From 53b733a902043f7ff52f35a22f558c038dcea099 Mon Sep 17 00:00:00 2001 From: SW van Heerden Date: Thu, 20 Jun 2024 09:41:13 +0200 Subject: [PATCH] review comments --- .../src/tari_address/dual_address.rs | 58 ++++++++++--------- .../common_types/src/tari_address/mod.rs | 22 ++++--- .../src/tari_address/single_address.rs | 52 +++++++++-------- 3 files changed, 72 insertions(+), 60 deletions(-) diff --git a/base_layer/common_types/src/tari_address/dual_address.rs b/base_layer/common_types/src/tari_address/dual_address.rs index 6c554440d4f..c7cc8242fba 100644 --- a/base_layer/common_types/src/tari_address/dual_address.rs +++ b/base_layer/common_types/src/tari_address/dual_address.rs @@ -157,19 +157,23 @@ impl DualAddress { /// Construct Tari Address from Base58 pub fn from_base58(hex_str: &str) -> Result { - if hex_str.len() < 3 { + if hex_str.len() != 91 { return Err(TariAddressError::InvalidSize); } let (first, rest) = hex_str.split_at(2); let (network, features) = first.split_at(1); - let mut network = bs58::decode(network).into_vec().map_err(|_| TariAddressError::CannotRecoverNetwork)?; - let mut features = bs58::decode(features).into_vec().map_err(|_| TariAddressError::CannotRecoverFeature)?; - if rest.is_empty(){ - return Err(TariAddressError::CannotRecoverPublicKey); - } - let mut rest = bs58::decode(rest).into_vec().map_err(|_| TariAddressError::CannotRecoverPublicKey)?; - network.append(&mut features);network.append(&mut rest); - Self::from_bytes(network.as_slice()) + let mut result = bs58::decode(network) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverNetwork)?; + let mut features = bs58::decode(features) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverFeature)?; + let mut rest = bs58::decode(rest) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverPublicKey)?; + result.append(&mut features); + result.append(&mut rest); + Self::from_bytes(result.as_slice()) } /// Convert Tari Address to Base58 string @@ -290,7 +294,7 @@ mod test { let address = DualAddress::new_with_default_features(view_key.clone(), spend_key.clone(), Network::Esmeralda); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = DualAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); @@ -298,11 +302,11 @@ mod test { assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = DualAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.public_view_key(), address.public_view_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = DualAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.public_view_key(), address.public_view_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); let view_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); let spend_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); @@ -316,7 +320,7 @@ mod test { ); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = DualAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); @@ -324,11 +328,11 @@ mod test { assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = DualAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.public_view_key(), address.public_view_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = DualAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.public_view_key(), address.public_view_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); let view_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); let spend_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); @@ -342,7 +346,7 @@ mod test { ); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = DualAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); @@ -350,11 +354,11 @@ mod test { assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = DualAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.public_view_key(), address.public_view_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = DualAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.public_view_key(), address.public_view_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); } #[test] diff --git a/base_layer/common_types/src/tari_address/mod.rs b/base_layer/common_types/src/tari_address/mod.rs index 635a3b42063..ae2c4aa6d30 100644 --- a/base_layer/common_types/src/tari_address/mod.rs +++ b/base_layer/common_types/src/tari_address/mod.rs @@ -218,19 +218,23 @@ impl TariAddress { /// Construct Tari Address from hex pub fn from_base58(hex_str: &str) -> Result { - if hex_str.len() < 3 { + if hex_str.len() < 47 { return Err(TariAddressError::InvalidSize); } let (first, rest) = hex_str.split_at(2); let (network, features) = first.split_at(1); - let mut network = bs58::decode(network).into_vec().map_err(|_| TariAddressError::CannotRecoverNetwork)?; - let mut features = bs58::decode(features).into_vec().map_err(|_| TariAddressError::CannotRecoverFeature)?; - if rest.is_empty(){ - return Err(TariAddressError::CannotRecoverPublicKey); - } - let mut rest = bs58::decode(rest).into_vec().map_err(|_| TariAddressError::CannotRecoverPublicKey)?; - network.append(&mut features);network.append(&mut rest); - Self::from_bytes(network.as_slice()) + let mut result = bs58::decode(network) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverNetwork)?; + let mut features = bs58::decode(features) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverFeature)?; + let mut rest = bs58::decode(rest) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverPublicKey)?; + result.append(&mut features); + result.append(&mut rest); + Self::from_bytes(result.as_slice()) } /// Convert Tari Address to bytes diff --git a/base_layer/common_types/src/tari_address/single_address.rs b/base_layer/common_types/src/tari_address/single_address.rs index e7172f77b90..a8a4dbbf792 100644 --- a/base_layer/common_types/src/tari_address/single_address.rs +++ b/base_layer/common_types/src/tari_address/single_address.rs @@ -140,19 +140,23 @@ impl SingleAddress { /// Construct Tari Address from Base58 pub fn from_base58(hex_str: &str) -> Result { - if hex_str.len() < 3 { + if hex_str.len() != 47 { return Err(TariAddressError::InvalidSize); } let (first, rest) = hex_str.split_at(2); let (network, features) = first.split_at(1); - let mut network = bs58::decode(network).into_vec().map_err(|_| TariAddressError::CannotRecoverNetwork)?; - let mut features = bs58::decode(features).into_vec().map_err(|_| TariAddressError::CannotRecoverFeature)?; - if rest.is_empty(){ - return Err(TariAddressError::CannotRecoverPublicKey); - } - let mut rest = bs58::decode(rest).into_vec().map_err(|_| TariAddressError::CannotRecoverPublicKey)?; - network.append(&mut features);network.append(&mut rest); - Self::from_bytes(network.as_slice()) + let mut result = bs58::decode(network) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverNetwork)?; + let mut features = bs58::decode(features) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverFeature)?; + let mut rest = bs58::decode(rest) + .into_vec() + .map_err(|_| TariAddressError::CannotRecoverPublicKey)?; + result.append(&mut features); + result.append(&mut rest); + Self::from_bytes(result.as_slice()) } /// Convert Tari Address to Base58 @@ -259,17 +263,17 @@ mod test { let address = SingleAddress::new_with_interactive_only(public_key.clone(), Network::Esmeralda); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = SingleAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = SingleAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = SingleAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); // Generate random public key let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); @@ -282,17 +286,17 @@ mod test { ); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = SingleAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = SingleAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = SingleAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); // Generate random public key let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng)); @@ -305,17 +309,17 @@ mod test { ); let buff = address.to_bytes(); - let hex = address.to_base58(); + let base58 = address.to_base58(); let address_buff = SingleAddress::from_bytes(&buff).unwrap(); assert_eq!(address_buff.public_spend_key(), address.public_spend_key()); assert_eq!(address_buff.network(), address.network()); assert_eq!(address_buff.features(), address.features()); - let address_hex = SingleAddress::from_base58(&hex).unwrap(); - assert_eq!(address_hex.public_spend_key(), address.public_spend_key()); - assert_eq!(address_hex.network(), address.network()); - assert_eq!(address_hex.features(), address.features()); + let address_base58 = SingleAddress::from_base58(&base58).unwrap(); + assert_eq!(address_base58.public_spend_key(), address.public_spend_key()); + assert_eq!(address_base58.network(), address.network()); + assert_eq!(address_base58.features(), address.features()); } #[test]