cesrox 2.0.0-beta.5

Implementation of Composable Event Streaming Representation (CESR)
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

pub mod codes;
pub mod parsers;
use chrono::{DateTime, FixedOffset};

use crate::{conversion::from_bytes_to_text, primitives::codes::rand_128::Rand128Code};

use self::codes::{
    attached_signature_code::AttachedSignatureCode, basic::Basic, self_addressing::SelfAddressing,
    self_signing::SelfSigning, PrimitiveCode,
};

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum IdentifierCode {
    Basic(Basic),
    SelfAddressing(SelfAddressing),
}

impl From<IdentifierCode> for PrimitiveCode {
    fn from(code: IdentifierCode) -> Self {
        match code {
            IdentifierCode::Basic(b) => PrimitiveCode::Basic(b),
            IdentifierCode::SelfAddressing(sa) => PrimitiveCode::SelfAddressing(sa),
        }
    }
}

pub type Identifier = (IdentifierCode, Vec<u8>);
pub type PublicKey = (Basic, Vec<u8>);
pub type Digest = (SelfAddressing, Vec<u8>);
pub type Signature = (SelfSigning, Vec<u8>);
pub type IndexedSignature = (AttachedSignatureCode, Vec<u8>);
pub type Timestamp = DateTime<FixedOffset>;
pub type AnchoringEventSeal = (Identifier, u64, Digest);
pub type SaltyNounce = (Rand128Code, Vec<u8>);

pub trait CesrPrimitive {
    fn derivative(&self) -> Vec<u8>;
    fn derivation_code(&self) -> PrimitiveCode;
    fn to_str(&self) -> String {
        match self.derivative().len() {
            // empty data cannot be prefixed!
            0 => "".to_string(),
            _ => {
                let dc = self.derivation_code().to_str();
                let lead_bytes = if !dc.len().is_multiple_of(4) {
                    dc.len() % 4
                } else {
                    0
                };
                // replace lead bytes with code
                let derivative_text =
                    from_bytes_to_text(&self.derivative())[lead_bytes..].to_string();
                [dc, derivative_text].join("")
            }
        }
    }
}

impl CesrPrimitive for Digest {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        PrimitiveCode::SelfAddressing(self.0.clone())
    }
}

impl CesrPrimitive for Signature {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        PrimitiveCode::SelfSigning(self.0)
    }
}

impl CesrPrimitive for IndexedSignature {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        PrimitiveCode::IndexedSignature(self.0)
    }
}

impl CesrPrimitive for PublicKey {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        PrimitiveCode::Basic(self.0)
    }
}

impl CesrPrimitive for Identifier {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        match &self.0 {
            IdentifierCode::Basic(b) => PrimitiveCode::Basic(*b),
            IdentifierCode::SelfAddressing(sa) => PrimitiveCode::SelfAddressing(sa.clone()),
        }
    }
}

impl CesrPrimitive for SaltyNounce {
    fn derivative(&self) -> Vec<u8> {
        self.1.clone()
    }

    fn derivation_code(&self) -> PrimitiveCode {
        PrimitiveCode::Random(self.0.clone())
    }
}