From 4955e21992a414e1bc2d1ffcb28af5d73db21fdd Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Tue, 20 Feb 2024 18:43:04 +0100 Subject: [PATCH] WIP: addressesm JSON roundtrop fails for addresses --- .../v100/address/access_controller_address.rs | 99 ---------- .../v100/address/accesscontroller_address.rs | 176 ++++++++++++++++++ src/profile/v100/address/account_address.rs | 2 +- src/profile/v100/address/component_address.rs | 31 ++- src/profile/v100/address/mod.rs | 4 +- src/profile/v100/address/vault_address.rs | 82 ++++++-- src/profile/v100/address/wrap_ret_address.rs | 2 +- 7 files changed, 274 insertions(+), 122 deletions(-) delete mode 100644 src/profile/v100/address/access_controller_address.rs create mode 100644 src/profile/v100/address/accesscontroller_address.rs diff --git a/src/profile/v100/address/access_controller_address.rs b/src/profile/v100/address/access_controller_address.rs deleted file mode 100644 index 761fef78a..000000000 --- a/src/profile/v100/address/access_controller_address.rs +++ /dev/null @@ -1,99 +0,0 @@ -use crate::prelude::*; - -#[derive( - Clone, - Debug, - PartialEq, - Eq, - Hash, - derive_more::FromStr, - derive_more::Display, - SerializeDisplay, - DeserializeFromStr, - uniffi::Record, -)] -#[display("{__inner}")] -pub struct AccessControllerAddress { - pub(crate) __inner: InnerAccessControllerAddress, -} - -#[cfg(test)] -mod tests { - use crate::prelude::*; - - #[allow(clippy::upper_case_acronyms)] - type SUT = AccessControllerAddress; - - #[test] - fn display() { - let s = "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"; - let a = SUT::try_from_bech32(s).unwrap(); - assert_eq!(format!("{a}"), s); - } - - #[test] - fn json_roundtrip() { - let a: SUT = - "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd" - .parse() - .unwrap(); - - assert_json_value_eq_after_roundtrip( - &a, - json!("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"), - ); - assert_json_roundtrip(&a); - assert_json_value_ne_after_roundtrip( - &a, - json!("resource_rdx1tkk83magp3gjyxrpskfsqwkg4g949rmcjee4tu2xmw93ltw2cz94sq"), - ); - } - - #[test] - fn json_roundtrip_fails_for_invalid() { - assert_json_value_fails::( - json!("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxxx") - ); - assert_json_value_fails::( - json!("account_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd") - ); - assert_json_value_fails::(json!("super invalid")); - } - - #[test] - fn network_id_stokenet() { - let a: SUT = - "resource_tdx_2_1tkckx9fynl9f7756z8wxphq7wce6vk874nuq4f2nnxgh3nzrwhjdlp" - .parse() - .unwrap(); - assert_eq!(a.network_id(), NetworkID::Stokenet); - } - - #[test] - fn network_id_mainnet() { - let a: SUT = - "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd" - .parse() - .unwrap(); - assert_eq!(a.network_id(), NetworkID::Mainnet); - } -} - -#[cfg(test)] -mod uniffi_tests { - use crate::prelude::*; - - use super::*; - - #[allow(clippy::upper_case_acronyms)] - type SUT = AccessControllerAddress; - - #[test] - fn new() { - let s = "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"; - let a = SUT::try_from_bech32(s).unwrap(); - let b = new_access_controller_address(s.to_string()).unwrap(); - assert_eq!(b.address(), s); - assert_eq!(a, b); - } -} diff --git a/src/profile/v100/address/accesscontroller_address.rs b/src/profile/v100/address/accesscontroller_address.rs new file mode 100644 index 000000000..59296be95 --- /dev/null +++ b/src/profile/v100/address/accesscontroller_address.rs @@ -0,0 +1,176 @@ +use crate::prelude::*; + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + Hash, + derive_more::FromStr, + derive_more::Display, + SerializeDisplay, + DeserializeFromStr, + uniffi::Record, +)] +#[display("{__inner}")] +pub struct AccessControllerAddress { + pub(crate) __inner: InnerAccessControllerAddress, +} + +impl HasPlaceholder for AccessControllerAddress { + fn placeholder() -> Self { + Self::placeholder_mainnet() + } + + fn placeholder_other() -> Self { + Self::placeholder_stokenet() + } +} + +impl AccessControllerAddress { + /* + these should all be valid + [ + "accesscontroller_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a", + "accesscontroller_rdx1cv93xuha64eay8ctkx9km0el2jgkuh6gqlwec7tzecccyu0rj37xak", + "accesscontroller_rdx1cva6mtja4crwxxhmd63q2xlhew7fh0af67zw3snhzj8cm7xq2cm06g", + "accesscontroller_rdx1cvlu8kvmqu56arywyzkkewyuv7mdg448d69k083dpq0nvrd44me6qd", + "accesscontroller_rdx1cw9383xuqx6cme0knucw5aggknvrqmc8lzu7jcn3kwherk8x55zmtt", + "accesscontroller_rdx1cwggxzkqxwg9zjhv3jvyvkcn2hl7gxgwgjeqxl2d7xyuyx3tklg77y", + "accesscontroller_rdx1cwtvlhhg0pwyrlcujv9gv2adastmcc03ewg9vww8ke3s5t9gjf7jmp", + "accesscontroller_rdx1cwufa4a2j7klu5hh72uwxvd9gyevxfuxspxynne7fqnnzzr7nh4uya" + ] + and these: + accesscontroller_rdx1c0llllllllllllllllllllllllllllllllllllllllllllllkl2v3s + accesscontroller_rdx1cvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq09959m + + from GW: + accesscontroller_rdx1cw9383xuqx6cme0knucw5aggknvrqmc8lzu7jcn3kwherk8x55zmtt + accesscontroller_tdx_2_1cw68j9ca4fye09mz3hshp4qydjnxhsahm68hvmz9cjhftcz9f53juq + + Working roundtrip test from OA: + #[test] + fn access_controller() { + let address = CanonicalAccessControllerAddress::from_str("accesscontroller_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a").unwrap(); + assert_eq!(CanonicalAccessControllerAddress::from_str(&address.to_string()).unwrap().to_string(), "accesscontroller_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a"); + } + */ + pub fn placeholder_mainnet() -> Self { + "accesscontroller_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a".parse().expect("Placeholder") + } + + pub fn placeholder_stokenet() -> Self { + "accesscontroller_tdx_2_1c0llllllllllllllllllllllllllllllllllllllllllllllhcg0ny".parse().expect("Placeholder") + } +} + +#[cfg(test)] +mod tests { + use radix_engine_toolkit::models::canonical_address_types::CanonicalAccessControllerAddress; + + use crate::prelude::*; + + #[allow(clippy::upper_case_acronyms)] + type SUT = AccessControllerAddress; + + #[test] + fn equality() { + assert_eq!(SUT::placeholder(), SUT::placeholder()); + assert_eq!(SUT::placeholder_other(), SUT::placeholder_other()); + } + + #[test] + fn inequality() { + assert_ne!(SUT::placeholder(), SUT::placeholder_other()); + } + + #[test] + fn display() { + let s = "accesscontroller_rdx1cw9383xuqx6cme0knucw5aggknvrqmc8lzu7jcn3kwherk8x55zmtt"; + let a = SUT::try_from_bech32(s).unwrap(); + assert_eq!(format!("{a}"), s); + } + + #[test] + fn json_roundtrip() { + let a: SUT = + "accesscontroller_rdx1cw9383xuqx6cme0knucw5aggknvrqmc8lzu7jcn3kwherk8x55zmtt" + .parse() + .unwrap(); + + assert_json_value_eq_after_roundtrip( + &a, + json!("accesscontroller_rdx1cw9383xuqx6cme0knucw5aggknvrqmc8lzu7jcn3kwherk8x55zmtt"), + ); + assert_json_roundtrip(&a); + assert_json_value_ne_after_roundtrip( + &a, + json!("resource_rdx1tkk83magp3gjyxrpskfsqwkg4g949rmcjee4tu2xmw93ltw2cz94sq"), + ); + } + + #[test] + fn json_roundtrip_fails_for_invalid() { + assert_json_value_fails::( + json!("accesscontroller_rdx1c0llllllllllllllllllllllllllllllllllllllllllllllkl2v3s") + ); + assert_json_value_fails::( + json!("account_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a") + ); + assert_json_value_fails::(json!("super invalid")); + } + + #[test] + fn network_id_stokenet() { + let a: SUT = + "accesscontroller_tdx_2_1c0llllllllllllllllllllllllllllllllllllllllllllllhcg0ny" + .parse() + .unwrap(); + assert_eq!(a.network_id(), NetworkID::Stokenet); + } + + #[test] + fn network_id_mainnet() { + let a: SUT = + "accesscontroller_rdx1c0llllllllllllllllllllllllllllllllllllllllllllllkl2v3s" + .parse() + .unwrap(); + assert_eq!(a.network_id(), NetworkID::Mainnet); + } + + #[test] + fn access_controller() { + let address = CanonicalAccessControllerAddress::from_str("accesscontroller_rdx1c0duj4lq0dc3cpl8qd420fpn5eckh8ljeysvjm894lyl5ja5yq6y5a").unwrap(); + println!("{address}"); + } +} + +#[cfg(test)] +mod uniffi_tests { + use crate::prelude::*; + + use super::*; + + #[allow(clippy::upper_case_acronyms)] + type SUT = AccessControllerAddress; + + #[test] + fn new_from_bech32_get_network_id_and_address() { + let b32 = "accesscontroller_rdx1c0llllllllllllllllllllllllllllllllllllllllllllllkl2v3s"; + let address = new_accesscontroller_address(b32.to_owned()).unwrap(); + assert_eq!( + accesscontroller_address_network_id(&address), + NetworkID::Mainnet + ); + assert_eq!(accesscontroller_address_bech32_address(&address), b32); + } + + #[test] + fn new() { + let s = "accesscontroller_rdx1c0llllllllllllllllllllllllllllllllllllllllllllllkl2v3s"; + let a = SUT::try_from_bech32(s).unwrap(); + let b = new_accesscontroller_address(s.to_string()).unwrap(); + assert_eq!(b.address(), s); + assert_eq!(a, b); + } +} diff --git a/src/profile/v100/address/account_address.rs b/src/profile/v100/address/account_address.rs index efeae10d6..1b8b01d41 100644 --- a/src/profile/v100/address/account_address.rs +++ b/src/profile/v100/address/account_address.rs @@ -72,7 +72,7 @@ impl AccountAddress { /// `account_rdx16xlfcpp0vf7e3gqnswv8j9k58n6rjccu58vvspmdva22kf3aplease` /// pub fn short(&self) -> String { - let suffix = suffix_str(6, &self.address()); + let suffix = suffix_str(6, self.address()); format!("{}...{}", &self.address()[0..4], suffix) } } diff --git a/src/profile/v100/address/component_address.rs b/src/profile/v100/address/component_address.rs index f295c5c5c..2872377a0 100644 --- a/src/profile/v100/address/component_address.rs +++ b/src/profile/v100/address/component_address.rs @@ -56,13 +56,38 @@ mod tests { #[test] fn equality() { - assert_eq!(SUT::placeholder(), SUT::placeholder()); - assert_eq!(SUT::placeholder_other(), SUT::placeholder_other()); + assert_eq!( + SUT::placeholder_mainnet_internal(), + SUT::placeholder_mainnet_internal() + ); + assert_eq!( + SUT::placeholder_mainnet_global(), + SUT::placeholder_mainnet_global() + ); + assert_eq!( + SUT::placeholder_stokenet_internal(), + SUT::placeholder_stokenet_internal() + ); + assert_eq!( + SUT::placeholder_stokenet_global(), + SUT::placeholder_stokenet_global() + ); } #[test] fn inequality() { - assert_ne!(SUT::placeholder(), SUT::placeholder_other()); + assert_ne!( + SUT::placeholder_mainnet_internal(), + SUT::placeholder_mainnet_global() + ); + assert_ne!( + SUT::placeholder_stokenet_internal(), + SUT::placeholder_mainnet_internal() + ); + assert_ne!( + SUT::placeholder_stokenet_global(), + SUT::placeholder_mainnet_global() + ); } #[test] diff --git a/src/profile/v100/address/mod.rs b/src/profile/v100/address/mod.rs index b38c92e63..60c174630 100644 --- a/src/profile/v100/address/mod.rs +++ b/src/profile/v100/address/mod.rs @@ -1,4 +1,4 @@ -mod access_controller_address; +mod accesscontroller_address; mod account_address; mod component_address; mod entity_address; @@ -12,7 +12,7 @@ mod validator_address; mod vault_address; mod wrap_ret_address; -pub use access_controller_address::*; +pub use accesscontroller_address::*; pub use account_address::*; pub use component_address::*; diff --git a/src/profile/v100/address/vault_address.rs b/src/profile/v100/address/vault_address.rs index 42f467ad4..aa9e9b144 100644 --- a/src/profile/v100/address/vault_address.rs +++ b/src/profile/v100/address/vault_address.rs @@ -17,27 +17,69 @@ pub struct VaultAddress { pub(crate) __inner: InnerVaultAddress, } +impl VaultAddress { + pub fn placeholder_mainnet_fungible() -> Self { + "internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d".parse().expect("Placeholder") + } + + pub fn placeholder_mainnet_non_fungible() -> Self { + "internal_vault_rdx1tz474x29nxxd4k2p2reete9xyz4apawv63dphxkr00qt23vyju49fq".parse().expect("Placeholder") + } + + pub fn placeholder_stokenet_fungible() -> Self { + "internal_vault_tdx_2_1tqulaapn7etkm8d7h7h2dl5wn32dhmgj942mjc8g4jm9qajga6e40s".parse().expect("Placeholder") + } + + pub fn placeholder_stokenet_non_fungible() -> Self { + "internal_vault_tdx_2_1npcfs62psk2r8fnchjfrc5fepk7defxzl5c4ngsun9h0svf5zts4te".parse().expect("Placeholder") + } +} + +impl HasPlaceholder for VaultAddress { + fn placeholder() -> Self { + Self::placeholder_mainnet_fungible() + } + + fn placeholder_other() -> Self { + Self::placeholder_mainnet_non_fungible() + } +} + #[cfg(test)] mod tests { use crate::prelude::*; + #[allow(clippy::upper_case_acronyms)] + type SUT = AccountAddress; + + #[test] + fn equality() { + assert_eq!(SUT::placeholder(), SUT::placeholder()); + assert_eq!(SUT::placeholder_other(), SUT::placeholder_other()); + } + + #[test] + fn inequality() { + assert_ne!(SUT::placeholder(), SUT::placeholder_other()); + } + #[test] fn display() { - let s = "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"; - let a = VaultAddress::try_from_bech32(s).unwrap(); + let s = "internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d"; + let a = SUT::try_from_bech32(s).unwrap(); assert_eq!(format!("{a}"), s); } #[test] fn json_roundtrip() { - let a: VaultAddress = - "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd" + let a: SUT = + "internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d" .parse() .unwrap(); assert_json_value_eq_after_roundtrip( &a, - json!("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"), + json!("internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d"), ); assert_json_roundtrip(&a); assert_json_value_ne_after_roundtrip( @@ -48,19 +90,19 @@ mod tests { #[test] fn json_roundtrip_fails_for_invalid() { - assert_json_value_fails::( - json!("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxxx") + assert_json_value_fails::( + json!("internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3e") ); - assert_json_value_fails::( - json!("account_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd") + assert_json_value_fails::( + json!("account_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d") ); - assert_json_value_fails::(json!("super invalid")); + assert_json_value_fails::(json!("super invalid")); } #[test] fn network_id_stokenet() { - let a: VaultAddress = - "resource_tdx_2_1tkckx9fynl9f7756z8wxphq7wce6vk874nuq4f2nnxgh3nzrwhjdlp" + let a: SUT = + "internal_vault_tdx_2_1tqulaapn7etkm8d7h7h2dl5wn32dhmgj942mjc8g4jm9qajga6e40s" .parse() .unwrap(); assert_eq!(a.network_id(), NetworkID::Stokenet); @@ -68,8 +110,8 @@ mod tests { #[test] fn network_id_mainnet() { - let a: VaultAddress = - "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd" + let a: SUT = + "internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d" .parse() .unwrap(); assert_eq!(a.network_id(), NetworkID::Mainnet); @@ -85,10 +127,18 @@ mod uniffi_tests { #[allow(clippy::upper_case_acronyms)] type SUT = VaultAddress; + #[test] + fn new_from_bech32_get_network_id_and_address() { + let b32 = "internal_vault_rdx1nz8nsf78zrrxq7r2r059vzsnmleawr36470chegf84p06fhze6wq3d"; + let address = new_vault_address(b32.to_owned()).unwrap(); + assert_eq!(vault_address_network_id(&address), NetworkID::Mainnet); + assert_eq!(vault_address_bech32_address(&address), b32); + } + #[test] fn new() { - let s = "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd"; - let a = VaultAddress::try_from_bech32(s).unwrap(); + let s = "internal_vault_rdx1tz474x29nxxd4k2p2reete9xyz4apawv63dphxkr00qt23vyju49fq"; + let a = SUT::try_from_bech32(s).unwrap(); let b = new_vault_address(s.to_string()).unwrap(); assert_eq!(b.address(), s); assert_eq!(a, b); diff --git a/src/profile/v100/address/wrap_ret_address.rs b/src/profile/v100/address/wrap_ret_address.rs index 73d852a28..e49838256 100644 --- a/src/profile/v100/address/wrap_ret_address.rs +++ b/src/profile/v100/address/wrap_ret_address.rs @@ -145,7 +145,7 @@ macro_rules! decl_ret_wrapped_address { decl_ret_wrapped_address!( AccessControllerAddress, RetAccessControllerAddress, - access_controller + accesscontroller ); decl_ret_wrapped_address!(AccountAddress, RetAccountAddress, account); decl_ret_wrapped_address!(ComponentAddress, RetComponentAddress, component);