basic implementations

Author: yxf

.gitignore

@@ -8,3 +8,8 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+
+#Added by cargo
+
+/target

Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "subwallet"
+version = "0.1.0"
+authors = ["yxf <[email protected]>"]
+edition = "2018"
+
+
+[dependencies]
+clap = "2.33.0"
+rustbreak = { version = "2.0.0-rc3", features=["bin_enc"] }
+serde = { version = "1.0", features = ["derive"] }
+tiny-bip39 = "0.7"
+serde_json = { version = "1.0" }
+rpassword = "4.0.1"
+hex = "0.4.0"
+rand = "0.7.2"
+dirs = "2.0"
+
+sodalite = "0.3.0"
+tweetnacl = "0.2.1"
+schnorrkel = { version = "0.9.1", features = ["preaudit_deprecated", "u64_backend"], default-features = false }
+
+# sp-core = { version = "2.0.0-alpha.8" }
+sp-core = { path = "../substrate/primitives/core" }
+
+blake2-rfc = { version = "0.2.18" }

README.md

@@ -1,2 +1,6 @@
 # subwallet
-A simple Command Line Interface Wallet for Polkadot/Substrate.
+
+A simple Command Line Interface Wallet for Polkadot/Substrate.
+
+<img src="https://raw.githubusercontent.com/w3f/Open-Grants-Program/master/src/web3%20foundation%20grants_black.jpg" width="300px">
+

src/command.rs

@@ -0,0 +1,34 @@
+use clap::{App, SubCommand, Arg};
+
+pub fn get_app<'a, 'b>() -> App<'a, 'b> {
+	App::new("subwallet")
+ 			.author("yxf <[email protected]>")
+			.about("A simple Command Line Interface wallet for Polkadot/Substrate.")
+			.version(env!("CARGO_PKG_VERSION"))
+			.subcommands(vec![
+				SubCommand::with_name("getnewaddress")
+					.about("Generate a new address. if label is specified, the address will be associated with label")
+					.arg(Arg::with_name("label")
+						.help("The label name for the address to be linked to.")
+						.required(true)
+					).args_from_usage("
+						-e, --ed25519 'Use Ed25519/BIP39 cryptography'
+						-k, --secp256k1 'Use SECP256k1/ECDSA/BIP39 cryptography'
+						-s, --sr25519 'Use Schnorr/Ristretto x25519/BIP39 cryptography'
+					"),
+				SubCommand::with_name("listaddresses")
+					.about("Return the list of addresses"),
+
+				SubCommand::with_name("restore")
+					.about("Restore address from json file")
+					.args_from_usage("
+						<file>  'The filename with path'
+					"),
+				SubCommand::with_name("backup")
+					.about("Backup specified address to local json file")
+					.args_from_usage("
+						<label>  'Address or label to backup'
+						<path>  'The destination directory or file'
+					"),
+			])
+}

src/crypto.rs

@@ -0,0 +1,102 @@
+
+pub use sp_core::{
+	crypto::{set_default_ss58_version, Ss58AddressFormat, Ss58Codec, Derive },
+	ed25519, sr25519, ecdsa, Pair, Public,
+};
+
+use blake2_rfc::blake2b::{ Blake2b, Blake2bResult };
+
+pub trait Crypto: Sized {
+	type Pair: Pair<Public = Self::Public>;
+	type Public: Public + Ss58Codec + AsRef<[u8]> + std::hash::Hash;
+
+	fn pair_from_secret_slice(slice: &[u8]) -> Result<Self::Pair, ()>;
+
+	fn crypto_type() -> &'static str;
+}
+
+pub struct Ed25519;
+
+impl Crypto for Ed25519 {
+	type Pair = ed25519::Pair;
+	type Public = ed25519::Public;
+
+	fn pair_from_secret_slice(slice: &[u8]) -> Result<Self::Pair, ()> {
+		// if slice.len() != SEC_LENGTH  {
+		// 	return Err(())
+		// }
+		let mut secret_key = [0u8; 32];
+		secret_key.copy_from_slice(&slice[..32]);
+		Ok(Self::Pair::from_seed_slice(&secret_key[..]).unwrap())
+	}
+
+	fn crypto_type() -> &'static str { "ed25519" }
+}
+
+
+pub struct Ecdsa;
+struct EcdsaPublic([u8; 32]);
+impl Derive for EcdsaPublic {}
+
+impl Default for EcdsaPublic {
+	fn default() -> Self {
+		EcdsaPublic([0u8; 32])
+	}
+}
+
+impl AsRef<[u8]> for EcdsaPublic {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+impl AsMut<[u8]> for EcdsaPublic {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl Crypto for Ecdsa {
+	type Pair = ecdsa::Pair;
+	type Public = ecdsa::Public;
+
+	fn pair_from_secret_slice(slice: &[u8]) -> Result<Self::Pair, ()> {
+		let mut secret_key = [0u8; 32];
+		secret_key.copy_from_slice(&slice[..32]);
+		let pair = Self::Pair::from_seed_slice(&secret_key[..]).unwrap();
+		Ok(pair)
+	}
+	fn crypto_type() -> &'static str { "ecdsa" }
+}
+
+impl Ecdsa {
+	// Return `https://github.com/polkadot-js` compatible address.
+	pub fn to_js_ss58check<P: Pair>(pair: &P) -> String {
+		let raw = pair.public().to_raw_vec();
+		let hash = Self::prehash(&raw[..]);
+		let mut raw = [0u8; 32];
+		raw.copy_from_slice(&hash.as_bytes()[..]);
+		let public = EcdsaPublic(raw);
+		public.to_ss58check()
+	}
+
+	fn prehash(data: &[u8]) -> Blake2bResult {
+		let mut context = Blake2b::new(32);
+		context.update(data);
+		context.finalize()
+	}
+}
+
+
+pub struct Sr25519;
+impl Crypto for Sr25519 {
+	type Pair = sr25519::Pair;
+	type Public = sr25519::Public;
+
+	fn pair_from_secret_slice(slice: &[u8]) -> Result<Self::Pair, ()> {
+		Ok(Self::Pair::from_seed_slice(&slice[..]).unwrap())
+	}
+
+	fn crypto_type() -> &'static str { "sr25519" }
+}
+
+

src/keystore.rs

@@ -0,0 +1,76 @@
+use std::fs;
+use serde::{Serialize, Deserialize};
+use serde_json::Value;
+use crate::crypto::*;
+use crate::pkcs8;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Encoding {
+	pub content: Vec<String>,
+	pub r#type: String,
+	pub version: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Keystore {
+	pub address: String,
+	pub encoded: String,
+	pub encoding: Encoding,
+	pub meta: Value,
+}
+
+
+impl Keystore {
+	pub fn parse_from_file(path: String) -> Result<Self, ()> {
+		let data = fs::read_to_string(path).map_err(|_| () )?;
+		let keystore: Self = serde_json::from_str(&data).map_err( |_| () )?;
+		Ok(keystore)
+	}
+
+	pub fn crypto(&self) -> String {
+		self.encoding.content[1].clone()
+	}
+
+	pub fn label(&self) -> String {
+		self.meta["name"].as_str().unwrap_or("").to_string()
+	}
+
+	pub fn genesis_hash(&self) -> String {
+		self.meta["genesisHash"].as_str().unwrap_or("").to_string()
+	}
+
+	pub fn when_created(&self) -> u64 {
+		self.meta["whenCreated"].as_u64().unwrap_or(0u64)
+	}
+
+	pub fn to_json(&self) -> String {
+		serde_json::to_string(&self).unwrap()
+	}
+
+	pub fn encoded_bytes(&self) -> Vec<u8> {
+		let encoded = if self.encoded.starts_with("0x") {
+			&self.encoded[2..]
+		} else {
+			&self.encoded
+		};
+		hex::decode(encoded).unwrap_or(vec![])
+	}
+
+	pub fn into_pair<T: Crypto>(&self, password: Option<String>) -> Result<T::Pair, ()> {
+		let encoded = self.encoded_bytes();
+		if encoded.is_empty() {
+			return Err(())
+		}
+		match pkcs8::decode(&encoded[..], password) {
+			Ok((_, secret_key)) => {
+				T::pair_from_secret_slice(&secret_key[..])
+			},
+			Err(_) => Err(())
+		}
+	}
+}
+
+
+
+
+

src/main.rs

@@ -0,0 +1,104 @@
+
+mod keystore;
+mod crypto;
+mod command;
+mod wallet;
+mod pkcs8;
+
+use sp_core::crypto::{Ss58AddressFormat, set_default_ss58_version};
+use std::path::Path;
+use std::fs;
+use keystore::Keystore;
+use crypto::*;
+use wallet::*;
+
+fn main() {
+	let mut app = command::get_app();
+	let matches = app.clone().get_matches();
+	set_default_ss58_version(Ss58AddressFormat::PolkadotAccount);
+	let store = WalletStore::init(None);
+
+	match matches.subcommand() {
+		("getnewaddress", Some(matches)) => {
+			let label = matches.value_of("label").unwrap();
+			let mut address = if matches.is_present("ed25519") {
+				Address::generate::<Ed25519>()
+			} else if matches.is_present("secp256k1") {
+				Address::generate::<Ecdsa>()
+			} else {
+				Address::generate::<Sr25519>()
+			};
+
+			address.label = label.to_string();
+			store.save(address.clone());
+			println!("{}", address.addr);
+		}
+		("listaddresses", Some(_)) => {
+			let addresses = store.read_all();
+			for address in addresses {
+				address.print();
+			}
+		}
+		("restore", Some(matches)) => {
+			let file = matches.value_of("file").unwrap();
+
+			let keystore = match Keystore::parse_from_file(file.to_string()) {
+				Ok(keystore) => keystore,
+				Err(_) => {
+					println!("Failed to parse keystore file");
+					return
+				}
+			};
+
+			let password = rpassword::read_password_from_tty(Some("Password: ")).ok();
+			if let Ok(address) = Address::from_keystore(keystore, password) {
+				store.save(address.clone());
+				println!("Address `{}` is restored", address.addr);
+			} else {
+				println!("Failed to recover address");
+				return
+			}
+		}
+		("backup", Some(matches)) => {
+			let label  = matches.value_of("label").unwrap();
+			let file  = matches.value_of("path").unwrap();
+
+			let address = match store.read(label) {
+				Some(address) => address,
+				None => {
+					println!("`{}` related address does not exist.", label);
+					return
+				}
+			};
+
+			let path = Path::new(file);
+			let full_path = if path.ends_with("/") || path.is_dir() { // dir
+				let file_name = format!("{}.json", address.addr.as_str());
+				let mut path = path.to_path_buf();
+				path.push(file_name);
+				path
+			} else { // file
+				path.to_path_buf()
+			};
+
+			if full_path.exists() {
+				eprintln!("File `{}` aleady exists", full_path.to_str().unwrap());
+				return
+			}
+
+			let password = rpassword::read_password_from_tty(Some("Type password to encrypt seed: ")).ok();
+
+			let keystore = address.into_keystore(password);
+
+			if let Err(e) =  fs::write(full_path.clone(), keystore.to_json()) {
+				println!("Failed to write to file: {:?}", e);
+			} else {
+				println!("Address `{}` is backed up to file `{}`", address.addr, full_path.to_str().unwrap());
+			}
+		}
+		_ => {
+			app.print_help().unwrap();
+			println!();
+		}
+	}
+}