remove sp-serializer which is not useful

Cargo.toml

@@ -219,7 +219,6 @@ members = [
 	"primitives/runtime-interface/test",
 	"primitives/runtime-interface/test-wasm",
 	"primitives/runtime-interface/test-wasm-deprecated",
-	"primitives/serializer",
 	"primitives/session",
 	"primitives/staking",
 	"primitives/state-machine",

primitives/core/Cargo.toml

@@ -56,7 +56,6 @@ sp-runtime-interface = { version = "7.0.0", default-features = false, path = "..
 w3f-bls = { version = "0.1.3", default-features = false, optional = true}
 
 [dev-dependencies]
-sp-serializer = { version = "4.0.0-dev", path = "../serializer" }
 rand = "0.8.5"
 criterion = "0.4.0"
 serde_json = "1.0"

primitives/core/src/hash.rs

@@ -32,7 +32,6 @@ pub fn convert_hash<H1: Default + AsMut<[u8]>, H2: AsRef<[u8]>>(src: &H2) -> H1
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sp_serializer as ser;
 
 	#[test]
 	fn test_h160() {
@@ -47,8 +46,11 @@ mod tests {
 		];
 
 		for (number, expected) in tests {
-			assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
-			assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+			assert_eq!(
+				format!("{:?}", expected),
+				serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+			);
+			assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
 		}
 	}
 
@@ -86,30 +88,33 @@ mod tests {
 		];
 
 		for (number, expected) in tests {
-			assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
-			assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+			assert_eq!(
+				format!("{:?}", expected),
+				serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+			);
+			assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
 		}
 	}
 
 	#[test]
 	fn test_invalid() {
-		assert!(ser::from_str::<H256>(
+		assert!(serde_json::from_str::<H256>(
 			"\"0x000000000000000000000000000000000000000000000000000000000000000\""
 		)
 		.unwrap_err()
 		.is_data());
-		assert!(ser::from_str::<H256>(
+		assert!(serde_json::from_str::<H256>(
 			"\"0x000000000000000000000000000000000000000000000000000000000000000g\""
 		)
 		.unwrap_err()
 		.is_data());
-		assert!(ser::from_str::<H256>(
+		assert!(serde_json::from_str::<H256>(
 			"\"0x00000000000000000000000000000000000000000000000000000000000000000\""
 		)
 		.unwrap_err()
 		.is_data());
-		assert!(ser::from_str::<H256>("\"\"").unwrap_err().is_data());
-		assert!(ser::from_str::<H256>("\"0\"").unwrap_err().is_data());
-		assert!(ser::from_str::<H256>("\"10\"").unwrap_err().is_data());
+		assert!(serde_json::from_str::<H256>("\"\"").unwrap_err().is_data());
+		assert!(serde_json::from_str::<H256>("\"0\"").unwrap_err().is_data());
+		assert!(serde_json::from_str::<H256>("\"10\"").unwrap_err().is_data());
 	}
 }

primitives/core/src/uint.rs

@@ -23,7 +23,6 @@ pub use primitive_types::{U256, U512};
 mod tests {
 	use super::*;
 	use codec::{Decode, Encode};
-	use sp_serializer as ser;
 
 	macro_rules! test {
 		($name: ident, $test_name: ident) => {
@@ -43,14 +42,17 @@ mod tests {
 				];
 
 				for (number, expected) in tests {
-					assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
-					assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+					assert_eq!(
+						format!("{:?}", expected),
+						serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+					);
+					assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
 				}
 
 				// Invalid examples
-				assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
-				assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
-				assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
+				assert!(serde_json::from_str::<$name>("\"0x\"").unwrap_err().is_data());
+				assert!(serde_json::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
+				assert!(serde_json::from_str::<$name>("\"\"").unwrap_err().is_data());
 			}
 		};
 	}
@@ -78,10 +80,10 @@ mod tests {
 	#[test]
 	fn test_large_values() {
 		assert_eq!(
-			ser::to_string_pretty(&!U256::zero()),
+			serde_json::to_string_pretty(&!U256::zero()).expect("Json pretty print failed"),
 			"\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
 		);
-		assert!(ser::from_str::<U256>(
+		assert!(serde_json::from_str::<U256>(
 			"\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
 		)
 		.unwrap_err()