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
105
106
107
108
109
110
111
112
113
114
115
116

use proofman_fields::PrimeField64;
use proofman_starks_lib_c::{
    get_n_constraints_c, get_constraints_lines_sizes_c, get_constraints_lines_c, get_n_global_constraints_c,
    get_global_constraints_lines_sizes_c, get_global_constraints_lines_c,
};

use crate::{ProofmanResult, SetupCtx};

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct ConstraintRowInfo {
    pub row: u64,
    pub dim: u64,
    pub value: [u64; 3usize],
}

#[derive(Default, Debug, Clone)]
#[repr(C)]
pub struct ConstraintInfo {
    pub id: u64,
    pub stage: u64,
    pub im_pol: bool,
    pub n_rows: u64,
    pub skip: bool,
    pub n_print_constraints: u64,
    pub rows: Vec<ConstraintRowInfo>,
}

#[derive(Debug, Clone)]
#[repr(C)]
pub struct ConstraintInfoC {
    pub id: u64,
    pub stage: u64,
    pub im_pol: bool,
    pub n_rows: u64,
    pub skip: bool,
    pub n_print_constraints: u64,
    pub rows: *mut ConstraintRowInfo,
}

impl ConstraintInfo {
    pub fn new(n_print_constraints: u64) -> Self {
        Self {
            rows: vec![ConstraintRowInfo::default(); n_print_constraints as usize],
            n_print_constraints,
            ..Default::default()
        }
    }
}

#[derive(Default, Debug, Clone, Copy)]
#[repr(C)]
pub struct GlobalConstraintInfo {
    pub id: u64,
    pub dim: u64,
    pub valid: bool,
    pub skip: bool,
    pub value: [u64; 3usize],
}

pub fn get_constraints_lines_str<F: PrimeField64>(
    sctx: &SetupCtx<F>,
    airgroup_id: usize,
    air_id: usize,
) -> ProofmanResult<Vec<String>> {
    let setup = sctx.get_setup(airgroup_id, air_id)?;

    let p_setup = (&setup.p_setup).into();
    let n_constraints = get_n_constraints_c(p_setup);

    let mut constraints_sizes = vec![0u64; n_constraints as usize];

    get_constraints_lines_sizes_c(p_setup, constraints_sizes.as_mut_ptr());

    let mut constraints_lines = vec![Vec::new(); n_constraints as usize];
    for i in 0..n_constraints as usize {
        constraints_lines[i] = vec![0u8; constraints_sizes[i] as usize];
    }

    get_constraints_lines_c(
        p_setup,
        constraints_lines.iter_mut().map(|v| v.as_mut_ptr()).collect::<Vec<_>>().as_mut_ptr(),
    );

    let mut constraints_lines_str = Vec::new();
    for constraint_line in constraints_lines {
        constraints_lines_str.push(std::str::from_utf8(&constraint_line).unwrap().to_string());
    }

    Ok(constraints_lines_str)
}

pub fn get_global_constraints_lines_str<F: PrimeField64>(sctx: &SetupCtx<F>) -> Vec<String> {
    let n_global_constraints = get_n_global_constraints_c(sctx.get_global_bin());

    let mut global_constraints_sizes = vec![0u64; n_global_constraints as usize];

    get_global_constraints_lines_sizes_c(sctx.get_global_bin(), global_constraints_sizes.as_mut_ptr());

    let mut global_constraints_lines = vec![Vec::new(); n_global_constraints as usize];
    for i in 0..n_global_constraints as usize {
        global_constraints_lines[i] = vec![0u8; global_constraints_sizes[i] as usize];
    }

    get_global_constraints_lines_c(
        sctx.get_global_bin(),
        global_constraints_lines.iter_mut().map(|v| v.as_mut_ptr()).collect::<Vec<_>>().as_mut_ptr(),
    );

    let mut global_constraints_lines_str = Vec::new();
    for global_constraint_line in global_constraints_lines {
        global_constraints_lines_str.push(std::str::from_utf8(&global_constraint_line).unwrap().to_string());
    }

    global_constraints_lines_str
}