feat: pjs vault

libwallet/Cargo.toml

@@ -15,8 +15,8 @@ serde = {version = "1.0", default-features = false, features = ["derive"], optio
 hmac = {version = "0.12.1", default-features = false, optional = true}
 pbkdf2 = {version = "0.11.0", default-features = false, optional = true}
 sha2 = {version = "0.10.2", default-features = false, optional = true}
-
-mnemonic = {package = "bip0039", version = "0.10.1", default-features = false, optional = true}
+pjs = { path = "../pjs-rs", optional = true }
+mnemonic = { package = "bip0039", version = "0.10.1", default-features = false, optional = true}
 
 rand_core = {version = "0.6.3", optional = true}
 # substrate related
@@ -35,8 +35,7 @@ serde_json = {version = "1.0", default-features = false, features = ["alloc"]}
 dirs = "4.0"
 
 [features]
-# The library has no default features but this can be uncommented during development
-# default = [ "std",  "substrate",  "vault_simple",  "vault_os",  "vault_pass",  "mnemonic",  "util_pin", "rand", ]
+default = ["std", "substrate", "vault_simple", "mnemonic", "rand", "vault_pass", "vault_os", "util_pin", "vault_pjs"]
 rand = ["rand_core", "schnorrkel?/getrandom"]
 sr25519 = ["dep:schnorrkel"]
 std = [
@@ -46,6 +45,8 @@ substrate = ["sr25519"]
 util_pin = ["pbkdf2", "hmac", "sha2"]
 vault_os = ["keyring"]
 vault_pass = ["prs-lib"]
+vault_simple = []
+vault_pjs = ["pjs"]
 
 [workspace]
 members = [

libwallet/examples/account_generation.rs

@@ -1,7 +1,7 @@
-use libwallet::{self, vault};
+use libwallet::{self, vault, Account};
 use std::env;
 
-type Wallet = libwallet::Wallet<vault::Simple>;
+type Wallet = libwallet::Wallet<vault::Simple<String>>;
 
 #[async_std::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -15,10 +15,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     let mut wallet = Wallet::new(vault);
-    wallet.unlock(None).await?;
+    wallet.unlock(None, None).await?;
     let account = wallet.default_account();
 
     println!("Secret phrase: \"{phrase}\"");
-    println!("Default Account: 0x{account}");
+    println!("Default Account: 0x{:?}", account.unwrap());
     Ok(())
 }

libwallet/examples/persisted_in_keyring.rs

@@ -2,7 +2,7 @@ use libwallet::{self, vault, Language};
 
 use std::{env, error::Error};
 
-type Wallet = libwallet::Wallet<vault::OSKeyring>;
+type Wallet = libwallet::Wallet<vault::OSKeyring<String>>;
 
 const TEST_USER: &str = "test_user";
 
@@ -11,12 +11,15 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let pin = env::args().nth(1);
     let pin = pin.as_ref().map(String::as_str);
 
-    let vault = vault::OSKeyring::new(TEST_USER, Language::default());
+    let vault = vault::OSKeyring::<String>::new(TEST_USER, Language::default());
+
     let mut wallet = Wallet::new(vault);
-    wallet.unlock(pin).await?;
+
+
+    wallet.unlock(None, pin).await?;
 
     let account = wallet.default_account();
-    println!("Default account: {}", account);
+    println!("Default account: {}", account.unwrap());
 
     Ok(())
 }

libwallet/examples/persisted_in_pass.rs

@@ -1,7 +1,8 @@
 use dirs::home_dir;
 use libwallet::{self, vault::Pass, Language};
 use std::error::Error;
-type Wallet = libwallet::Wallet<Pass>;
+type PassVault = Pass<String>;
+type Wallet = libwallet::Wallet<PassVault>;
 
 #[async_std::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -13,10 +14,10 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let vault = Pass::new(store_path.to_str().unwrap(), Language::default());
     let mut wallet = Wallet::new(vault);
 
-    wallet.unlock(account).await?;
+    wallet.unlock(None, account).await?;
 
     let account = wallet.default_account();
-    println!("Default account: {}", account);
+    println!("Default account: {}", account.unwrap());
 
     Ok(())
 }

libwallet/src/account.rs

@@ -1,103 +1,9 @@
+use core::fmt::{Debug, Display};
+
 use crate::{
-    any::{self, AnySignature},
-    Derive, Network, Pair, Public, RootAccount,
+    Public, Signer,
 };
-use arrayvec::ArrayString;
-// use regex::Regex;
-// use sp_core::crypto::DeriveJunction;
-
-const MAX_PATH_LEN: usize = 16;
-
-/// Account is an abstration around public/private key pairs that are more convenient to use and
-/// can hold extra metadata. Accounts are constructed by the wallet and are used to sign messages.
-#[derive(Debug)]
-pub struct Account {
-    pair: Option<any::Pair>,
-    network: Network,
-    path: ArrayString<MAX_PATH_LEN>,
-    name: ArrayString<{ MAX_PATH_LEN - 2 }>,
-}
-
-impl Account {
-    pub(crate) fn new<'a>(name: impl Into<Option<&'a str>>) -> Self {
-        let n = name.into().unwrap_or_else(|| "default");
-        let mut path = ArrayString::from("//").unwrap();
-        path.push_str(&n);
-        Account {
-            pair: None,
-            network: Network::default(),
-            name: ArrayString::from(&n).expect("short name"),
-            path,
-        }
-    }
-
-    pub fn switch_network(self, net: impl Into<Network>) -> Self {
-        Account {
-            network: net.into(),
-            ..self
-        }
-    }
-
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    pub fn public(&self) -> impl Public {
-        self.pair.as_ref().expect("account unlocked").public()
-    }
-
-    pub fn network(&self) -> &Network {
-        &self.network
-    }
-
-    pub fn is_locked(&self) -> bool {
-        self.pair.is_none()
-    }
-
-    pub(crate) fn unlock(&mut self, root: &RootAccount) -> &Self {
-        if self.is_locked() {
-            self.pair = Some(root.derive(&self.path));
-        }
-        self
-    }
-}
-
-impl crate::Signer for Account {
-    type Signature = AnySignature;
-
-    fn sign_msg<M: AsRef<[u8]>>(&self, msg: M) -> Self::Signature {
-        self.pair.as_ref().expect("account unlocked").sign_msg(msg)
-    }
-
-    fn verify<M: AsRef<[u8]>>(&self, msg: M, sig: &[u8]) -> bool {
-        self.pair
-            .as_ref()
-            .expect("account unlocked")
-            .verify(msg, sig)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Account {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut state = serializer.serialize_struct("Account", 1)?;
-        state.serialize_field("network", &self.network)?;
-        state.serialize_field("path", self.path.as_str())?;
-        state.serialize_field("name", self.name.as_str())?;
-        state.end()
-    }
-}
 
-impl core::fmt::Display for Account {
-    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-        for byte in self.public().as_ref() {
-            write!(f, "{:02x}", byte)?;
-        }
-        Ok(())
-    }
+pub trait Account: Signer + Display {
+    fn public(&self) -> impl Public;
 }

libwallet/src/key_pair.rs

@@ -1,7 +1,9 @@
-use core::fmt::Debug;
+use core::{convert::TryFrom, fmt::Debug};
 
 pub use derive::Derive;
 
+use self::any::AnySignature;
+
 type Bytes<const N: usize> = [u8; N];
 
 /// A key pair with a public key
@@ -24,12 +26,13 @@ impl<const N: usize> Signature for Bytes<N> {}
 /// Something that can sign messages
 pub trait Signer {
     type Signature: Signature;
-    fn sign_msg<M: AsRef<[u8]>>(&self, msg: M) -> Self::Signature;
-    fn verify<M: AsRef<[u8]>>(&self, msg: M, sig: &[u8]) -> bool;
+    async fn sign_msg(&self, data: impl AsRef<[u8]>) -> Result<Self::Signature, ()>;
+    async fn verify(&self, msg: impl AsRef<[u8]>, sig: impl AsRef<[u8]>) -> bool;
 }
-
 /// Wrappers to represent any supported key pair.
 pub mod any {
+    use crate::Signer;
+
     use super::{Public, Signature};
     use core::fmt;
 
@@ -91,19 +94,17 @@ pub mod any {
     impl super::Signer for Pair {
         type Signature = AnySignature;
 
-        fn sign_msg<M: AsRef<[u8]>>(&self, msg: M) -> Self::Signature {
+        async fn sign_msg(&self, msg: impl AsRef<[u8]>) -> Result<Self::Signature, ()> {
             match self {
                 #[cfg(feature = "sr25519")]
-                Pair::Sr25519(p) => p.sign_msg(msg).into(),
+                Pair::Sr25519(p) => Ok(p.sign_msg(msg).await?.into()),
             }
         }
 
-        fn verify<M: AsRef<[u8]>>(&self, msg: M, sig: &[u8]) -> bool {
+        async fn verify(&self, msg: impl AsRef<[u8]>, sig: impl AsRef<[u8]>) -> bool {
             match self {
                 #[cfg(feature = "sr25519")]
-                Pair::Sr25519(p) => super::Signer::verify(p, msg, sig),
-                #[cfg(not(feature = "sr25519"))]
-                Pair::_None => unreachable!(),
+                Pair::Sr25519(p) => super::Signer::verify(p, msg, sig).await,
             }
         }
     }
@@ -145,6 +146,7 @@ pub mod any {
         #[cfg(not(feature = "sr25519"))]
         _None,
     }
+
     impl AsRef<[u8]> for AnySignature {
         fn as_ref(&self) -> &[u8] {
             match self {
@@ -198,13 +200,13 @@ pub mod sr25519 {
     impl Signer for Pair {
         type Signature = Signature;
 
-        fn sign_msg<M: AsRef<[u8]>>(&self, msg: M) -> Self::Signature {
+        async fn sign_msg(&self, msg: impl AsRef<[u8]>) -> Result<Self::Signature, ()> {
             let context = signing_context(SIGNING_CTX);
-            self.sign(context.bytes(msg.as_ref())).to_bytes()
+            Ok(self.sign(context.bytes(msg.as_ref())).to_bytes())
         }
 
-        fn verify<M: AsRef<[u8]>>(&self, msg: M, sig: &[u8]) -> bool {
-            let sig = match schnorrkel::Signature::from_bytes(sig) {
+        async fn verify(&self, msg: impl AsRef<[u8]>, sig: impl AsRef<[u8]>) -> bool {
+            let sig = match schnorrkel::Signature::from_bytes(sig.as_ref()) {
                 Ok(s) => s,
                 Err(_) => return false,
             };
@@ -310,6 +312,7 @@ pub mod sr25519 {
             ] {
                 let phrase = Mnemonic::from_phrase(phrase).unwrap();
                 let seed = Pin::from("").protect::<64>(&phrase.entropy());
+
                 let root: super::Pair = Pair::from_bytes(&seed);
                 let derived = root.derive(path);
                 assert_eq!(&derived.public(), pubkey);