blockify 0.0.9

A general purpose blockchain library
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

#![cfg(test)]

use blockify::{record::Record, data::Metadata};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Detail<T> {
    val: T,
}

impl<T: Serialize> Record for Detail<T> {
    fn sign(
        &self,
        key: &blockify::AuthKeyPair,
    ) -> Result<blockify::DigitalSignature, blockify::SigningError> {
        let msg = blockify::serialize(self)?;
        let signature = blockify::sign_msg(&msg, key)?;
        Ok(signature)
    }

    fn verify(
        &self,
        signature: &blockify::DigitalSignature,
        key: &blockify::PublicKey,
    ) -> Result<(), blockify::VerificationError> {
        let msg = blockify::serialize(self).map_err(|_| blockify::VerificationError::SerdeError)?;
        key.verify(&msg, signature)
    }

    fn record(
        self,
        keypair: blockify::AuthKeyPair,
        metadata: blockify::data::Metadata,
    ) -> Result<blockify::record::SignedRecord<Self>, blockify::SigningError> {
        let signature = self.sign(&keypair)?;
        let hash = self.hash();
        Ok(blockify::record::SignedRecord::new(
            self,
            signature,
            keypair.into_public_key(),
            hash,
            metadata,
        ))
    }

    fn hash(&self) -> blockify::Hash {
        blockify::hash(self)
    }
}

#[test]
fn test_derive() {
    let keypair = blockify::generate_ed25519_key_pair();
    let value = Detail {
        val: String::from("Hello, World!"),
    };
    let hash = value.hash();
    let signature = value.sign(&keypair).unwrap();
    let record = value.record(keypair, Metadata::empty()).unwrap();

    assert_eq!(&hash, record.hash());
    assert_eq!(&signature, record.signature());
    assert_eq!(&Metadata::empty(), record.metadata());
    assert!(record.verify().is_ok());
}

#[test]
fn test_record() {
    let keypair = blockify::generate_ed25519_key_pair();
    let value = Detail {
        val: String::from("Hello, World!"),
    };
    let hash = value.hash();
    let signature = value.sign(&keypair).unwrap();
    let record = value.record(keypair, Metadata::empty()).unwrap();

    assert_eq!(&hash, record.hash());
    assert_eq!(&signature, record.signature());
    assert_eq!(&Metadata::empty(), record.metadata());
    assert!(record.verify().is_ok());
}