ergotree_ir/serialization/
sigmaboolean.rs

1use super::SigmaSerializeResult;
2use super::{op_code::OpCode, sigma_byte_writer::SigmaByteWrite};
3use crate::has_opcode::{HasOpCode, HasStaticOpCode};
4use crate::serialization::{
5    sigma_byte_reader::SigmaByteRead, SigmaParsingError, SigmaSerializable,
6};
7use crate::sigma_protocol::sigma_boolean::{
8    ProveDhTuple, ProveDlog, SigmaBoolean, SigmaConjecture, SigmaProofOfKnowledgeTree,
9};
10use ergo_chain_types::EcPoint;
11
12use crate::sigma_protocol::sigma_boolean::cand::Cand;
13use crate::sigma_protocol::sigma_boolean::cor::Cor;
14use crate::sigma_protocol::sigma_boolean::cthreshold::Cthreshold;
15
16impl SigmaSerializable for SigmaBoolean {
17    fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> SigmaSerializeResult {
18        self.op_code().sigma_serialize(w)?;
19        match self {
20            SigmaBoolean::ProofOfKnowledge(proof) => match proof {
21                SigmaProofOfKnowledgeTree::ProveDhTuple(v) => v.sigma_serialize(w),
22                SigmaProofOfKnowledgeTree::ProveDlog(v) => v.sigma_serialize(w),
23            },
24            SigmaBoolean::SigmaConjecture(conj) => match conj {
25                SigmaConjecture::Cand(c) => c.sigma_serialize(w),
26                SigmaConjecture::Cor(c) => c.sigma_serialize(w),
27                SigmaConjecture::Cthreshold(c) => c.sigma_serialize(w),
28            },
29            SigmaBoolean::TrivialProp(_) => Ok(()), // besides opCode no additional bytes
30        }
31    }
32
33    fn sigma_parse<R: SigmaByteRead>(r: &mut R) -> Result<Self, SigmaParsingError> {
34        let op_code = OpCode::sigma_parse(r)?;
35        match op_code {
36            ProveDlog::OP_CODE => Ok(SigmaBoolean::ProofOfKnowledge(
37                SigmaProofOfKnowledgeTree::ProveDlog(ProveDlog::sigma_parse(r)?),
38            )),
39            ProveDhTuple::OP_CODE => Ok(SigmaBoolean::ProofOfKnowledge(
40                SigmaProofOfKnowledgeTree::ProveDhTuple(ProveDhTuple::sigma_parse(r)?),
41            )),
42            Cand::OP_CODE => {
43                let c = Cand::sigma_parse(r)?;
44                Ok(SigmaBoolean::SigmaConjecture(SigmaConjecture::Cand(c)))
45            }
46            Cor::OP_CODE => {
47                let c = Cor::sigma_parse(r)?;
48                Ok(SigmaBoolean::SigmaConjecture(SigmaConjecture::Cor(c)))
49            }
50            Cthreshold::OP_CODE => {
51                let c = Cthreshold::sigma_parse(r)?;
52                Ok(SigmaBoolean::SigmaConjecture(SigmaConjecture::Cthreshold(
53                    c,
54                )))
55            }
56            OpCode::TRIVIAL_PROP_TRUE => Ok(SigmaBoolean::TrivialProp(true)),
57            OpCode::TRIVIAL_PROP_FALSE => Ok(SigmaBoolean::TrivialProp(false)),
58            _ => Err(SigmaParsingError::Misc(format!(
59                "unexpected op code in SigmaBoolean parsing: {:?}",
60                op_code
61            ))),
62        }
63    }
64}
65
66impl SigmaSerializable for ProveDlog {
67    fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> SigmaSerializeResult {
68        self.h.sigma_serialize(w)
69    }
70
71    fn sigma_parse<R: SigmaByteRead>(r: &mut R) -> Result<Self, SigmaParsingError> {
72        let p = EcPoint::sigma_parse(r)?;
73        Ok(ProveDlog::new(p))
74    }
75}
76
77impl SigmaSerializable for ProveDhTuple {
78    fn sigma_serialize<W: SigmaByteWrite>(&self, w: &mut W) -> SigmaSerializeResult {
79        self.g.sigma_serialize(w)?;
80        self.h.sigma_serialize(w)?;
81        self.u.sigma_serialize(w)?;
82        self.v.sigma_serialize(w)
83    }
84
85    #[allow(clippy::many_single_char_names)]
86    fn sigma_parse<R: SigmaByteRead>(r: &mut R) -> Result<Self, SigmaParsingError> {
87        let g = EcPoint::sigma_parse(r)?;
88        let h = EcPoint::sigma_parse(r)?;
89        let u = EcPoint::sigma_parse(r)?;
90        let v = EcPoint::sigma_parse(r)?;
91        Ok(ProveDhTuple::new(g, h, u, v))
92    }
93}
ergotree_ir/serialization/sigmaboolean.rs

ergotree_ir/serialization/
sigmaboolean.rs
