Skip to main content

libkeri/cesr/indexing/
siger.rs

1use crate::cesr::indexing::{idx_sig_dex, BaseIndexer, Indexer};
2use crate::cesr::verfer::Verfer;
3use crate::cesr::Parsable;
4use crate::errors::MatterError;
5use crate::Matter;
6use std::any::Any;
7
8///  Cigar is Matter subclass holding a nonindexed signature with verfer property.
9///  From Matter .raw is signature and .code is signature cipher suite
10///  Adds .verfer property to hold Verfer instance of associated verifier public key
11///  Verfer's .raw as verifier key and .code is verifier cipher suite.
12
13#[derive(Debug, Clone)]
14pub struct Siger {
15    base: BaseIndexer,
16    verfer: Option<Verfer>,
17}
18
19impl Siger {
20    pub fn new(
21        raw: Option<&[u8]>,
22        code: Option<&str>,
23        index: Option<u32>,
24        ondex: Option<u32>,
25        verfer: Option<Verfer>,
26    ) -> Result<Self, MatterError> {
27        if !idx_sig_dex::TUPLE.contains(&(code.unwrap())) {
28            return Err(MatterError::UnsupportedCodeError(String::from(
29                code.unwrap(),
30            )));
31        }
32
33        let base = BaseIndexer::new(raw, code, index, ondex)?;
34        Ok(Siger { base, verfer })
35    }
36
37    pub fn from_raw(raw: Option<&[u8]>, verfer: Option<Verfer>) -> Result<Self, MatterError> {
38        let base = BaseIndexer::from_raw(raw)?;
39
40        Ok(Siger { base, verfer })
41    }
42
43    pub fn from_qb64(qb64: &str, verfer: Option<Verfer>) -> Result<Self, MatterError> {
44        let base = BaseIndexer::from_qb64(qb64)?;
45        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
46            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
47        }
48
49        Ok(Siger { base, verfer })
50    }
51
52    pub fn verfer(&self) -> Option<Verfer> {
53        self.verfer.clone()
54    }
55
56    pub fn set_verfer(&mut self, verfer: Verfer) {
57        self.verfer = Some(verfer);
58    }
59}
60
61impl Parsable for Siger {
62    fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
63        let base = BaseIndexer::from_qb64b(data, strip)?;
64        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
65            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
66        }
67
68        Ok(Siger { base, verfer: None })
69    }
70
71    fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
72        let base = BaseIndexer::from_qb2(data, strip)?;
73        if !idx_sig_dex::TUPLE.contains(&(base.code())) {
74            return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
75        }
76
77        Ok(Siger { base, verfer: None })
78    }
79}
80
81impl Indexer for Siger {
82    fn index(&self) -> u32 {
83        self.base.index()
84    }
85    fn ondex(&self) -> Option<u32> {
86        self.base.ondex()
87    }
88}
89
90impl Matter for Siger {
91    fn code(&self) -> &str {
92        self.base.code()
93    }
94
95    fn raw(&self) -> &[u8] {
96        self.base.raw()
97    }
98
99    fn qb64(&self) -> String {
100        self.base.qb64()
101    }
102
103    fn qb64b(&self) -> Vec<u8> {
104        self.base.qb64b()
105    }
106
107    fn qb2(&self) -> Vec<u8> {
108        self.base.qb2()
109    }
110
111    fn soft(&self) -> &str {
112        ""
113    }
114
115    fn full_size(&self) -> usize {
116        self.base.full_size() as usize
117    }
118
119    fn size(&self) -> usize {
120        0
121    }
122
123    fn is_transferable(&self) -> bool {
124        false
125    }
126
127    fn is_digestive(&self) -> bool {
128        false
129    }
130
131    fn is_prefixive(&self) -> bool {
132        false
133    }
134
135    fn is_special(&self) -> bool {
136        false
137    }
138
139    fn as_any(&self) -> &dyn Any {
140        self
141    }
142}