feeless 0.1.11

A Nano (cryptocurrency) node and utilities such as nano addresses, hashing blocks, signing, etc.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{expect_len, Address, Public, Signature};
use ed25519_dalek::ed25519::signature::Signature as InternalSignature;
use ed25519_dalek::ExpandedSecretKey;
use rand::RngCore;
use serde::{Deserialize, Serialize};
use std::convert::TryFrom;
use std::str::FromStr;
use crate::FeelessError;

/// 256 bit private key which can generate a public key.
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Private([u8; Private::LEN]);

impl Private {
    pub(crate) const LEN: usize = 32;

    pub fn random() -> Self {
        let mut private = Private::zero();
        rand::thread_rng().fill_bytes(&mut private.0);
        private
    }

    /// Generate the public key for this private key.
    ///
    /// If you wish to convert this private key to a Nano address you will need to take another
    /// step:
    /// ```
    /// use feeless::Private;
    /// use std::str::FromStr;
    ///
    /// # fn main() -> anyhow::Result<()> {
    /// let s = "0000000000000000000000000000000000000000000000000000000000000000";
    /// let address = Private::from_str(s)?.to_public()?.to_address();
    /// # Ok(())
    /// # }
    /// ```
    pub fn to_public(&self) -> Result<Public, FeelessError> {
        Ok(Public::from(self.internal_public()?))
    }

    pub(crate) fn internal_public(&self) -> Result<ed25519_dalek::PublicKey, FeelessError> {
        let dalek = self.to_ed25519_dalek()?;
        Ok(ed25519_dalek::PublicKey::from(&dalek))
    }

    pub fn to_address(&self) -> Result<Address, FeelessError> {
        Ok(self.to_public()?.to_address())
    }

    pub fn sign(&self, message: &[u8]) -> Result<Signature, FeelessError> {
        let dalek = self.to_ed25519_dalek()?;
        let expanded_secret = ExpandedSecretKey::from(&dalek);
        let internal_signed = expanded_secret.sign(message, &self.internal_public()?);
        Signature::try_from(internal_signed.as_bytes())
    }

    // Not public because we don't want users to accidentally generate this key.
    fn zero() -> Self {
        Self([0u8; 32])
    }

    fn to_ed25519_dalek(&self) -> Result<ed25519_dalek::SecretKey, FeelessError> {
        Ok(ed25519_dalek::SecretKey::from_bytes(&self.0)
            .map_err(|e| FeelessError::SignatureError {
                msg: String::from("Converting to SecretKey"),
                source: e,
            })?
        )
    }
}

impl TryFrom<&[u8]> for Private {
    type Error = FeelessError;

    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
        expect_len(bytes.len(), Private::LEN, "Private key")?;
        let x = <[u8; Self::LEN]>::try_from(bytes)?;
        Ok(Self(x))
    }
}

impl std::fmt::UpperHex for Private {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        crate::encoding::hex_formatter(f, &self.0)
    }
}

impl std::fmt::Display for Private {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:X}", &self)
    }
}

impl FromStr for Private {
    type Err = FeelessError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        expect_len(s.len(), Self::LEN * 2, "hex private key")?;
        let vec = hex::decode(s.as_bytes())
            .map_err(|e| FeelessError::FromHexError {
                msg: String::from("Decoding hex public key"),
                source: e,
            })?;
        let bytes = vec.as_slice();
        Self::try_from(bytes)
    }
}

#[cfg(test)]
mod tests {
    use crate::Seed;

    #[tokio::test]
    async fn signing() {
        let message = [1, 2, 3, 4, 5];
        let private = Seed::random().derive(0);
        let public = private.to_public().unwrap();
        let signature = private.sign(&message).unwrap();
        assert!(public.verify(&message, &signature).is_ok());
    }
}