human readable uses bech32 from scenario

data/human-readable/Cargo.toml

@@ -16,7 +16,6 @@ categories = ["cryptography::cryptocurrencies", "development-tools"]
 
 [dependencies]
 serde_json = { version = "1.0.68" }
-bech32 = "0.9"
 
 [dependencies.multiversx-sc-scenario]
 version = "=0.53.0"

data/human-readable/src/decode.rs

@@ -5,8 +5,8 @@ use crate::{
     multiversx_sc::abi::{TypeContents, TypeDescription},
     SingleValue, StructField, StructValue,
 };
-use bech32::FromBase32;
 use multiversx_sc_scenario::{
+    bech32,
     multiversx_sc::abi::{ContractAbi, EnumVariantDescription, StructFieldDescription},
     num_bigint::{BigInt, BigUint},
 };
@@ -95,19 +95,11 @@ fn decode_single_value(
                 .as_str()
                 .ok_or_else(|| Box::new(DecodeError("expected string value")))?;
 
-            let (_, address_bytes_u5, _) = bech32::decode(str_value)
+            let address = bech32::try_decode(str_value)
                 .map_err(|_| Box::new(DecodeError("failed to parse address")))?;
-            let address_bytes = Vec::<u8>::from_base32(&address_bytes_u5)
-                .map_err(|_| Box::new(DecodeError("failed to parse address")))?;
-
-            if address_bytes.len() != 32 {
-                return Err(Box::new(DecodeError(
-                    "Invalid address length after decoding",
-                )));
-            }
 
             Ok(AnyValue::SingleValue(SingleValue::Bytes(
-                address_bytes.into(),
+                address.into_boxed_bytes().into_box(),
             )))
         },
         "bool" => {

data/human-readable/src/encode.rs

@@ -1,8 +1,11 @@
 use std::{error::Error, fmt::Display};
 
-use bech32::ToBase32;
-use multiversx_sc_scenario::multiversx_sc::abi::{
-    ContractAbi, EnumVariantDescription, StructFieldDescription, TypeContents, TypeDescription,
+use multiversx_sc_scenario::{
+    bech32,
+    imports::Address,
+    multiversx_sc::abi::{
+        ContractAbi, EnumVariantDescription, StructFieldDescription, TypeContents, TypeDescription,
+    },
 };
 use serde_json::{Map, Value as JsonValue};
 
@@ -99,10 +102,8 @@ fn encode_single_value(
                 return Err(Box::new(EncodeError("expected bytes value")));
             };
 
-            let address = bech32::encode("erd", value.to_base32(), bech32::Variant::Bech32)
-                .map_err(|_| Box::new(EncodeError("failed to encode address")))?;
-
-            Ok(JsonValue::String(address).into())
+            let bech32_addres_string = bech32::encode(&Address::from_slice(value));
+            Ok(JsonValue::String(bech32_addres_string).into())
         },
         "bool" => {
             let AnyValue::SingleValue(value) = input else {

data/human-readable/tests/single_value_tests.rs

@@ -1,9 +1,9 @@
-use bech32::FromBase32;
 use multiversx_sc_codec_human_readable::{
     decode_human_readable_value, default_value_for_abi_type, encode_human_readable_value,
     format::HumanReadableValue, AnyValue, SingleValue,
 };
 use multiversx_sc_scenario::{
+    bech32,
     meta::abi_json::deserialize_abi_from_json,
     multiversx_sc::{abi::ContractAbi, codec::top_encode_to_vec_u8},
 };
@@ -135,19 +135,17 @@ fn serialize_single_value_address() {
     let result = decode_human_readable_value(&value, "Address", &abi).unwrap();
     let serialized = top_encode_to_vec_u8(&result).unwrap();
 
-    let (_, address_bytes, _) = bech32::decode(TEST_ADDRESS).unwrap();
-    let address_bytes = Vec::<u8>::from_base32(&address_bytes).unwrap();
+    let address = bech32::decode(TEST_ADDRESS);
 
-    assert_eq!(serialized, address_bytes);
+    assert_eq!(serialized, address.into_boxed_bytes().into_vec());
 }
 
 #[test]
 fn deserialize_single_value_address() {
     let abi: ContractAbi = deserialize_abi_from_json(EMPTY_ABI_JSON).unwrap().into();
-    let (_, address_bytes, _) = bech32::decode(TEST_ADDRESS).unwrap();
-    let address_bytes = Vec::<u8>::from_base32(&address_bytes).unwrap();
+    let address = bech32::decode(TEST_ADDRESS);
 
-    let value = AnyValue::SingleValue(SingleValue::Bytes(address_bytes.into()));
+    let value = AnyValue::SingleValue(SingleValue::Bytes(address.into_boxed_bytes().into_box()));
     let result = encode_human_readable_value(&value, "Address", &abi).unwrap();
 
     assert_eq!(result.to_string(), format!("\"{}\"", TEST_ADDRESS));

framework/scenario/src/bech32.rs

@@ -1,14 +1,30 @@
+use std::{error::Error, fmt::Display};
+
 use bech32::{Bech32, Hrp};
 use multiversx_sc::types::heap::Address;
 
-pub fn decode(bech32_address: &str) -> Address {
-    let (_hrp, dest_address_bytes) = bech32::decode(bech32_address)
-        .unwrap_or_else(|err| panic!("bech32 decode error for {bech32_address}: {err}"));
+#[derive(Debug)]
+pub struct InvalidAddressLengthError;
+
+impl Display for InvalidAddressLengthError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        "Invalid address length after decoding".fmt(f)
+    }
+}
+
+impl Error for InvalidAddressLengthError {}
+
+pub fn try_decode(bech32_address: &str) -> Result<Address, Box<dyn Error>> {
+    let (_hrp, dest_address_bytes) = bech32::decode(bech32_address)?;
     if dest_address_bytes.len() != 32 {
-        panic!("Invalid address length after decoding")
+        return Err(Box::new(InvalidAddressLengthError));
     }
 
-    Address::from_slice(&dest_address_bytes)
+    Ok(Address::from_slice(&dest_address_bytes))
+}
+
+pub fn decode(bech32_address: &str) -> Address {
+    try_decode(bech32_address).expect("bech32 Address decode failed")
 }
 
 pub fn encode(address: &Address) -> String {