Merge pull request #27 from Relayz-io/silvestr/16-move-cryptographic-code-from-near-client

Copy existed crypto.rs to common-api crate

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["wasm-client", "near-client"]
+members = ["wasm-client", "near-client", "common-api"]
 
 [profile.release]
 codegen-units = 1

common-api/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "common-api"
+version = "0.1.0"
+edition = "2021"
+authors = ["silvestr@relayz.io"]
+description = """
+This crate is used between many other crates to provide the same
+API for signing data and shared types. Please note that all data
+structures should be serializable with "serde" and "borsh"
+"""
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+base64 = "0.13"
+bs58 = "0.4"
+borsh = "0.9"
+ed25519-dalek = "1"
+itertools = "0.10"
+serde = { version = "1", default-features = false, features = ["derive"] }
+serde_json = { version = "1", default-features = false }
+thiserror = "1"

common-api/src/crypto/ed25519.rs

@@ -0,0 +1,321 @@
+//! ### Sign with ed25519 elliptic curve signing algorithm
+//! ---
+//! Used Dalek cryptography, and implemented [`Borsh`](https://borsh.io/) serialization for them
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use ed25519_dalek::{
+    ExpandedSecretKey, PublicKey, SecretKey, Signature, Verifier, PUBLIC_KEY_LENGTH,
+    SECRET_KEY_LENGTH, SIGNATURE_LENGTH,
+};
+use itertools::Itertools;
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt::{Debug, Display},
+    hash::{Hash, Hasher},
+    io::{Error as IoError, ErrorKind},
+    str::FromStr,
+};
+
+use super::Error;
+
+type Result<T> = std::result::Result<T, Error>;
+
+pub trait Key<T, const KEY_LENGTH: usize> {
+    fn from_string(key: &str) -> Result<T> {
+        let bs58_encoded = split_encoded_str(key)?;
+        let bytes = bs58::decode(bs58_encoded)
+            .into_vec()
+            .map_err(|err| Error::from_string::<T>(bs58_encoded.to_owned(), err.to_string()))?;
+        Self::from_bytes(&bytes)
+    }
+
+    fn to_string(&self) -> String {
+        format!("ed25519:{}", bs58::encode(self.to_bytes()).into_string())
+    }
+
+    fn from_bytes(bytes: &[u8]) -> Result<T>;
+    fn to_bytes(&self) -> [u8; KEY_LENGTH];
+}
+
+#[derive(Copy, Clone, Default, Eq, PartialEq)]
+pub struct ED25519PublicKey(PublicKey);
+
+impl ED25519PublicKey {
+    pub fn verify(&self, data: &[u8], signature: &ED25519Signature) -> Result<()> {
+        self.0
+            .verify(data, &signature.0)
+            .map_err(|_| Error::Verification(*signature))
+    }
+
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
+        self.0.as_bytes()
+    }
+}
+
+impl Key<ED25519PublicKey, PUBLIC_KEY_LENGTH> for ED25519PublicKey {
+    fn from_bytes(bytes: &[u8]) -> Result<ED25519PublicKey> {
+        PublicKey::from_bytes(bytes)
+            .map(Self)
+            .map_err(|err| Error::from_bytes::<ED25519PublicKey>(bytes, err.to_string()))
+    }
+
+    #[inline]
+    fn to_bytes(&self) -> [u8; PUBLIC_KEY_LENGTH] {
+        self.0.to_bytes()
+    }
+}
+
+impl BorshDeserialize for ED25519PublicKey {
+    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
+        if buf.len() != PUBLIC_KEY_LENGTH {
+            return Err(IoError::new(ErrorKind::InvalidData, format!("Couldn't deserialize a ED25519PublicKey, input buffer {} is greater or less than required", buf.len())));
+        }
+
+        // The first byte is a key type, let's skip it because currently is used ed25519 only
+        let temp_buf = std::mem::take(buf);
+        Ok(Self(PublicKey::from_bytes(&temp_buf[1..]).map_err(
+            |err| {
+                IoError::new(
+                    ErrorKind::InvalidData,
+                    format!("Couldn't deserialize a ED25519PublicKey because of: {err}"),
+                )
+            },
+        )?))
+    }
+}
+
+impl BorshSerialize for ED25519PublicKey {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        BorshSerialize::serialize(&0_u8, writer)?;
+        writer.write_all(self.0.as_bytes())
+    }
+}
+
+impl From<&ED25519SecretKey> for ED25519PublicKey {
+    fn from(sk: &ED25519SecretKey) -> Self {
+        Self(PublicKey::from(&sk.0))
+    }
+}
+
+// This `Hash` implementation is safe since it retains the property
+// `k1 == k2 ⇒ hash(k1) == hash(k2)`.
+#[allow(clippy::derive_hash_xor_eq)]
+impl Hash for ED25519PublicKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u8(0u8);
+        state.write(self.0.as_bytes());
+    }
+}
+
+impl Debug for ED25519PublicKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", self)
+    }
+}
+
+impl Display for ED25519PublicKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", Key::to_string(self))
+    }
+}
+
+pub struct ED25519SecretKey(SecretKey);
+
+impl ED25519SecretKey {
+    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))
+    }
+
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
+        self.0.as_bytes()
+    }
+
+    pub fn from_encoded_expanded(key: &str) -> Result<Self> {
+        let bs58_encoded = split_encoded_str(key)?;
+        let expanded_key_bytes = bs58::decode(bs58_encoded).into_vec().map_err(|err| {
+            Error::from_string::<ED25519SecretKey>(bs58_encoded.to_owned(), err.to_string())
+        })?;
+        Self::from_bytes(&expanded_key_bytes[..32])
+    }
+}
+
+impl Key<ED25519SecretKey, SECRET_KEY_LENGTH> for ED25519SecretKey {
+    fn from_bytes(bytes: &[u8]) -> Result<ED25519SecretKey> {
+        SecretKey::from_bytes(bytes)
+            .map(Self)
+            .map_err(|err| Error::from_bytes::<ED25519SecretKey>(bytes, err.to_string()))
+    }
+
+    #[inline]
+    fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
+        self.0.to_bytes()
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct ED25519Signature(Signature);
+
+impl Key<ED25519Signature, SIGNATURE_LENGTH> for ED25519Signature {
+    fn from_bytes(bytes: &[u8]) -> Result<ED25519Signature> {
+        Signature::from_bytes(bytes)
+            .map(Self)
+            .map_err(|err| Error::from_bytes::<ED25519Signature>(bytes, err.to_string()))
+    }
+
+    fn to_bytes(&self) -> [u8; SIGNATURE_LENGTH] {
+        self.0.to_bytes()
+    }
+}
+
+impl BorshSerialize for ED25519Signature {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        BorshSerialize::serialize(&0_u8, writer)?;
+        writer.write_all(&self.to_bytes())
+    }
+}
+
+impl BorshDeserialize for ED25519Signature {
+    fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
+        if buf.len() != SIGNATURE_LENGTH + 1 {
+            return Err(IoError::new(ErrorKind::InvalidData, format!("Couldn't deserialize a ED25519Signature, input buffer {} is greater or less than required", buf.len())));
+        }
+
+        // The first byte is a key type, let's skip it because currently is used ed25519 only
+        let temp_buf = std::mem::take(buf);
+        Self::from_bytes(&temp_buf[1..]).map_err(|err| {
+            IoError::new(
+                ErrorKind::InvalidData,
+                format!("Couldn't deserialize a ED25519Signature because of: {err}"),
+            )
+        })
+    }
+}
+
+#[allow(clippy::derive_hash_xor_eq)]
+impl Hash for ED25519Signature {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.to_bytes().hash(state);
+    }
+}
+
+impl Debug for ED25519Signature {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", self)
+    }
+}
+
+impl Display for ED25519Signature {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", Key::to_string(self))
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Keypair {
+    pub public_key: ED25519PublicKey,
+    pub secret_key: ED25519SecretKey,
+}
+
+impl Keypair {
+    pub fn new(secret_key: ED25519SecretKey) -> Self {
+        let public_key = ED25519PublicKey::from(&secret_key);
+        Self {
+            public_key,
+            secret_key,
+        }
+    }
+
+    pub fn from_encoded(encoded: &str) -> Result<Self> {
+        let secret_key = ED25519SecretKey::from_encoded_expanded(encoded)?;
+        let public_key = ED25519PublicKey::from(&secret_key);
+        Ok(Self {
+            public_key,
+            secret_key,
+        })
+    }
+
+    pub fn sign(&self, data: &[u8]) -> ED25519Signature {
+        self.secret_key.sign(data, &self.public_key)
+    }
+
+    pub fn verify(&self, data: &[u8], signature: &ED25519Signature) -> Result<()> {
+        self.public_key.verify(data, signature)
+    }
+}
+
+macro_rules! util_impl {
+    ($key_type: ty) => {
+        impl From<$key_type> for String {
+            fn from(key: $key_type) -> Self {
+                Key::to_string(&key)
+            }
+        }
+
+        impl FromStr for $key_type {
+            type Err = Error;
+
+            fn from_str(s: &str) -> Result<Self> {
+                Self::from_string(s)
+            }
+        }
+    };
+}
+
+macro_rules! serde_impl {
+    ($key_type: ty) => {
+        impl serde::Serialize for $key_type {
+            fn serialize<S>(
+                &self,
+                serializer: S,
+            ) -> std::result::Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
+            where
+                S: serde::Serializer,
+            {
+                serializer.serialize_str(&Key::to_string(self))
+            }
+        }
+
+        impl<'de> serde::Deserialize<'de> for $key_type {
+            fn deserialize<D>(
+                deserializer: D,
+            ) -> std::result::Result<Self, <D as serde::Deserializer<'de>>::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                let s = <String as serde::Deserialize>::deserialize(deserializer)?;
+                s.parse().map_err(|err| {
+                    serde::de::Error::custom(format!("Deserialization failed: `{}`", err))
+                })
+            }
+        }
+    };
+}
+
+fn split_encoded_str(encoded: &str) -> Result<&str> {
+    match encoded.split(':').next_tuple() {
+        Some((key_type, bs58_encoded)) => {
+            if key_type != "ed25519" {
+                return Err(Error::UnknownKeyType(key_type.to_owned()));
+            }
+            Ok(bs58_encoded)
+        }
+        _ => Err(Error::UnknownKeyType(encoded.to_owned())),
+    }
+}
+
+serde_impl!(ED25519PublicKey);
+util_impl!(ED25519PublicKey);
+serde_impl!(ED25519SecretKey);
+util_impl!(ED25519SecretKey);
+serde_impl!(ED25519Signature);
+util_impl!(ED25519Signature);
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test() {}
+}

common-api/src/crypto/mod.rs

@@ -0,0 +1,51 @@
+pub mod ed25519;
+
+use ed25519::ED25519Signature;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(
+        "Couldn't convert key from bytes `{key_string}` into `{key_name}`, because of: {cause}"
+    )]
+    ConvertFromBytes {
+        key_name: &'static str,
+        key_string: String,
+        cause: String,
+    },
+    #[error(
+        "Couldn't convert key from string `{key_string}` into `{key_name}`, because of: {cause}"
+    )]
+    ConvertFromString {
+        key_name: &'static str,
+        key_string: String,
+        cause: String,
+    },
+    #[error("The key format `{0}` seems different from ed25519 format")]
+    UnknownKeyType(String),
+    #[error("Signature `{0}` verification failed")]
+    Verification(ED25519Signature),
+}
+
+impl Error {
+    pub(crate) fn from_string<T>(key_string: String, cause: String) -> Self {
+        Self::ConvertFromString {
+            key_name: std::any::type_name::<T>()
+                .rsplit("::")
+                .next()
+                .unwrap_or_default(),
+            key_string,
+            cause,
+        }
+    }
+
+    pub(crate) fn from_bytes<T>(data: &[u8], cause: String) -> Self {
+        Self::ConvertFromBytes {
+            key_name: std::any::type_name::<T>()
+                .rsplit("::")
+                .next()
+                .unwrap_or_default(),
+            key_string: bs58::encode(data).into_string(),
+            cause,
+        }
+    }
+}

common-api/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod crypto;
+
+#[cfg(test)]
+mod tests {}