Merge pull request #62 from Relayz-io/silvestr/improve-keypair

Improve keypair API

.github/workflows/ci.yml

 env:
   CARGO_TERM_COLOR: always
 
-on: 
+on:
   push:
     branches:
       - main
       - name: Install Rust Toolchain
         uses: actions-rs/toolchain@v1
         with:
-            toolchain: nightly
-            components: rustfmt
+          toolchain: nightly
+          components: rustfmt
       - name: cargo fmt
         run: cargo +nightly fmt -- --check
   clippy:
       - name: Install Rust Toolchain
         uses: actions-rs/toolchain@v1
         with:
-            toolchain: nightly
-            components: clippy
+          toolchain: nightly
+          components: clippy
       - name: cargo clippy
-        run: cargo +nightly clippy --all --tests -- -D warnings
+        run: cargo +nightly clippy --workspace --tests -- -D warnings
       - name: Install wasm32-unknown-unknown
         run: rustup +nightly target add wasm32-unknown-unknown
       - name: cargo clippy for wasm32-unknown-unknown
-        run: cargo +nightly clippy --all --target wasm32-unknown-unknown -- -D warnings
+        run: cargo +nightly clippy --workspace --target wasm32-unknown-unknown -- -D warnings
   build:
     name: build
     needs: [clippy, fmt]
       - name: Install Rust Toolchain
         uses: actions-rs/toolchain@v1
         with:
-            toolchain: stable
+          toolchain: stable
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
-      - name: cargo build [wasm-client, near-client] for wasm
-        run: cargo build --all --target wasm32-unknown-unknown --release
-      - name: cargo build [near-client]
-        run: cargo build --all --release
+      - name: cargo build [web-client, near-client, common-api] for wasm
+        run: cargo build -p web-client -p near-client -p common-api --target wasm32-unknown-unknown --release
+      - name: cargo build [near-client, common-api]
+        run: cargo build -p near-client -p common-api --tests --release
+  tests:
+    name: tests
+    needs: [clippy, fmt]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust Toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Run unit-tests for [common-api]
+        run: cargo test -p common-api crypto
+      - name: Run integration-tests for [common-api]
+        run: cargo test -p common-api --test crypto

.github/workflows/issue-link.yml

-name: 'Issue Links'
-on:
-  pull_request:
-    types: [opened]
-
-jobs:
-  issue-links:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: tkt-actions/add-issue-links@v1.8.0
-        with:
-          header: '### Issue'
-          repo-token: '${{ secrets.GITHUB_TOKEN }}'
-          resolve: 'true'
-          branch-prefix: '/'

common-api/Cargo.toml

 x25519-dalek = { version = "1", features = ["serde"] }
 
 [dev-dependencies]
-anyhow = "1"
 rand = "0.8.5"
 rand_chacha = "0.3"

common-api/src/crypto/ed25519.rs

     fmt::Display,
     hash::{Hash, Hasher},
     io::{Error as IoError, ErrorKind},
+    str::FromStr,
 };
 
 use super::{split_encoded_str, Error, Key, Result, ED25519};
 
 pub use ed25519_dalek::{
-    PUBLIC_KEY_LENGTH as ED25519_PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH as ED25519_SECRET_KEY_LENGTH,
-    SIGNATURE_LENGTH as ED25519_SIGNATURE_LENGTH,
+    KEYPAIR_LENGTH as ED25519_KEYPAIR_LENGTH, PUBLIC_KEY_LENGTH as ED25519_PUBLIC_KEY_LENGTH,
+    SECRET_KEY_LENGTH as ED25519_SECRET_KEY_LENGTH, SIGNATURE_LENGTH as ED25519_SIGNATURE_LENGTH,
 };
 
-#[derive(Copy, Clone, Default, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
 pub struct Ed25519PublicKey(PublicKey);
 
 impl Ed25519PublicKey {
+    /// Verifies the signature of a signed data
     pub fn verify(&self, data: &[u8], signature: &Ed25519Signature) -> Result<()> {
         self.0
             .verify(data, &signature.0)
 pub struct Ed25519SecretKey(SecretKey);
 
 impl Ed25519SecretKey {
+    /// Sign a `data` with a private key
     pub fn sign(&self, data: &[u8], public_key: &Ed25519PublicKey) -> Ed25519Signature {
         let expanded_key = ExpandedSecretKey::from(&self.0);
         Ed25519Signature(expanded_key.sign(data, &public_key.0))
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct Ed25519Signature(Signature);
 
 impl Key<ED25519_SIGNATURE_LENGTH> for Ed25519Signature {
     }
 }
 
+/// Contains public and secret user keys
 #[derive(Serialize, Deserialize)]
 pub struct Keypair {
     public_key: Ed25519PublicKey,
         }
     }
 
-    pub fn from_encoded(encoded: &str) -> Result<Self> {
-        let secret_key = Ed25519SecretKey::from_expanded(encoded)?;
+    pub fn from_expanded_secret(expanded: &str) -> Result<Self> {
+        let secret_key = Ed25519SecretKey::from_expanded(expanded)?;
         let public_key = Ed25519PublicKey::from(&secret_key);
         Ok(Self {
             public_key,
     }
 }
 
+impl ToString for Keypair {
+    fn to_string(&self) -> String {
+        let keypair_bytes = self
+            .secret_key()
+            .as_bytes()
+            .iter()
+            .chain(self.public_key().as_bytes().iter())
+            .copied()
+            .collect_vec();
+
+        format!("{ED25519}:{}", bs58::encode(keypair_bytes).into_string())
+    }
+}
+
+impl FromStr for Keypair {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let (key_type, data) = split_encoded_str(s)?;
+
+        if key_type != ED25519 {
+            return Err(Error::WrongKeyType {
+                key_type: key_type.to_owned(),
+                expected_key_type: ED25519,
+            });
+        }
+
+        let byte_data = bs58::decode(data)
+            .into_vec()
+            .map_err(|err| Error::from_string::<Keypair>(data.to_owned(), err.to_string()))?;
+
+        if byte_data.len() != ED25519_KEYPAIR_LENGTH {
+            return Err(Error::from_bytes::<Keypair>(
+                &byte_data,
+                format!(
+                    "Keypair byte array length doesn't equal\
+                     to requested length {ED25519_KEYPAIR_LENGTH}"
+                ),
+            ));
+        }
+
+        Ok(Self {
+            secret_key: Ed25519SecretKey::try_from_bytes(&byte_data[..ED25519_SECRET_KEY_LENGTH])?,
+            public_key: Ed25519PublicKey::try_from_bytes(&byte_data[ED25519_SECRET_KEY_LENGTH..])?,
+        })
+    }
+}
+
 serde_impl!(Ed25519PublicKey);
 serde_impl!(Ed25519SecretKey);
 serde_impl!(Ed25519Signature);

common-api/src/crypto/mod.rs

     use super::{split_encoded_str, Error, ED25519, X25519};
 
     #[test]
-    fn split_encoded() -> anyhow::Result<()> {
+    fn split_encoded() {
         let bs58_str = bs58::encode(vec![0, 0, 0]).into_string();
         assert!(matches!(
                 split_encoded_str(&format!("ed25519:{}", bs58_str)),
             split_encoded_str(&bs58_str),
             Err(Error::UnknownKeyType(..))
         ));
-        Ok(())
     }
 }

common-api/tests/crypto.rs

+use std::str::FromStr;
+
 use borsh::BorshDeserialize;
 use common_api::crypto::prelude::*;
 use ed25519_dalek::{ExpandedSecretKey, SecretKey as DalekSecretKey};
 use rand_chacha::ChaChaRng;
 
 #[test]
-fn try_from_bytes_ed25519() -> anyhow::Result<()> {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+fn try_from_bytes_ed25519() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = Ed25519PublicKey::from(&sk);
-    let _ = Ed25519PublicKey::try_from_bytes(pk.as_bytes())?;
+    let _ = Ed25519PublicKey::try_from_bytes(pk.as_bytes()).unwrap();
 
     assert!(matches!(
         Ed25519PublicKey::try_from_bytes(&[0, 0, 0]),
         Ed25519SecretKey::try_from_bytes(&[0, 0, 0]),
         Err(Error::ConvertFromBytes { .. })
     ));
-
-    Ok(())
 }
 
 #[test]
-fn to_string_ed25519() -> anyhow::Result<()> {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+fn to_string_ed25519() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = Ed25519PublicKey::from(&sk);
 
     assert_eq!(
         format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()),
         pk.string()
     );
-
-    Ok(())
 }
 
 #[test]
-fn from_string_ed25519() -> anyhow::Result<()> {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+fn from_string_ed25519() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = Ed25519PublicKey::from(&sk);
 
     let _ = Ed25519SecretKey::from_string(
         format!("ed25519:{}", bs58::encode(sk.as_bytes()).into_string()).as_str(),
-    )?;
+    )
+    .unwrap();
 
     let _ = Ed25519PublicKey::from_string(
         format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()).as_str(),
-    )?;
+    )
+    .unwrap();
 
     assert!(matches!(
         Ed25519PublicKey::from_string(
         Ed25519PublicKey::from_string(format!("ed25519:{}", "==1234%#").as_str(),),
         Err(Error::ConvertFromString { .. })
     ));
-
-    Ok(())
 }
 
 #[test]
-fn from_expanded() -> anyhow::Result<()> {
-    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits())?);
+fn from_expanded() {
+    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits()).unwrap());
     let exp_str = format!(
         "ed25519:{}",
         bs58::encode(dalek_sk.to_bytes()).into_string()
     );
-    let sk = Ed25519SecretKey::from_expanded(&exp_str)?;
+    let sk = Ed25519SecretKey::from_expanded(&exp_str).unwrap();
 
     assert_eq!(sk.as_bytes(), &dalek_sk.to_bytes()[..32]);
-    Ok(())
 }
 
 #[test]
-fn from_expanded_fail() -> anyhow::Result<()> {
-    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits())?);
+fn from_expanded_fail() {
+    let dalek_sk = ExpandedSecretKey::from(&DalekSecretKey::from_bytes(&random_bits()).unwrap());
 
     let exp_str = bs58::encode(dalek_sk.to_bytes()).into_string();
     assert!(matches!(
         Ed25519SecretKey::from_expanded(&exp_str),
         Err(Error::ConvertFromString { .. })
     ));
-
-    Ok(())
 }
 
 #[test]
-fn try_from_bytes_x25519() -> anyhow::Result<()> {
-    let sk = SecretKey::try_from_bytes(&random_bits())?;
+fn try_from_bytes_x25519() {
+    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = PublicKey::from(&sk);
-    let _ = PublicKey::try_from_bytes(&pk.to_bytes())?;
+    let _ = PublicKey::try_from_bytes(&pk.to_bytes()).unwrap();
 
     assert!(matches!(
         PublicKey::try_from_bytes(&[0, 0, 0]),
         SecretKey::try_from_bytes(&[0, 0, 0]),
         Err(Error::ConvertFromBytes { .. })
     ));
-
-    Ok(())
 }
 
 #[test]
-fn to_string_x25519() -> anyhow::Result<()> {
-    let sk = SecretKey::try_from_bytes(&random_bits())?;
+fn to_string_x25519() {
+    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = PublicKey::from(&sk);
 
     assert_eq!(
         format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()),
         pk.string()
     );
-
-    Ok(())
 }
 
 #[test]
-fn from_string_x25519() -> anyhow::Result<()> {
-    let sk = SecretKey::try_from_bytes(&random_bits())?;
+fn from_string_x25519() {
+    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = PublicKey::from(&sk);
 
     let _ = SecretKey::from_string(
         format!("x25519:{}", bs58::encode(&sk.to_bytes()).into_string()).as_str(),
-    )?;
+    )
+    .unwrap();
 
     let _ = PublicKey::from_string(
         format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()).as_str(),
-    )?;
+    )
+    .unwrap();
 
     assert!(matches!(
         PublicKey::from_string(
         PublicKey::from_string(format!("x25519:{}", "==1234%#").as_str(),),
         Err(Error::ConvertFromString { .. })
     ));
-
-    Ok(())
 }
 
 #[test]
-fn public_key_verify() -> anyhow::Result<()> {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+fn public_key_verify() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
     let pk = Ed25519PublicKey::from(&sk);
 
     let signature = sk.sign(b"message", &pk);
-    pk.verify(b"message", &signature)?;
-
-    Ok(())
+    pk.verify(b"message", &signature).unwrap();
 }
 
 #[test]
-fn keypair_verify() -> anyhow::Result<()> {
-    let keypair = Keypair::new(Ed25519SecretKey::try_from_bytes(&random_bits())?);
+fn keypair_verify() {
+    let keypair = Keypair::new(Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap());
     let signature = keypair.sign(b"message");
-    keypair.verify(b"message", &signature)?;
-
-    Ok(())
+    keypair.verify(b"message", &signature).unwrap();
 }
 
 #[test]
-fn key_exchange() -> anyhow::Result<()> {
-    let alice_sk = SecretKey::try_from_bytes(&random_bits())?;
+fn key_exchange() {
+    let alice_sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
     let alice_pk = PublicKey::from(&alice_sk);
 
-    let bob_sk = SecretKey::try_from_bytes(&random_bits())?;
+    let bob_sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
     let bob_pk = PublicKey::from(&bob_sk);
 
     assert_eq!(alice_sk.exchange(&bob_pk), bob_sk.exchange(&alice_pk));
-    Ok(())
 }
 
 #[test]
-fn borsh_ed25519() -> anyhow::Result<()> {
-    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
-    let sk_bytes = borsh::to_vec(&sk)?;
+fn borsh_ed25519() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let sk_bytes = borsh::to_vec(&sk).unwrap();
     let pk = Ed25519PublicKey::from(&sk);
-    let pk_bytes = borsh::to_vec(&pk)?;
+    let pk_bytes = borsh::to_vec(&pk).unwrap();
 
     assert_eq!(pk_bytes.len(), pk.as_bytes().len() + 1);
     assert_eq!(pk_bytes[0], 0);
     assert_eq!(sk_bytes.len(), sk.as_bytes().len());
 
-    let sk = Ed25519SecretKey::try_from_slice(&sk_bytes)?;
-    let pk = Ed25519PublicKey::try_from_slice(&pk_bytes)?;
+    let sk = Ed25519SecretKey::try_from_slice(&sk_bytes).unwrap();
+    let pk = Ed25519PublicKey::try_from_slice(&pk_bytes).unwrap();
 
-    let signature_bytes = borsh::to_vec(&sk.sign(b"message", &pk))?;
+    let signature_bytes = borsh::to_vec(&sk.sign(b"message", &pk)).unwrap();
     pk.verify(
         b"message",
-        &Ed25519Signature::try_from_slice(&signature_bytes)?,
-    )?;
-
-    Ok(())
+        &Ed25519Signature::try_from_slice(&signature_bytes).unwrap(),
+    )
+    .unwrap();
 }
 
 #[test]
-fn borsh_x25519() -> anyhow::Result<()> {
-    let sk = SecretKey::try_from_bytes(&random_bits())?;
-    let sk_bytes = borsh::to_vec(&sk)?;
+fn borsh_x25519() {
+    let sk = SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let sk_bytes = borsh::to_vec(&sk).unwrap();
     let pk = PublicKey::from(&sk);
-    let pk_bytes = borsh::to_vec(&pk)?;
+    let pk_bytes = borsh::to_vec(&pk).unwrap();
+
+    // just try to serialize and deserialize. We doesn't support key-exchange for now
+    let _ = SecretKey::try_from_slice(&sk_bytes).unwrap();
+    let _ = PublicKey::try_from_slice(&pk_bytes).unwrap();
+}
+
+#[test]
+fn keypair_from_str() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&sk);
+
+    let mut sk_bytes = sk.to_bytes().to_vec();
+    sk_bytes.extend_from_slice(&pk.to_bytes());
+
+    let keypair_bs58 = format!("ed25519:{}", bs58::encode(sk_bytes).into_string());
+
+    let keypair = Keypair::from_str(&keypair_bs58).unwrap();
+
+    assert_eq!(keypair.secret_key().to_bytes(), sk.to_bytes());
+    assert_eq!(keypair.public_key().to_bytes(), pk.to_bytes());
+}
+
+#[test]
+fn keypair_to_string() {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let pk = Ed25519PublicKey::from(&sk);
+
+    let mut sk_bytes = sk.to_bytes().to_vec();
+    sk_bytes.extend_from_slice(&pk.to_bytes());
 
-    let _ = SecretKey::try_from_slice(&sk_bytes)?;
-    let _ = PublicKey::try_from_slice(&pk_bytes)?;
+    let keypair_bs58 = format!("ed25519:{}", bs58::encode(sk_bytes).into_string());
+    let keypair = Keypair::new(sk);
 
-    Ok(())
+    assert_eq!(keypair_bs58, keypair.to_string());
 }
 
 fn random_bits() -> [u8; ED25519_SECRET_KEY_LENGTH] {