diff --git a/Cargo.toml b/Cargo.toml
index de9cc3e5..f2068f61 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,28 +1,26 @@
 [package]
-name          = "safe_dns"
-version       = "0.3.1"
-authors       = ["MaidSafe Developers <dev@maidsafe.net>"]
-description   = "SAFE DNS API library"
+authors = ["MaidSafe Developers <dev@maidsafe.net>"]
+description = "SAFE DNS API library"
 documentation = "http://maidsafe.net/safe_dns/latest"
-repository    = "https://github.com/maidsafe/safe_dns"
-readme        = "README.md"
-license       = "GPL-3.0"
-homepage      = "http://maidsafe.net"
+homepage = "http://maidsafe.net"
+license = "GPL-3.0"
+name = "safe_dns"
+readme = "README.md"
+repository = "https://github.com/maidsafe/safe_dns"
+version = "0.3.1"
 
 [dependencies]
-# ---- Maidsafe ----
-routing         = "~0.4.2"
-safe_nfs        = "~0.3.1"
-safe_core       = "~0.3.1"
-
-# ---- Others ----
-log             = "~0.3.3"
-sodiumoxide     = "~0.0.9"
+log = "~0.3.4"
+maidsafe_utilities = "~0.1.5"
+routing = "~0.5.2"
 rustc-serialize = "~0.3.16"
+safe_core = "~0.4.0"
+safe_nfs = "~0.4.0"
+sodiumoxide = "~0.0.9"
+xor_name = "~0.0.1"
 
 [dev-dependencies]
-regex = "~0.1.41"
+regex = "~0.1.44"
 
 [features]
-use-mock-routing = ["safe_core/use-mock-routing",
-                    "safe_nfs/use-mock-routing"]
+use-mock-routing = ["safe_core/use-mock-routing", "safe_nfs/use-mock-routing"]
diff --git a/examples/simulate_browser.rs b/examples/simulate_browser.rs
index ab3b8216..df65630c 100644
--- a/examples/simulate_browser.rs
+++ b/examples/simulate_browser.rs
@@ -18,9 +18,12 @@
 extern crate regex;
 extern crate routing;
 extern crate safe_dns;
+extern crate safe_core;
 extern crate safe_nfs;
 extern crate sodiumoxide;
-#[macro_use] extern crate safe_core;
+#[macro_use] extern crate maidsafe_utilities;
+
+use routing::Data;
 
 const DEFAULT_SERVICE: &'static str = "www";
 const HOME_PAGE_FILE_NAME: &'static str = "index.html";
@@ -52,7 +55,7 @@ fn handle_login() -> std::sync::Arc<std::sync::Mutex<safe_core::client::Client>>
     // Account Creation
     {
         println!("\nTrying to create an account ...");
-        let _ = eval_result!(safe_core::client::Client::create_account(keyword.clone(), pin.clone(), password.clone()));
+        let _ = unwrap_result!(safe_core::client::Client::create_account(keyword.clone(), pin.clone(), password.clone()));
         println!("Account Creation Successful !!");
     }
 
@@ -61,7 +64,7 @@ fn handle_login() -> std::sync::Arc<std::sync::Mutex<safe_core::client::Client>>
 
     // Log into the created account
     println!("\nTrying to log into the created account using supplied credentials ...");
-    std::sync::Arc::new(std::sync::Mutex::new(eval_result!(safe_core::client::Client::log_in(keyword, pin, password))))
+    std::sync::Arc::new(std::sync::Mutex::new(unwrap_result!(safe_core::client::Client::log_in(keyword, pin, password))))
 }
 
 fn create_dns_record(client        : std::sync::Arc<std::sync::Mutex<safe_core::client::Client>>,
@@ -87,7 +90,7 @@ fn create_dns_record(client        : std::sync::Arc<std::sync::Mutex<safe_core::
                                                            owners,
                                                            &secret_signing_key,
                                                            None));
-    Ok(try!(eval_result!(client.lock()).put(routing::data::Data::StructuredData(dns_struct_data), None)))
+    Ok(try!(unwrap_result!(client.lock()).put(Data::StructuredData(dns_struct_data), None)))
 }
 
 fn delete_dns_record(client        : std::sync::Arc<std::sync::Mutex<safe_core::client::Client>>,
@@ -104,7 +107,7 @@ fn delete_dns_record(client        : std::sync::Arc<std::sync::Mutex<safe_core::
     println!("Deleting Dns...");
 
     let dns_struct_data = try!(dns_operations.delete_dns(&long_name, &secret_signing_key));
-    Ok(try!(eval_result!(client.lock()).delete(routing::data::Data::StructuredData(dns_struct_data), None)))
+    Ok(try!(unwrap_result!(client.lock()).delete(Data::StructuredData(dns_struct_data), None)))
 }
 
 fn display_dns_records(dns_operations: &safe_dns::dns_operations::DnsOperations) -> Result<(), safe_dns::errors::DnsError> {
@@ -164,7 +167,8 @@ fn add_service(client        : std::sync::Arc<std::sync::Mutex<safe_core::client
                                                       (service_name, dir_key.clone()),
                                                       &secret_signing_key,
                                                       None));
-    Ok(client.lock().unwrap().post(routing::data::Data::StructuredData(struct_data), None))
+
+    Ok(try!(client.lock().unwrap().post(Data::StructuredData(struct_data), None)))
 }
 
 fn remove_service(client        : std::sync::Arc<std::sync::Mutex<safe_core::client::Client>>,
@@ -185,7 +189,7 @@ fn remove_service(client        : std::sync::Arc<std::sync::Mutex<safe_core::cli
 
     let secret_signing_key = try!(client.lock().unwrap().get_secret_signing_key()).clone();
     let struct_data = try!(dns_operations.remove_service(&long_name, service_name, &secret_signing_key, None));
-    Ok(client.lock().unwrap().post(routing::data::Data::StructuredData(struct_data), None))
+    Ok(try!(client.lock().unwrap().post(Data::StructuredData(struct_data), None)))
 }
 
 fn display_services(dns_operations: &safe_dns::dns_operations::DnsOperations) -> Result<(), safe_dns::errors::DnsError> {
@@ -259,14 +263,14 @@ fn parse_url_and_get_home_page(client        : std::sync::Arc<std::sync::Mutex<s
 
 fn main() {
     let client = handle_login();
-    let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_core
+    let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(unwrap_result!(::safe_core
                                                                                          ::client
                                                                                          ::Client
                                                                                          ::create_unregistered_client())));
     println!("Account Login Successful !!");
 
     println!("Initialising Dns...");
-    let dns_operations = eval_result!(safe_dns::dns_operations::DnsOperations::new(client.clone()));
+    let dns_operations = unwrap_result!(safe_dns::dns_operations::DnsOperations::new(client.clone()));
     let dns_operations_unregistered = safe_dns::dns_operations::DnsOperations::new_unregistered(unregistered_client.clone());
 
     let mut user_option = String::new();
diff --git a/src/dns_operations/dns_configuration.rs b/src/dns_operations/dns_configuration.rs
index 9082711b..15b14fc0 100644
--- a/src/dns_operations/dns_configuration.rs
+++ b/src/dns_operations/dns_configuration.rs
@@ -15,6 +15,8 @@
 // Please review the Licences for the specific language governing permissions and limitations
 // relating to use of the SAFE Network Software.
 
+use maidsafe_utilities::serialisation::{serialise, deserialise};
+
 const DNS_CONFIG_DIR_NAME: &'static str = "DnsReservedDirectory";
 const DNS_CONFIG_FILE_NAME: &'static str = "DnsConfigurationFile";
 
@@ -49,7 +51,7 @@ pub fn get_dns_configuaration_data(client: ::std::sync::Arc<::std::sync::Mutex<:
     let mut reader = file_helper.read(file);
     let size = reader.size();
     if size != 0 {
-        Ok(try!(::safe_core::utility::deserialise(&try!(reader.read(0, size)))))
+        Ok(try!(deserialise(&try!(reader.read(0, size)))))
     } else {
         Ok(vec![])
     }
@@ -63,7 +65,7 @@ pub fn write_dns_configuaration_data(client: ::std::sync::Arc<::std::sync::Mutex
     let file_helper = ::safe_nfs::helper::file_helper::FileHelper::new(client.clone());
     let mut writer = try!(file_helper.update_content(file, ::safe_nfs::helper::writer::Mode::Overwrite, dir_listing));
     debug!("Writing dns configuration data ...");
-    writer.write(&try!(::safe_core::utility::serialise(&config)), 0);
+    writer.write(&try!(serialise(&config)), 0);
     let _ = try!(writer.close());
     Ok(())
 }
@@ -74,16 +76,16 @@ mod test {
 
     #[test]
     fn read_write_dns_configuration_file() {
-        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_core::utility::test_utils::get_client())));
+        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(unwrap_result!(::safe_core::utility::test_utils::get_client())));
 
         // Initialise Dns Configuration File
-        eval_result!(initialise_dns_configuaration(client.clone()));
+        unwrap_result!(initialise_dns_configuaration(client.clone()));
 
         // Get the Stored Configurations
-        let mut config_vec = eval_result!(get_dns_configuaration_data(client.clone()));
+        let mut config_vec = unwrap_result!(get_dns_configuaration_data(client.clone()));
         assert_eq!(config_vec.len(), 0);
 
-        let long_name = eval_result!(::safe_core::utility::generate_random_string(10));
+        let long_name = unwrap_result!(::safe_core::utility::generate_random_string(10));
 
         // Put in the 1st record
         let mut keypair = ::sodiumoxide::crypto::box_::gen_keypair();
@@ -93,10 +95,10 @@ mod test {
         };
 
         config_vec.push(config_0.clone());
-        eval_result!(write_dns_configuaration_data(client.clone(), &config_vec));
+        unwrap_result!(write_dns_configuaration_data(client.clone(), &config_vec));
 
         // Get the Stored Configurations
-        config_vec = eval_result!(get_dns_configuaration_data(client.clone()));
+        config_vec = unwrap_result!(get_dns_configuaration_data(client.clone()));
         assert_eq!(config_vec.len(), 1);
 
         assert_eq!(config_vec[0], config_0);
@@ -109,10 +111,10 @@ mod test {
         };
 
         config_vec[0] = config_1.clone();
-        eval_result!(write_dns_configuaration_data(client.clone(), &config_vec));
+        unwrap_result!(write_dns_configuaration_data(client.clone(), &config_vec));
 
         // Get the Stored Configurations
-        config_vec = eval_result!(get_dns_configuaration_data(client.clone()));
+        config_vec = unwrap_result!(get_dns_configuaration_data(client.clone()));
         assert_eq!(config_vec.len(), 1);
 
         assert!(config_vec[0] != config_0);
@@ -120,10 +122,10 @@ mod test {
 
         // Delete Record
         config_vec.clear();
-        eval_result!(write_dns_configuaration_data(client.clone(), &config_vec));
+        unwrap_result!(write_dns_configuaration_data(client.clone(), &config_vec));
 
         // Get the Stored Configurations
-        config_vec = eval_result!(get_dns_configuaration_data(client.clone()));
+        config_vec = unwrap_result!(get_dns_configuaration_data(client.clone()));
         assert_eq!(config_vec.len(), 0);
     }
 }
diff --git a/src/dns_operations/mod.rs b/src/dns_operations/mod.rs
index b5e10827..80988256 100644
--- a/src/dns_operations/mod.rs
+++ b/src/dns_operations/mod.rs
@@ -15,6 +15,10 @@
 // Please review the Licences for the specific language governing permissions and limitations
 // relating to use of the SAFE Network Software.
 
+use xor_name::XorName;
+use routing::{Data, DataRequest, StructuredData};
+use maidsafe_utilities::serialisation::{serialise, deserialise};
+
 mod dns_configuration;
 
 const DNS_TAG: u64 = 5;
@@ -56,13 +60,13 @@ impl DnsOperations {
                         private_signing_key            : &::sodiumoxide::crypto::sign::SecretKey,
                         data_encryption_keys           : Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                  &::sodiumoxide::crypto::box_::SecretKey,
-                                                                 &::sodiumoxide::crypto::box_::Nonce)>) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
+                                                                 &::sodiumoxide::crypto::box_::Nonce)>) -> Result<StructuredData, ::errors::DnsError> {
         debug!("Registering {:?} dns ...", long_name);
         let mut saved_configs = try!(dns_configuration::get_dns_configuaration_data(self.client.clone()));
         if saved_configs.iter().any(|config| config.long_name == long_name) {
             Err(::errors::DnsError::DnsNameAlreadyRegistered)
         } else {
-            let identifier = ::routing::NameType::new(::sodiumoxide::crypto::hash::sha512::hash(long_name.as_bytes()).0);
+            let identifier = XorName::new(::sodiumoxide::crypto::hash::sha512::hash(long_name.as_bytes()).0);
 
             let dns_record = Dns {
                 long_name     : long_name.clone(),
@@ -83,7 +87,7 @@ impl DnsOperations {
                                                                                    DNS_TAG,
                                                                                    identifier,
                                                                                    0,
-                                                                                   try!(::safe_core::utility::serialise(&dns_record)),
+                                                                                   try!(serialise(&dns_record)),
                                                                                    owners,
                                                                                    vec![],
                                                                                    private_signing_key,
@@ -94,7 +98,7 @@ impl DnsOperations {
     /// Delete the Dns-Record
     pub fn delete_dns(&self,
                       long_name          : &String,
-                      private_signing_key: &::sodiumoxide::crypto::sign::SecretKey) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
+                      private_signing_key: &::sodiumoxide::crypto::sign::SecretKey) -> Result<StructuredData, ::errors::DnsError> {
         let mut saved_configs = try!(dns_configuration::get_dns_configuaration_data(self.client.clone()));
         let pos = try!(saved_configs.iter().position(|config| config.long_name == *long_name).ok_or(::errors::DnsError::DnsRecordNotFound));
 
@@ -172,7 +176,7 @@ impl DnsOperations {
                        private_signing_key            : &::sodiumoxide::crypto::sign::SecretKey,
                        data_encryption_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                 &::sodiumoxide::crypto::box_::SecretKey,
-                                                                &::sodiumoxide::crypto::box_::Nonce)>) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
+                                                                &::sodiumoxide::crypto::box_::Nonce)>) -> Result<StructuredData, ::errors::DnsError> {
         self.add_remove_service_impl(long_name, (new_service.0, Some(new_service.1)), private_signing_key, data_encryption_decryption_keys)
     }
 
@@ -183,7 +187,7 @@ impl DnsOperations {
                           private_signing_key            : &::sodiumoxide::crypto::sign::SecretKey,
                           data_encryption_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                    &::sodiumoxide::crypto::box_::SecretKey,
-                                                                   &::sodiumoxide::crypto::box_::Nonce)>) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
+                                                                   &::sodiumoxide::crypto::box_::Nonce)>) -> Result<StructuredData, ::errors::DnsError> {
         self.add_remove_service_impl(long_name, (service_to_remove, None), private_signing_key, data_encryption_decryption_keys)
     }
 
@@ -198,7 +202,7 @@ impl DnsOperations {
                                private_signing_key            : &::sodiumoxide::crypto::sign::SecretKey,
                                data_encryption_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                         &::sodiumoxide::crypto::box_::SecretKey,
-                                                                        &::sodiumoxide::crypto::box_::Nonce)>) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
+                                                                        &::sodiumoxide::crypto::box_::Nonce)>) -> Result<StructuredData, ::errors::DnsError> {
         let _ = try!(self.find_dns_record(long_name));
 
         let is_add_service = service.1.is_some();
@@ -222,7 +226,7 @@ impl DnsOperations {
                                                                                    DNS_TAG,
                                                                                    prev_struct_data.get_identifier().clone(),
                                                                                    prev_struct_data.get_version() + 1,
-                                                                                   try!(::safe_core::utility::serialise(&dns_record)),
+                                                                                   try!(serialise(&dns_record)),
                                                                                    prev_struct_data.get_owner_keys().clone(),
                                                                                    prev_struct_data.get_previous_owner_keys().clone(),
                                                                                    private_signing_key,
@@ -234,21 +238,21 @@ impl DnsOperations {
                                                   long_name           : &String,
                                                   data_decryption_keys: Option<(&::sodiumoxide::crypto::box_::PublicKey,
                                                                                 &::sodiumoxide::crypto::box_::SecretKey,
-                                                                                &::sodiumoxide::crypto::box_::Nonce)>) -> Result<(::routing::structured_data::StructuredData,
+                                                                                &::sodiumoxide::crypto::box_::Nonce)>) -> Result<(StructuredData,
                                                                                                                                   Dns), ::errors::DnsError> {
         let struct_data = try!(self.get_housing_structured_data(long_name));
-        let dns_record = try!(::safe_core::utility::deserialise(&try!(::safe_core::structured_data_operations::unversioned::get_data(self.client.clone(),
+        let dns_record = try!(deserialise(&try!(::safe_core::structured_data_operations::unversioned::get_data(self.client.clone(),
                                                                                                                                          &struct_data,
                                                                                                                                          data_decryption_keys))));
         Ok((struct_data, dns_record))
     }
 
-    fn get_housing_structured_data(&self, long_name: &String) -> Result<::routing::structured_data::StructuredData, ::errors::DnsError> {
-        let identifier = ::routing::NameType::new(::sodiumoxide::crypto::hash::sha512::hash(long_name.as_bytes()).0);
-        let request = ::routing::data::DataRequest::StructuredData(identifier, DNS_TAG);
+    fn get_housing_structured_data(&self, long_name: &String) -> Result<StructuredData, ::errors::DnsError> {
+        let identifier = XorName::new(::sodiumoxide::crypto::hash::sha512::hash(long_name.as_bytes()).0);
+        let request = DataRequest::StructuredData(identifier, DNS_TAG);
         debug!("Retrieving structured data from network for {:?} dns ...", long_name);
-        let response_getter = eval_result!(self.client.lock()).get(request, None);
-        if let ::routing::data::Data::StructuredData(struct_data) = try!(response_getter.get()) {
+        let response_getter = try!(unwrap_result!(self.client.lock()).get(request, None));
+        if let Data::StructuredData(struct_data) = try!(response_getter.get()) {
             Ok(struct_data)
         } else {
             Err(::errors::DnsError::from(::safe_core::errors::CoreError::ReceivedUnexpectedData))
@@ -266,20 +270,22 @@ struct Dns {
 #[cfg(test)]
 mod test {
     use super::*;
+    use xor_name::XorName;
+    use routing::Data;
 
     #[test]
     fn register_and_delete_dns() {
-        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_core::utility::test_utils::get_client())));
-        let dns_operations = eval_result!(DnsOperations::new(client.clone()));
+        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(unwrap_result!(::safe_core::utility::test_utils::get_client())));
+        let dns_operations = unwrap_result!(DnsOperations::new(client.clone()));
 
-        let dns_name = eval_result!(::safe_core::utility::generate_random_string(10));
+        let dns_name = unwrap_result!(::safe_core::utility::generate_random_string(10));
         let messaging_keypair = ::sodiumoxide::crypto::box_::gen_keypair();
-        let owners = vec![eval_result!(eval_result!(client.lock()).get_public_signing_key()).clone()];
+        let owners = vec![unwrap_result!(unwrap_result!(client.lock()).get_public_signing_key()).clone()];
 
-        let secret_signing_key = eval_result!(eval_result!(client.lock()).get_secret_signing_key()).clone();
+        let secret_signing_key = unwrap_result!(unwrap_result!(client.lock()).get_secret_signing_key()).clone();
 
         // Register
-        let mut struct_data = eval_result!(dns_operations.register_dns(dns_name.clone(),
+        let mut struct_data = unwrap_result!(dns_operations.register_dns(dns_name.clone(),
                                                                        &messaging_keypair.0,
                                                                        &messaging_keypair.1,
                                                                        &vec![],
@@ -287,10 +293,10 @@ mod test {
                                                                        &secret_signing_key,
                                                                        None));
 
-        eval_result!(eval_result!(client.lock()).put(::routing::data::Data::StructuredData(struct_data), None));
+        unwrap_result!(unwrap_result!(client.lock()).put(Data::StructuredData(struct_data), None));
 
         // Get Services
-        let services = eval_result!(dns_operations.get_all_services(&dns_name, None));
+        let services = unwrap_result!(dns_operations.get_all_services(&dns_name, None));
         assert_eq!(services.len(), 0);
 
         // Re-registering is not allowed
@@ -307,11 +313,11 @@ mod test {
         }
 
         // Delete
-        struct_data = eval_result!(dns_operations.delete_dns(&dns_name, &secret_signing_key));
-        eval_result!(eval_result!(client.lock()).delete(::routing::data::Data::StructuredData(struct_data), None));
+        struct_data = unwrap_result!(dns_operations.delete_dns(&dns_name, &secret_signing_key));
+        unwrap_result!(unwrap_result!(client.lock()).delete(Data::StructuredData(struct_data), None));
 
         // Registering again should be allowed
-        let _ = eval_result!(dns_operations.register_dns(dns_name,
+        let _ = unwrap_result!(dns_operations.register_dns(dns_name,
                                                          &messaging_keypair.0,
                                                          &messaging_keypair.1,
                                                          &vec![],
@@ -322,34 +328,34 @@ mod test {
 
     #[test]
     fn manipulate_services() {
-        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_core::utility::test_utils::get_client())));
-        let dns_operations = eval_result!(DnsOperations::new(client.clone()));
+        let client = ::std::sync::Arc::new(::std::sync::Mutex::new(unwrap_result!(::safe_core::utility::test_utils::get_client())));
+        let dns_operations = unwrap_result!(DnsOperations::new(client.clone()));
 
-        let dns_name = eval_result!(::safe_core::utility::generate_random_string(10));
+        let dns_name = unwrap_result!(::safe_core::utility::generate_random_string(10));
         let messaging_keypair = ::sodiumoxide::crypto::box_::gen_keypair();
 
         let mut services = vec![("www".to_string(),
-                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([123; 64]),
+                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(XorName::new([123; 64]),
                                                                                         15000,
                                                                                         false,
                                                                                         ::safe_nfs::AccessLevel::Public)),
                                 ("blog".to_string(),
-                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([123; 64]),
+                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(XorName::new([123; 64]),
                                                                                         15000,
                                                                                         false,
                                                                                         ::safe_nfs::AccessLevel::Public)),
                                 ("bad-ass".to_string(),
-                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([123; 64]),
+                                 ::safe_nfs::metadata::directory_key::DirectoryKey::new(XorName::new([123; 64]),
                                                                                         15000,
                                                                                         false,
                                                                                         ::safe_nfs::AccessLevel::Public))];
 
-        let owners = vec![eval_result!(eval_result!(client.lock()).get_public_signing_key()).clone()];
+        let owners = vec![unwrap_result!(unwrap_result!(client.lock()).get_public_signing_key()).clone()];
 
-        let secret_signing_key = eval_result!(eval_result!(client.lock()).get_secret_signing_key()).clone();
+        let secret_signing_key = unwrap_result!(unwrap_result!(client.lock()).get_secret_signing_key()).clone();
 
         // Register
-        let mut struct_data = eval_result!(dns_operations.register_dns(dns_name.clone(),
+        let mut struct_data = unwrap_result!(dns_operations.register_dns(dns_name.clone(),
                                                                        &messaging_keypair.0,
                                                                        &messaging_keypair.1,
                                                                        &services,
@@ -357,18 +363,18 @@ mod test {
                                                                        &secret_signing_key,
                                                                        None));
 
-        eval_result!(eval_result!(client.lock()).put(::routing::data::Data::StructuredData(struct_data), None));
+        unwrap_result!(unwrap_result!(client.lock()).put(Data::StructuredData(struct_data), None));
 
         // Get all dns-names
-        let dns_records_vec = eval_result!(dns_operations.get_all_registered_names());
+        let dns_records_vec = unwrap_result!(dns_operations.get_all_registered_names());
         assert_eq!(dns_records_vec.len(), 1);
 
         // Gets should be possible with unregistered clients
-        let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(eval_result!(::safe_core::client::Client::create_unregistered_client())));
+        let unregistered_client = ::std::sync::Arc::new(::std::sync::Mutex::new(unwrap_result!(::safe_core::client::Client::create_unregistered_client())));
         let dns_operations_unregistered = DnsOperations::new_unregistered(unregistered_client);
 
         // Get all services for a dns-name
-        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
+        let services_vec = unwrap_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
 
@@ -380,16 +386,16 @@ mod test {
         // }
 
         // Get information about a service - the home-directory and its type
-        let home_dir_key = eval_result!(dns_operations_unregistered.get_service_home_directory_key(&dns_name, &services[1].0, None));
+        let home_dir_key = unwrap_result!(dns_operations_unregistered.get_service_home_directory_key(&dns_name, &services[1].0, None));
         assert_eq!(home_dir_key, services[1].1);
 
         // Remove a service
         let removed_service = services.remove(1);
-        struct_data = eval_result!(dns_operations.remove_service(&dns_name, removed_service.0.clone(), &secret_signing_key, None));
-        eval_result!(client.lock()).post(::routing::data::Data::StructuredData(struct_data), None);
+        struct_data = unwrap_result!(dns_operations.remove_service(&dns_name, removed_service.0.clone(), &secret_signing_key, None));
+        unwrap_result!(unwrap_result!(client.lock()).post(Data::StructuredData(struct_data), None));
 
         // Get all services
-        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
+        let services_vec = unwrap_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
 
@@ -403,16 +409,16 @@ mod test {
 
         // Add a service
         services.push(("added-service".to_string(),
-                       ::safe_nfs::metadata::directory_key::DirectoryKey::new(::routing::NameType::new([126; 64]),
+                       ::safe_nfs::metadata::directory_key::DirectoryKey::new(XorName::new([126; 64]),
                                                                               15000,
                                                                               false,
                                                                               ::safe_nfs::AccessLevel::Public)));
         let services_size = services.len();
-        struct_data = eval_result!(dns_operations.add_service(&dns_name, services[services_size - 1].clone(), &secret_signing_key, None));
-        eval_result!(client.lock()).post(::routing::data::Data::StructuredData(struct_data), None);
+        struct_data = unwrap_result!(dns_operations.add_service(&dns_name, services[services_size - 1].clone(), &secret_signing_key, None));
+        unwrap_result!(unwrap_result!(client.lock()).post(Data::StructuredData(struct_data), None));
 
         // Get all services
-        let services_vec = eval_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
+        let services_vec = unwrap_result!(dns_operations_unregistered.get_all_services(&dns_name, None));
         assert_eq!(services.len(), services_vec.len());
         assert!(services.iter().all(|&(ref a, _)| services_vec.iter().find(|b| *a == **b).is_some()));
     }
diff --git a/src/errors.rs b/src/errors.rs
index b2091f41..cec055b5 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -15,6 +15,8 @@
 // Please review the Licences for the specific language governing permissions and limitations
 // relating to use of the SAFE Network Software.
 
+use maidsafe_utilities::serialisation::SerialisationError;
+
 /// Intended for converting DNS Errors into numeric codes for propagating some error information
 /// across FFI boundaries and specially to C.
 pub const DNS_ERROR_START_RANGE: i32 = ::safe_nfs::errors::NFS_ERROR_START_RANGE - 500;
@@ -37,8 +39,15 @@ pub enum DnsError {
     DnsConfigFileNotFoundOrCorrupted,
     /// Unexpected, probably due to logical error
     Unexpected(String),
+    /// Could not serialise or deserialise data
+    UnsuccessfulEncodeDecode(SerialisationError),
 }
 
+impl From<SerialisationError> for DnsError {
+    fn from(error: SerialisationError) -> DnsError {
+        DnsError::UnsuccessfulEncodeDecode(error)
+    }
+}
 impl From<::safe_core::errors::CoreError> for DnsError {
     fn from(error: ::safe_core::errors::CoreError) -> DnsError {
         DnsError::CoreError(error)
@@ -60,7 +69,7 @@ impl<'a> From<&'a str> for DnsError {
 impl Into<i32> for DnsError {
     fn into(self) -> i32 {
         match self {
-            DnsError::CoreError(error)               => error.into(),
+            DnsError::CoreError(error)                 => error.into(),
             DnsError::NfsError(error)                  => error.into(),
             DnsError::DnsNameAlreadyRegistered         => DNS_ERROR_START_RANGE,
             DnsError::DnsRecordNotFound                => DNS_ERROR_START_RANGE - 1,
@@ -68,6 +77,7 @@ impl Into<i32> for DnsError {
             DnsError::ServiceNotFound                  => DNS_ERROR_START_RANGE - 3,
             DnsError::DnsConfigFileNotFoundOrCorrupted => DNS_ERROR_START_RANGE - 4,
             DnsError::Unexpected(_)                    => DNS_ERROR_START_RANGE - 5,
+            DnsError::UnsuccessfulEncodeDecode(_)      => DNS_ERROR_START_RANGE - 6,
         }
     }
 }
@@ -75,14 +85,15 @@ impl Into<i32> for DnsError {
 impl ::std::fmt::Debug for DnsError {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match *self {
-            DnsError::CoreError(ref error)           => write!(f, "DnsError::CoreError -> {:?}", error),
-            DnsError::NfsError(ref error)              => write!(f, "DnsError::NfsError -> {:?}", error),
-            DnsError::DnsNameAlreadyRegistered         => write!(f, "DnsError::DnsNameAlreadyRegistered"),
-            DnsError::DnsRecordNotFound                => write!(f, "DnsError::DnsRecordNotFound"),
-            DnsError::ServiceAlreadyExists             => write!(f, "DnsError::ServiceAlreadyExists"),
-            DnsError::ServiceNotFound                  => write!(f, "DnsError::ServiceNotFound"),
-            DnsError::DnsConfigFileNotFoundOrCorrupted => write!(f, "DnsError::DnsConfigFileNotFoundOrCorrupted"),
-            DnsError::Unexpected(ref error)            => write!(f, "DnsError::Unexpected::{{{:?}}}", error),
+            DnsError::CoreError(ref error)              => write!(f, "DnsError::CoreError -> {:?}", error),
+            DnsError::NfsError(ref error)               => write!(f, "DnsError::NfsError -> {:?}", error),
+            DnsError::DnsNameAlreadyRegistered          => write!(f, "DnsError::DnsNameAlreadyRegistered"),
+            DnsError::DnsRecordNotFound                 => write!(f, "DnsError::DnsRecordNotFound"),
+            DnsError::ServiceAlreadyExists              => write!(f, "DnsError::ServiceAlreadyExists"),
+            DnsError::ServiceNotFound                   => write!(f, "DnsError::ServiceNotFound"),
+            DnsError::DnsConfigFileNotFoundOrCorrupted  => write!(f, "DnsError::DnsConfigFileNotFoundOrCorrupted"),
+            DnsError::Unexpected(ref error)             => write!(f, "DnsError::Unexpected::{{{:?}}}", error),
+            DnsError::UnsuccessfulEncodeDecode(ref err) => write!(f, "DnsError::UnsuccessfulEncodeDecode -> {:?}", err),
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 9e822b09..e369e534 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -43,11 +43,13 @@
          missing_debug_implementations)]
 
 extern crate routing;
+extern crate xor_name;
 extern crate safe_nfs;
+extern crate safe_core;
 extern crate sodiumoxide;
 extern crate rustc_serialize;
 #[macro_use] extern crate log;
-#[macro_use] extern crate safe_core;
+#[macro_use] extern crate maidsafe_utilities;
 
 /// Safe-Dns errors
 pub mod errors;