libkeri 0.1.0

A Rust library for KERI (Key Event Receipt Infrastructure)
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::cesr::indexing::{idx_sig_dex, BaseIndexer, Indexer};
use crate::cesr::verfer::Verfer;
use crate::cesr::Parsable;
use crate::errors::MatterError;
use crate::Matter;
use std::any::Any;

///  Cigar is Matter subclass holding a nonindexed signature with verfer property.
///  From Matter .raw is signature and .code is signature cipher suite
///  Adds .verfer property to hold Verfer instance of associated verifier public key
///  Verfer's .raw as verifier key and .code is verifier cipher suite.

#[derive(Debug, Clone)]
pub struct Siger {
    base: BaseIndexer,
    verfer: Option<Verfer>,
}

impl Siger {
    pub fn new(
        raw: Option<&[u8]>,
        code: Option<&str>,
        index: Option<u32>,
        ondex: Option<u32>,
        verfer: Option<Verfer>,
    ) -> Result<Self, MatterError> {
        if !idx_sig_dex::TUPLE.contains(&(code.unwrap())) {
            return Err(MatterError::UnsupportedCodeError(String::from(
                code.unwrap(),
            )));
        }

        let base = BaseIndexer::new(raw, code, index, ondex)?;
        Ok(Siger { base, verfer })
    }

    pub fn from_raw(raw: Option<&[u8]>, verfer: Option<Verfer>) -> Result<Self, MatterError> {
        let base = BaseIndexer::from_raw(raw)?;

        Ok(Siger { base, verfer })
    }

    pub fn from_qb64(qb64: &str, verfer: Option<Verfer>) -> Result<Self, MatterError> {
        let base = BaseIndexer::from_qb64(qb64)?;
        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
        }

        Ok(Siger { base, verfer })
    }

    pub fn verfer(&self) -> Option<Verfer> {
        self.verfer.clone()
    }

    pub fn set_verfer(&mut self, verfer: Verfer) {
        self.verfer = Some(verfer);
    }
}

impl Parsable for Siger {
    fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
        let base = BaseIndexer::from_qb64b(data, strip)?;
        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
        }

        Ok(Siger { base, verfer: None })
    }

    fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
        let base = BaseIndexer::from_qb2(data, strip)?;
        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
        }

        Ok(Siger { base, verfer: None })
    }
}

impl Indexer for Siger {
    fn index(&self) -> u32 {
        self.base.index()
    }
    fn ondex(&self) -> Option<u32> {
        self.base.ondex()
    }
}

impl Matter for Siger {
    fn code(&self) -> &str {
        self.base.code()
    }

    fn raw(&self) -> &[u8] {
        self.base.raw()
    }

    fn qb64(&self) -> String {
        self.base.qb64()
    }

    fn qb64b(&self) -> Vec<u8> {
        self.base.qb64b()
    }

    fn qb2(&self) -> Vec<u8> {
        self.base.qb2()
    }

    fn soft(&self) -> &str {
        ""
    }

    fn full_size(&self) -> usize {
        self.base.full_size() as usize
    }

    fn size(&self) -> usize {
        0
    }

    fn is_transferable(&self) -> bool {
        false
    }

    fn is_digestive(&self) -> bool {
        false
    }

    fn is_prefixive(&self) -> bool {
        false
    }

    fn is_special(&self) -> bool {
        false
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}