diff --git a/applications/minotari_console_wallet/src/ui/state/app_state.rs b/applications/minotari_console_wallet/src/ui/state/app_state.rs
index d233455aac..e38a810d91 100644
--- a/applications/minotari_console_wallet/src/ui/state/app_state.rs
+++ b/applications/minotari_console_wallet/src/ui/state/app_state.rs
@@ -23,6 +23,7 @@
 use std::{
     collections::{HashMap, VecDeque},
     path::PathBuf,
+    str::FromStr,
     sync::Arc,
     time::{Duration, Instant},
 };
@@ -61,7 +62,7 @@ use tari_core::transactions::{
     weight::TransactionWeight,
 };
 use tari_shutdown::ShutdownSignal;
-use tari_utilities::hex::{from_hex, Hex};
+use tari_utilities::hex::Hex;
 use tokio::{
     sync::{broadcast, watch, RwLock},
     task,
@@ -229,11 +230,7 @@ impl AppState {
     pub async fn upsert_contact(&mut self, alias: String, tari_emoji: String) -> Result<(), UiError> {
         let mut inner = self.inner.write().await;
 
-        let address = match TariAddress::from_emoji_string(&tari_emoji) {
-            Ok(address) => address,
-            Err(_) => TariAddress::from_bytes(&from_hex(&tari_emoji).map_err(|_| UiError::PublicKeyParseError)?)
-                .map_err(|_| UiError::PublicKeyParseError)?,
-        };
+        let address = TariAddress::from_str(&tari_emoji).map_err(|_| UiError::PublicKeyParseError)?;
 
         let contact = Contact::new(alias, address, None, None, false);
         inner.wallet.contacts_service.upsert_contact(contact).await?;
@@ -246,26 +243,22 @@ impl AppState {
 
     // Return alias or pub key if the contact is not in the list.
     pub fn get_alias(&self, address: &TariAddress) -> String {
-        let address_hex = address.to_base58();
+        let address_string = address.to_base58();
 
         match self
             .cached_data
             .contacts
             .iter()
-            .find(|&contact| contact.address.eq(&address_hex))
+            .find(|&contact| contact.address.eq(&address_string))
         {
             Some(contact) => contact.alias.clone(),
-            None => address_hex,
+            None => address_string,
         }
     }
 
     pub async fn delete_contact(&mut self, tari_emoji: String) -> Result<(), UiError> {
         let mut inner = self.inner.write().await;
-        let address = match TariAddress::from_emoji_string(&tari_emoji) {
-            Ok(address) => address,
-            Err(_) => TariAddress::from_bytes(&from_hex(&tari_emoji).map_err(|_| UiError::PublicKeyParseError)?)
-                .map_err(|_| UiError::PublicKeyParseError)?,
-        };
+        let address = TariAddress::from_str(&tari_emoji).map_err(|_| UiError::PublicKeyParseError)?;
 
         inner.wallet.contacts_service.remove_contact(address).await?;
 
@@ -301,11 +294,7 @@ impl AppState {
         result_tx: watch::Sender<UiTransactionSendStatus>,
     ) -> Result<(), UiError> {
         let inner = self.inner.write().await;
-        let address = match TariAddress::from_emoji_string(&address) {
-            Ok(address) => address,
-            Err(_) => TariAddress::from_bytes(&from_hex(&address).map_err(|_| UiError::PublicKeyParseError)?)
-                .map_err(|_| UiError::PublicKeyParseError)?,
-        };
+        let address = TariAddress::from_str(&address).map_err(|_| UiError::PublicKeyParseError)?;
 
         let output_features = OutputFeatures { ..Default::default() };
 
@@ -336,11 +325,7 @@ impl AppState {
         result_tx: watch::Sender<UiTransactionSendStatus>,
     ) -> Result<(), UiError> {
         let inner = self.inner.write().await;
-        let address = match TariAddress::from_emoji_string(&address) {
-            Ok(address) => address,
-            Err(_) => TariAddress::from_bytes(&from_hex(&address).map_err(|_| UiError::PublicKeyParseError)?)
-                .map_err(|_| UiError::PublicKeyParseError)?,
-        };
+        let address = TariAddress::from_str(&address).map_err(|_| UiError::PublicKeyParseError)?;
         let payment_id_u64: u64 = payment_id_hex
             .parse::<u64>()
             .map_err(|_| UiError::HexError("Could not convert payment_id to bytes".to_string()))?;
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 aee086e3de..db591aebbf 100644
--- a/base_layer/common_types/src/tari_address/dual_address.rs
+++ b/base_layer/common_types/src/tari_address/dual_address.rs
@@ -25,6 +25,7 @@ use std::convert::TryFrom;
 use serde::{Deserialize, Serialize};
 use tari_common::configuration::Network;
 use tari_crypto::tari_utilities::ByteArray;
+use tari_utilities::hex::{from_hex, Hex};
 
 use crate::{
     dammsum::{compute_checksum, validate_checksum},
@@ -187,6 +188,18 @@ impl DualAddress {
         network.push_str(&rest);
         network
     }
+
+    /// Convert Tari dual Address to hex
+    pub fn to_hex(&self) -> String {
+        let buf = self.to_bytes();
+        buf.to_hex()
+    }
+
+    /// Creates Tari dual Address from hex
+    pub fn from_hex(hex_str: &str) -> Result<DualAddress, TariAddressError> {
+        let buf = from_hex(hex_str).map_err(|_| TariAddressError::CannotRecoverPublicKey)?;
+        DualAddress::from_bytes(buf.as_slice())
+    }
 }
 
 #[cfg(test)]
@@ -296,6 +309,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = DualAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -309,6 +324,18 @@ mod test {
         assert_eq!(address_base58.network(), address.network());
         assert_eq!(address_base58.features(), address.features());
 
+        let address_hex = DualAddress::from_hex(&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_emoji = DualAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.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));
 
@@ -322,6 +349,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = DualAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -335,6 +364,18 @@ mod test {
         assert_eq!(address_base58.network(), address.network());
         assert_eq!(address_base58.features(), address.features());
 
+        let address_hex = DualAddress::from_hex(&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_emoji = DualAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.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));
 
@@ -348,6 +389,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = DualAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -360,6 +403,18 @@ mod test {
         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 address_hex = DualAddress::from_hex(&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_emoji = DualAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.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 ae2c4aa6d3..424dabac17 100644
--- a/base_layer/common_types/src/tari_address/mod.rs
+++ b/base_layer/common_types/src/tari_address/mod.rs
@@ -32,6 +32,7 @@ use bitflags::bitflags;
 use serde::{Deserialize, Serialize};
 use tari_common::configuration::Network;
 use tari_crypto::tari_utilities::ByteArray;
+use tari_utilities::hex::{from_hex, Hex};
 use thiserror::Error;
 
 use crate::{
@@ -247,6 +248,18 @@ impl TariAddress {
         network.push_str(&rest);
         network
     }
+
+    /// Convert Tari Address to hex
+    pub fn to_hex(&self) -> String {
+        let buf = self.to_vec();
+        buf.to_hex()
+    }
+
+    /// Creates Tari Address from hex
+    pub fn from_hex(hex_str: &str) -> Result<TariAddress, TariAddressError> {
+        let buf = from_hex(hex_str).map_err(|_| TariAddressError::CannotRecoverPublicKey)?;
+        TariAddress::from_bytes(buf.as_slice())
+    }
 }
 
 impl FromStr for TariAddress {
@@ -257,6 +270,8 @@ impl FromStr for TariAddress {
             Ok(address)
         } else if let Ok(address) = TariAddress::from_base58(key) {
             Ok(address)
+        } else if let Ok(address) = TariAddress::from_hex(key) {
+            Ok(address)
         } else {
             Err(TariAddressError::InvalidAddressString)
         }
@@ -461,7 +476,9 @@ mod test {
         let address = TariAddress::new_single_address_with_interactive_only(public_key.clone(), Network::Esmeralda);
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff);
         assert_eq!(address_buff, Ok(address.clone()));
@@ -471,11 +488,28 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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());
+
+        let address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
+
         // Generate random public key
         let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -487,7 +521,9 @@ mod test {
         );
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff);
         assert_eq!(address_buff, Ok(address.clone()));
@@ -497,10 +533,27 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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());
+
+        let address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
         // Generate random public key
         let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -512,7 +565,9 @@ mod test {
         );
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff);
         assert_eq!(address_buff, Ok(address.clone()));
@@ -522,10 +577,27 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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());
+
+        let address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
     }
 
     #[test]
@@ -544,7 +616,9 @@ mod test {
         );
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -552,12 +626,31 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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 address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
+
         let view_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
         let spend_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -570,7 +663,9 @@ mod test {
         );
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -578,12 +673,31 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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 address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
+
         let view_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
         let spend_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -596,7 +710,9 @@ mod test {
         );
 
         let buff = address.to_vec();
-        let hex = address.to_base58();
+        let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = TariAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -604,11 +720,30 @@ mod test {
         assert_eq!(address_buff.network(), address.network());
         assert_eq!(address_buff.features(), address.features());
 
-        let address_hex = TariAddress::from_base58(&hex).unwrap();
+        let address_base58 = TariAddress::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 address_hex = TariAddress::from_hex(&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_emoji = TariAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.public_view_key(), address.public_view_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
+        let address_base58_string = TariAddress::from_str(&base58).unwrap();
+        assert_eq!(address_base58_string, address_base58);
+        let address_hex_string = TariAddress::from_str(&hex).unwrap();
+        assert_eq!(address_hex_string, address_hex);
+        let address_emoji_string = TariAddress::from_str(&emoji).unwrap();
+        assert_eq!(address_emoji_string, address_emoji);
     }
 
     #[test]
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 afba371983..5553fc0dcb 100644
--- a/base_layer/common_types/src/tari_address/single_address.rs
+++ b/base_layer/common_types/src/tari_address/single_address.rs
@@ -25,6 +25,7 @@ use std::convert::TryFrom;
 use serde::{Deserialize, Serialize};
 use tari_common::configuration::Network;
 use tari_crypto::tari_utilities::ByteArray;
+use tari_utilities::hex::{from_hex, Hex};
 
 use crate::{
     dammsum::{compute_checksum, validate_checksum},
@@ -170,6 +171,18 @@ impl SingleAddress {
         network.push_str(&rest);
         network
     }
+
+    /// Convert Tari single Address to hex
+    pub fn to_hex(&self) -> String {
+        let buf = self.to_bytes();
+        buf.to_hex()
+    }
+
+    /// Creates Tari single Address from hex
+    pub fn from_hex(hex_str: &str) -> Result<SingleAddress, TariAddressError> {
+        let buf = from_hex(hex_str).map_err(|_| TariAddressError::CannotRecoverPublicKey)?;
+        SingleAddress::from_bytes(buf.as_slice())
+    }
 }
 #[cfg(test)]
 mod test {
@@ -265,6 +278,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = SingleAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -276,6 +291,16 @@ mod test {
         assert_eq!(address_base58.network(), address.network());
         assert_eq!(address_base58.features(), address.features());
 
+        let address_hex = SingleAddress::from_hex(&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_emoji = SingleAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
         // Generate random public key
         let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -288,6 +313,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = SingleAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -299,6 +326,16 @@ mod test {
         assert_eq!(address_base58.network(), address.network());
         assert_eq!(address_base58.features(), address.features());
 
+        let address_hex = SingleAddress::from_hex(&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_emoji = SingleAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
+
         // Generate random public key
         let public_key = PublicKey::from_secret_key(&PrivateKey::random(&mut rng));
 
@@ -311,6 +348,8 @@ mod test {
 
         let buff = address.to_bytes();
         let base58 = address.to_base58();
+        let hex = address.to_hex();
+        let emoji = address.to_emoji_string();
 
         let address_buff = SingleAddress::from_bytes(&buff).unwrap();
         assert_eq!(address_buff.public_spend_key(), address.public_spend_key());
@@ -321,6 +360,16 @@ mod test {
         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());
+
+        let address_hex = SingleAddress::from_hex(&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_emoji = SingleAddress::from_emoji_string(&emoji).unwrap();
+        assert_eq!(address_emoji.public_spend_key(), address.public_spend_key());
+        assert_eq!(address_emoji.network(), address.network());
+        assert_eq!(address_emoji.features(), address.features());
     }
 
     #[test]
diff --git a/base_layer/wallet_ffi/wallet.h b/base_layer/wallet_ffi/wallet.h
index f4b52306ef..753b157a6c 100644
--- a/base_layer/wallet_ffi/wallet.h
+++ b/base_layer/wallet_ffi/wallet.h
@@ -741,7 +741,7 @@ struct ByteVector *tari_address_get_bytes(TariWalletAddress *address,
  * The ```public_key_destroy``` method must be called when finished with a TariWalletAddress to prevent a memory leak
  */
 TariWalletAddress *tari_address_from_base58(const char *address,
-                                         int *error_out);
+                                            int *error_out);
 
 /**
  * Creates a char array from a TariWalletAddress in emoji format