diff --git a/substrate/primitives/src/ed25519.rs b/substrate/primitives/src/ed25519.rs
new file mode 100644
index 0000000000..676f8ef266
--- /dev/null
+++ b/substrate/primitives/src/ed25519.rs
@@ -0,0 +1,155 @@
+//! Simple Ed25519 API.
+
+use untrusted;
+use ring::{rand, signature};
+use rustc_hex::FromHex;
+
+struct HexDisplay<'a>(&'a [u8]);
+
+impl<'a> ::std::fmt::Display for HexDisplay<'a> {
+	fn fmt(&self, fmtr: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+		for byte in self.0 {
+			try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
+		}
+		Ok(())
+	}
+}
+
+/// A public key.
+#[derive(PartialEq, Clone, Debug)]
+pub struct Public ([u8; 32]);
+
+/// A key pair.
+pub struct Pair(signature::Ed25519KeyPair);
+
+/// A signature.
+#[derive(Clone)]
+pub struct Signature ([u8; 64]);
+
+impl Pair {
+	/// Generate new secure (random) key pair.
+	pub fn new() -> Pair {
+		let rng = rand::SystemRandom::new();
+		let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(&rng).unwrap();
+		Pair(signature::Ed25519KeyPair::from_pkcs8(untrusted::Input::from(&pkcs8_bytes)).unwrap())
+	}
+	/// Make a new key pair from a seed phrase.
+	pub fn from_seed(seed: &[u8; 32]) -> Pair {
+		Pair(signature::Ed25519KeyPair::from_seed_unchecked(untrusted::Input::from(&seed[..])).unwrap())
+	}
+	/// Make a new key pair from the raw secret.
+	pub fn from_secret(secret: &[u8; 32]) -> Pair {
+		let mut pkcs8_bytes = FromHex::from_hex("302e020100300506032b657004220420").unwrap();
+		pkcs8_bytes.extend_from_slice(&secret[..]);
+		Pair(signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(untrusted::Input::from(&pkcs8_bytes)).unwrap())
+	}
+	/// Make a new key pair from the raw secret and public key (it will check to make sure
+	/// they correspond to each other).
+	pub fn from_both(secret_public: &[u8; 64]) -> Option<Pair> {
+		let mut pkcs8_bytes = FromHex::from_hex("3053020101300506032b657004220420").unwrap();
+		pkcs8_bytes.extend_from_slice(&secret_public[0..32]);
+		pkcs8_bytes.extend_from_slice(&[0xa1u8, 0x23, 0x03, 0x21, 0x00]);
+		pkcs8_bytes.extend_from_slice(&secret_public[32..64]);
+		signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(untrusted::Input::from(&pkcs8_bytes)).ok().map(Pair)
+	}
+	/// Sign a message.
+	pub fn sign(&self, message: &[u8]) -> Signature {
+		let mut r = [0u8; 64];
+		r.copy_from_slice(self.0.sign(message).as_ref());
+		Signature(r)
+	}
+	/// Get the public key.
+	pub fn public(&self) -> Public {
+		let mut r = [0u8; 32];
+		let pk = self.0.public_key_bytes();
+		r.copy_from_slice(pk);
+		Public(r)
+	}
+}
+impl Signature {
+	/// Verify a message.
+	pub fn verify(&self, message: &[u8], public: &Public) -> bool {
+		let peer_public_key = untrusted::Input::from(&public.0[..]);
+		let msg = untrusted::Input::from(message);
+		let sig = untrusted::Input::from(&self.0[..]);
+
+		match signature::verify(&signature::ED25519, peer_public_key, msg, sig) {
+			Ok(_) => true,
+			_ => false,
+		}
+	}
+}
+impl From<&'static str> for Public {
+	fn from(hex: &'static str) -> Self {
+		let mut r = [0u8; 32];
+		r.copy_from_slice(&FromHex::from_hex(hex).unwrap()[0..32]);
+		Public(r)
+	}
+}
+impl From<&'static str> for Pair {
+	fn from(hex: &'static str) -> Self {
+		let data = FromHex::from_hex(hex).expect("Key pair given is static so hex should be good.");
+		match data.len() {
+			32 => {
+				let mut r = [0u8; 32];
+				r.copy_from_slice(&data[0..32]);
+				Pair::from_secret(&r)
+			}
+			64 => {
+				let mut r = [0u8; 64];
+				r.copy_from_slice(&data[0..64]);
+				Pair::from_both(&r).expect("Key pair given is static so should be good.")
+			}
+			_ => {
+				panic!("Key pair given is static so should be correct length.");
+			}
+		}
+	}
+}
+impl From<&'static str> for Signature {
+	fn from(hex: &'static str) -> Self {
+		let mut r = [0u8; 64];
+		r.copy_from_slice(&FromHex::from_hex(hex).unwrap()[0..64]);
+		Signature(r)
+	}
+}
+
+impl PartialEq for Signature {
+	fn eq(&self, other: &Signature) -> bool {
+		self.0.iter().eq(other.0.iter())
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn test_vector_should_work() {
+		let pair: Pair = "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60".into();
+		let public = pair.public();
+		assert_eq!(public, "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a".into());
+		let message = b"";
+		let signature: Signature = "e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b".into();
+		assert!(&pair.sign(&message[..]) == &signature);
+		assert!(signature.verify(&message[..], &public));
+	}
+
+	#[test]
+	fn generated_pair_should_work() {
+		let pair = Pair::new();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(signature.verify(&message[..], &public));
+	}
+
+	#[test]
+	fn seeded_pair_should_work() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(signature.verify(&message[..], &public));
+	}
+}
diff --git a/substrate/primitives/src/lib.rs b/substrate/primitives/src/lib.rs
index cd166f0a54..fc26658200 100644
--- a/substrate/primitives/src/lib.rs
+++ b/substrate/primitives/src/lib.rs
@@ -48,6 +48,7 @@ pub mod hash;
 pub mod parachain;
 pub mod uint;
 pub mod validator;
+pub mod ed25519;
 
 /// Alias to 160-bit hash when used in the context of an account address.
 pub type Address = hash::H160;
@@ -61,160 +62,3 @@ pub use self::uint::{U256, U512};
 pub fn hash(data: &[u8]) -> hash::H256 {
 	tiny_keccak::keccak256(data).into()
 }
-
-/// Cool module.
-pub mod ed25519 {
-	use untrusted;
-	use ring::{rand, signature};
-	use rustc_hex::FromHex;
-
-	struct HexDisplay<'a>(&'a [u8]);
-
-	impl<'a> ::std::fmt::Display for HexDisplay<'a> {
-		fn fmt(&self, fmtr: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-			for byte in self.0 {
-				try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
-			}
-			Ok(())
-		}
-	}
-
-	/// A public key.
-	#[derive(PartialEq, Clone, Debug)]
-	pub struct Public ([u8; 32]);
-
-	/// A key pair.
-	pub struct Pair(signature::Ed25519KeyPair);
-
-	/// A signature.
-	#[derive(Clone)]
-	pub struct Signature ([u8; 64]);
-
-	impl Pair {
-		/// Generate new secure (random) key pair.
-		pub fn new() -> Pair {
-			let rng = rand::SystemRandom::new();
-			let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(&rng).unwrap();
-			Pair(signature::Ed25519KeyPair::from_pkcs8(untrusted::Input::from(&pkcs8_bytes)).unwrap())
-		}
-		/// Make a new key pair from a seed phrase.
-		pub fn from_seed(seed: &[u8; 32]) -> Pair {
-			Pair(signature::Ed25519KeyPair::from_seed_unchecked(untrusted::Input::from(&seed[..])).unwrap())
-		}
-		/// Make a new key pair from the raw secret.
-		pub fn from_secret(secret: &[u8; 32]) -> Pair {
-			let mut pkcs8_bytes = FromHex::from_hex("302e020100300506032b657004220420").unwrap();
-			pkcs8_bytes.extend_from_slice(&secret[..]);
-			Pair(signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(untrusted::Input::from(&pkcs8_bytes)).unwrap())
-		}
-		/// Make a new key pair from the raw secret and public key (it will check to make sure
-		/// they correspond to each other).
-		pub fn from_both(secret_public: &[u8; 64]) -> Option<Pair> {
-			let mut pkcs8_bytes = FromHex::from_hex("3053020101300506032b657004220420").unwrap();
-			pkcs8_bytes.extend_from_slice(&secret_public[0..32]);
-			pkcs8_bytes.extend_from_slice(&[0xa1u8, 0x23, 0x03, 0x21, 0x00]);
-			pkcs8_bytes.extend_from_slice(&secret_public[32..64]);
-			signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(untrusted::Input::from(&pkcs8_bytes)).ok().map(Pair)
-		}
-		/// Sign a message.
-		pub fn sign(&self, message: &[u8]) -> Signature {
-			let mut r = [0u8; 64];
-			r.copy_from_slice(self.0.sign(message).as_ref());
-			Signature(r)
-		}
-		/// Get the public key.
-		pub fn public(&self) -> Public {
-			let mut r = [0u8; 32];
-			let pk = self.0.public_key_bytes();
-			r.copy_from_slice(pk);
-			Public(r)
-		}
-	}
-	impl Signature {
-		/// Verify a message.
-		pub fn verify(&self, message: &[u8], public: &Public) -> bool {
-			let peer_public_key = untrusted::Input::from(&public.0[..]);
-			let msg = untrusted::Input::from(message);
-			let sig = untrusted::Input::from(&self.0[..]);
-
-			match signature::verify(&signature::ED25519, peer_public_key, msg, sig) {
-				Ok(_) => true,
-				_ => false,
-			}
-		}
-	}
-	impl From<&'static str> for Public {
-		fn from(hex: &'static str) -> Self {
-			let mut r = [0u8; 32];
-			r.copy_from_slice(&FromHex::from_hex(hex).unwrap()[0..32]);
-			Public(r)
-		}
-	}
-	impl From<&'static str> for Pair {
-		fn from(hex: &'static str) -> Self {
-			let data = FromHex::from_hex(hex).expect("Key pair given is static so hex should be good.");
-			match data.len() {
-				32 => {
-					let mut r = [0u8; 32];
-					r.copy_from_slice(&data[0..32]);
-					Pair::from_secret(&r)
-				}
-				64 => {
-					let mut r = [0u8; 64];
-					r.copy_from_slice(&data[0..64]);
-					Pair::from_both(&r).expect("Key pair given is static so should be good.")
-				}
-				_ => {
-					panic!("Key pair given is static so should be correct length.");
-				}
-			}
-		}
-	}
-	impl From<&'static str> for Signature {
-		fn from(hex: &'static str) -> Self {
-			let mut r = [0u8; 64];
-			r.copy_from_slice(&FromHex::from_hex(hex).unwrap()[0..64]);
-			Signature(r)
-		}
-	}
-
-	impl PartialEq for Signature {
-		fn eq(&self, other: &Signature) -> bool {
-			self.0.iter().eq(other.0.iter())
-		}
-	}
-
-	#[cfg(test)]
-	mod test {
-		use super::*;
-
-		#[test]
-		fn test_vector_should_work() {
-			let pair: Pair = "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60".into();
-			let public = pair.public();
-			assert_eq!(public, "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a".into());
-			let message = b"";
-			let signature: Signature = "e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b".into();
-			assert!(&pair.sign(&message[..]) == &signature);
-			assert!(signature.verify(&message[..], &public));
-		}
-
-		#[test]
-		fn generated_pair_should_work() {
-			let pair = Pair::new();
-			let public = pair.public();
-			let message = b"Something important";
-			let signature = pair.sign(&message[..]);
-			assert!(signature.verify(&message[..], &public));
-		}
-
-		#[test]
-		fn seeded_pair_should_work() {
-			let pair = Pair::from_seed(b"12345678901234567890123456789012");
-			let public = pair.public();
-			let message = b"Something important";
-			let signature = pair.sign(&message[..]);
-			assert!(signature.verify(&message[..], &public));
-		}
-	}
-}