proofman-common 1.1.0-alpha

Shared proof/setup contexts, traces, and STARK metadata types for the PIL2 proofman framework
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

use std::str::FromStr;
use proofman_fields::PrimeField64;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum ProofType {
    #[default]
    Basic = 0,
    Compressor,
    Recursive1,
    Recursive2,
    VadcopFinal,
    VadcopFinalCompressed,
    RecursiveF,
    RecurserAggregator,
}

impl ProofType {
    pub fn as_usize(&self) -> usize {
        match self {
            ProofType::Basic => 0,
            ProofType::Compressor => 1,
            ProofType::Recursive1 => 2,
            ProofType::Recursive2 => 3,
            ProofType::VadcopFinal => 4,
            ProofType::VadcopFinalCompressed => 5,
            ProofType::RecursiveF => 6,
            ProofType::RecurserAggregator => 7,
        }
    }
}

impl From<ProofType> for &'static str {
    fn from(p: ProofType) -> Self {
        match p {
            ProofType::Basic => "basic",
            ProofType::Compressor => "compressor",
            ProofType::Recursive1 => "recursive1",
            ProofType::Recursive2 => "recursive2",
            ProofType::VadcopFinal => "vadcop_final",
            ProofType::VadcopFinalCompressed => "vadcop_final_compressed",
            ProofType::RecursiveF => "recursive_f",
            ProofType::RecurserAggregator => "recurser_aggregator",
        }
    }
}

impl FromStr for ProofType {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "basic" => Ok(ProofType::Basic),
            "compressor" => Ok(ProofType::Compressor),
            "recursive1" => Ok(ProofType::Recursive1),
            "recursive2" => Ok(ProofType::Recursive2),
            "vadcop_final" => Ok(ProofType::VadcopFinal),
            "vadcop_final_compressed" => Ok(ProofType::VadcopFinalCompressed),
            "recursive_f" => Ok(ProofType::RecursiveF),
            "recurser_aggregator" => Ok(ProofType::RecurserAggregator),
            _ => Err(()),
        }
    }
}

#[derive(Debug, Default, Clone)]
pub struct Proof<F: PrimeField64> {
    pub proof_type: ProofType,
    pub airgroup_id: usize,
    pub air_id: usize,
    pub global_idx: Option<usize>,
    pub proof: Vec<u64>,
    pub circom_witness: Vec<F>,
    pub n_cols: usize,
}

impl<F: PrimeField64> Proof<F> {
    pub fn new(
        proof_type: ProofType,
        airgroup_id: usize,
        air_id: usize,
        global_idx: Option<usize>,
        proof: Vec<u64>,
    ) -> Self {
        Self { proof_type, global_idx, airgroup_id, air_id, proof, circom_witness: Vec::new(), n_cols: 0 }
    }

    pub fn new_witness(
        proof_type: ProofType,
        airgroup_id: usize,
        air_id: usize,
        global_idx: Option<usize>,
        circom_witness: Vec<F>,
        n_cols: usize,
    ) -> Self {
        Self { proof_type, global_idx, airgroup_id, air_id, circom_witness, proof: Vec::new(), n_cols }
    }
}

#[derive(Debug, Clone, Copy)]
pub struct ProverInfo {
    pub airgroup_id: usize,
    pub air_id: usize,
    pub air_instance_id: usize,
}