ergotree-interpreter 0.28.0

ErgoTree interpreter
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

use std::convert::TryFrom;
use std::num::ParseIntError;
use std::str::FromStr;

use ergo_chain_types::Base16DecodedBytes;
use ergotree_ir::sigma_protocol::sigma_boolean::SigmaBoolean;
use serde::Deserialize;
use serde::Serialize;

use crate::sigma_protocol::challenge::Challenge;
use crate::sigma_protocol::prover::hint::RealSecretProof;
use crate::sigma_protocol::prover::hint::SimulatedSecretProof;
use crate::sigma_protocol::sig_serializer::parse_sig_compute_challenges;
use crate::sigma_protocol::sig_serializer::SigParsingError;
use crate::sigma_protocol::unproven_tree::NodePosition;

#[derive(Deserialize, Serialize)]
pub struct NodePositionJson(String);

impl From<NodePosition> for NodePositionJson {
    fn from(p: NodePosition) -> Self {
        NodePositionJson(
            p.positions
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join("-"),
        )
    }
}

impl TryFrom<NodePositionJson> for NodePosition {
    type Error = ParseIntError;

    fn try_from(pj: NodePositionJson) -> Result<Self, Self::Error> {
        Ok(NodePosition {
            positions: pj
                .0
                .split('-')
                .map(usize::from_str)
                .collect::<Result<Vec<usize>, _>>()?,
        })
    }
}

#[derive(Deserialize)]
pub struct RealSecretProofJson {
    #[serde(rename = "pubkey")]
    pub image: SigmaBoolean,
    #[serde(rename = "challenge")]
    pub challenge: Challenge,
    #[serde(rename = "proof")]
    pub unchecked_tree_bytes: Base16DecodedBytes,
    #[serde(rename = "position")]
    pub position: NodePosition,
}

impl TryFrom<RealSecretProofJson> for RealSecretProof {
    type Error = SigParsingError;

    fn try_from(rj: RealSecretProofJson) -> Result<Self, Self::Error> {
        let unchecked_tree =
            parse_sig_compute_challenges(&rj.image, rj.unchecked_tree_bytes.into())?;
        Ok(RealSecretProof {
            image: rj.image,
            challenge: rj.challenge,
            unchecked_tree,
            position: rj.position,
        })
    }
}

#[derive(Deserialize)]
pub struct SimulatedSecretProofJson {
    #[serde(rename = "pubkey")]
    pub image: SigmaBoolean,
    #[serde(rename = "challenge")]
    pub challenge: Challenge,
    #[serde(rename = "proof")]
    pub unchecked_tree_bytes: Base16DecodedBytes,
    #[serde(rename = "position")]
    pub position: NodePosition,
}

impl TryFrom<SimulatedSecretProofJson> for SimulatedSecretProof {
    type Error = SigParsingError;

    fn try_from(sj: SimulatedSecretProofJson) -> Result<Self, Self::Error> {
        let unchecked_tree =
            parse_sig_compute_challenges(&sj.image, sj.unchecked_tree_bytes.into())?;
        Ok(SimulatedSecretProof {
            image: sj.image,
            challenge: sj.challenge,
            unchecked_tree,
            position: sj.position,
        })
    }
}