Skip to main content

libkeri/cesr/
cigar.rs

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