feat: pjs vault

libwallet/Cargo.toml

@@ -15,14 +15,15 @@ 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, default-features = false }
+mnemonic = { package = "bip0039", version = "0.10.1", default-features = false, optional = true}
+sp-core = { version = "32.0.0", optional = true }
 rand_core = {version = "0.6.3", optional = true}
 # substrate related
 schnorrkel = {version = "0.11.4", default-features = false, optional = true}# soft derivation in no_std
 rand_chacha = {version = "0.3.1", default-features = false, optional = true}
-
+hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
+log = "0.4.17"
 # vault os
 keyring = {version = "1.1.2", optional = true}
 # vault pass
@@ -35,7 +36,7 @@ serde_json = {version = "1.0", default-features = false, features = ["alloc"]}
 dirs = "4.0"
 
 [features]
-# default = ["std", "substrate", "vault_simple", "mnemonic", "rand", "vault_pass", "vault_os", "util_pin"]
+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 +47,7 @@ util_pin = ["pbkdf2", "hmac", "sha2"]
 vault_os = ["keyring"]
 vault_pass = ["prs-lib"]
 vault_simple = []
+vault_pjs = ["pjs", "sp-core"]
 
 [workspace]
 members = [

libwallet/js/src/wallet.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use serde_wasm_bindgen::from_value;
 use wasm_bindgen::prelude::*;
 
-use libwallet::{vault::Simple, Signer, Wallet};
+use libwallet::{vault::Simple, Account, Signer, Wallet};
 
 #[derive(Serialize, Deserialize)]
 pub enum WalletConstructor {
@@ -13,7 +13,7 @@ pub enum WalletConstructor {
 #[wasm_bindgen(inspectable)]
 pub struct JsWallet {
     phrase: String,
-    wallet: Wallet<Simple>,
+    wallet: Wallet<Simple<String>>,
 }
 
 #[wasm_bindgen]
@@ -48,74 +48,66 @@ impl JsWallet {
 
     #[wasm_bindgen]
     pub async fn unlock(&mut self, credentials: JsValue) -> Result<(), JsValue> {
-        let credentials: <Simple as libwallet::Vault>::Credentials =
+        let credentials: <Simple<String> as libwallet::Vault>::Credentials =
             if credentials.is_null() || credentials.is_undefined() {
                 None
             } else {
                 from_value(credentials).unwrap_or(None)
             };
 
         self.wallet
-            .unlock(credentials)
+            .unlock(None, credentials)
             .await
             .map_err(|e| JsError::new(&e.to_string()))?;
 
         Ok(())
     }
 
     #[wasm_bindgen(js_name = getAddress)]
-    pub fn get_address(&self) -> Result<JsPublicAddress, JsError> {
+    pub fn get_address(&self) -> Result<JsBytes, JsError> {
         if self.wallet.is_locked() {
             return Err(JsError::new(
                 "The wallet is locked. You should unlock it first by using the .unlock() method",
             ));
         }
 
-        Ok(JsPublicAddress::new(
-            self.wallet.default_account().public().as_ref().to_vec(),
+        Ok(JsBytes::new(
+            self.wallet.default_account().unwrap().public().as_ref().to_vec(),
         ))
     }
 
     #[wasm_bindgen]
-    pub fn sign(&self, message: &[u8]) -> Result<Box<[u8]>, JsError> {
+    pub async fn sign(&self, message: &[u8]) -> Result<JsBytes, JsError> {
         if self.wallet.is_locked() {
             return Err(JsError::new(
                 "The wallet is locked. You should unlock it first by using the .unlock() method",
             ));
         }
 
-        let sig = self.wallet.sign(message);
-
-        if !self
-            .wallet
-            .default_account()
-            .verify(&message, &sig.as_ref())
-        {
-            return Err(JsError::new("Message could not be verified"));
-        }
-
-        Ok(sig.as_ref().to_vec().into_boxed_slice())
+        let sig = self.wallet.sign(message).await.map_err(|_| JsError::new("Error while signing"))?;
+        let f = sig.as_ref().to_vec();
+        Ok(JsBytes::new(f))
     }
 
     #[wasm_bindgen]
-    pub fn verify(&self, msg: &[u8], sig: &[u8]) -> Result<bool, JsError> {
+    pub async fn verify(&self, msg: &[u8], sig: &[u8]) -> Result<bool, JsError> {
         if self.wallet.is_locked() {
             return Err(JsError::new(
                 "The wallet is locked. You should unlock it first by using the .unlock() method",
             ));
         }
 
-        Ok(self.wallet.default_account().verify(msg, sig))
+        Ok(self.wallet.default_account().unwrap().verify(msg, sig).await)
     }
 }
 
 #[wasm_bindgen(inspectable)]
-pub struct JsPublicAddress {
+pub struct JsBytes {
     repr: Vec<u8>,
 }
 
 #[wasm_bindgen]
-impl JsPublicAddress {
+impl JsBytes {
     #[wasm_bindgen(constructor)]
     pub fn new(repr: Vec<u8>) -> Self {
         Self { repr }

libwallet/src/key_pair.rs

@@ -1,4 +1,4 @@
-use core::{convert::TryFrom, fmt::Debug};
+use core::{convert::{TryFrom, TryInto}, fmt::Debug};
 
 pub use derive::Derive;
 
@@ -20,7 +20,11 @@ pub trait Pair: Signer + Derive {
 pub trait Public: AsRef<[u8]> + Debug {}
 impl<const N: usize> Public for Bytes<N> {}
 
-pub trait Signature: AsRef<[u8]> + Debug + PartialEq {}
+pub trait Signature: AsRef<[u8]> + Debug + PartialEq {
+    fn as_bytes<const N: usize>(&self) -> Bytes<N> {
+        self.as_ref().try_into().expect("error getting the bytes")
+    }
+}
 impl<const N: usize> Signature for Bytes<N> {}
 
 /// Something that can sign messages

libwallet/src/vault.rs

@@ -1,16 +1,21 @@
 //! Collection of supported Vault backends
 #[cfg(feature = "vault_os")]
 mod os;
+
+#[cfg(feature = "vault_pjs")]
+pub mod pjs;
+
+#[cfg(feature = "vault_pjs")]
+pub use pjs::*;
+
 #[cfg(feature = "vault_pass")]
 mod pass;
-mod simple;
 
-#[cfg(feature = "vault_os")]
-pub use os::*;
 #[cfg(feature = "vault_pass")]
 pub use pass::*;
-pub use simple::*;
 
+mod simple;
+pub use simple::*;
 use crate::account::Account;
 
 /// Abstraction for storage of private keys that are protected by some credentials.

libwallet/src/vault/pjs.rs

@@ -0,0 +1,87 @@
+extern crate alloc;
+use crate::{any::AnySignature, Account, Signer, Vault};
+use alloc::vec::Vec;
+use pjs::{Account as PjsAccount, Error, PjsExtension};
+use log;
+use hex;
+use sp_core::crypto::{AccountId32, Ss58Codec};
+
+#[derive(Clone)]
+pub struct Pjs {
+    inner: PjsExtension,
+}
+
+impl Pjs {
+    pub async fn connect(name: &str) -> Result<Self, Error> {
+        Ok(Pjs {
+            inner: PjsExtension::connect(name).await?,
+        })
+    }
+
+    pub async fn list_accounts(&mut self) -> Result<Vec<PjsAccount>, Error> {
+        self.inner.fetch_accounts().await?;
+        Ok(self.inner.accounts())
+    }
+
+    pub fn select_account(&mut self, idx: u8) {
+        self.inner.select_account(idx)
+    }
+}
+
+impl Signer for Pjs {
+    type Signature = AnySignature;
+
+    async fn sign_msg(&self, msg: impl AsRef<[u8]>) -> Result<Self::Signature, ()> {
+        log::info!("signing: {}", hex::encode(&msg.as_ref()));
+        let sig = self.inner.sign(msg.as_ref()).await.map_err(|_| ())?;
+        log::info!("signature {:?}", hex::encode(&sig));
+        Ok(AnySignature::from(sig))
+    }
+
+    async fn verify(&self, _: impl AsRef<[u8]>, _: impl AsRef<[u8]>) -> bool {
+        unimplemented!()
+    }
+}
+
+impl Account for Pjs {
+    fn public(&self) -> impl crate::Public {
+        let mut key = [0u8; 32];
+
+        let address = self
+            .inner
+            .get_selected()
+            .expect("an account must be defined")
+            .address();
+
+        let address = <AccountId32 as Ss58Codec>::from_string(&address)
+            .expect("it must be a valid ss58 address");
+        key.copy_from_slice(address.as_ref());
+        key
+    }
+}
+
+impl core::fmt::Display for Pjs {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        for byte in self.public().as_ref() {
+            write!(f, "{:02x}", byte)?;
+        }
+        Ok(())
+    }
+}
+
+impl Vault for Pjs {
+    type Id = u8;
+    type Credentials = ();
+    type Account = Pjs;
+    type Error = Error;
+
+    async fn unlock(
+        &mut self,
+        account: Self::Id,
+        _: impl Into<Self::Credentials>,
+    ) -> Result<Self::Account, Self::Error> {
+        let mut pjs_signer = self.clone();
+        pjs_signer.select_account(account);
+        Ok(pjs_signer)
+    }
+}

pjs-rs/Cargo.toml

@@ -4,8 +4,10 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-wasm-bindgen = { version = "0.2.92", default-features = false }
+wasm-bindgen = { version = "0.2.91", default-features = false }
 wasm-bindgen-futures = "0.4.42"
+log = "0.4.19"
+hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
 
 [dependencies.web-sys]
 version = "0.3.69"
@@ -18,6 +20,4 @@ default = ["js"]
 js = []
 
 [lib]
-crate-type = ["cdylib"]
-
-
+crate-type = ["cdylib", "lib"]