kimchi/circuits/
scalars.rs

1//! This module implements Plonk prover polynomial evaluations primitive.
2
3use ark_ff::Field;
4use mina_poseidon::sponge::ScalarChallenge;
5
6#[derive(Clone, Debug)]
7pub struct RandomOracles<F: Field> {
8    pub joint_combiner: Option<(ScalarChallenge<F>, F)>,
9    pub beta: F,
10    pub gamma: F,
11    pub alpha_chal: ScalarChallenge<F>,
12    pub alpha: F,
13    pub zeta: F,
14    pub v: F,
15    pub u: F,
16    pub zeta_chal: ScalarChallenge<F>,
17    pub v_chal: ScalarChallenge<F>,
18    pub u_chal: ScalarChallenge<F>,
19}
20
21impl<F: Field> Default for RandomOracles<F> {
22    fn default() -> Self {
23        let c = ScalarChallenge(F::zero());
24        Self {
25            beta: F::zero(),
26            gamma: F::zero(),
27            alpha: F::zero(),
28            zeta: F::zero(),
29            v: F::zero(),
30            u: F::zero(),
31            alpha_chal: c.clone(),
32            zeta_chal: c.clone(),
33            v_chal: c.clone(),
34            u_chal: c,
35            joint_combiner: None,
36        }
37    }
38}
39
40//
41// OCaml types
42//
43
44#[cfg(feature = "ocaml_types")]
45pub mod caml {
46    use super::*;
47    use mina_poseidon::sponge::caml::CamlScalarChallenge;
48
49    //
50    // RandomOracles<F> <-> CamlRandomOracles<CamlF>
51    //
52
53    #[derive(ocaml::IntoValue, ocaml::FromValue, ocaml_gen::Struct)]
54    pub struct CamlRandomOracles<CamlF> {
55        pub joint_combiner: Option<(CamlScalarChallenge<CamlF>, CamlF)>,
56        pub beta: CamlF,
57        pub gamma: CamlF,
58        pub alpha_chal: CamlScalarChallenge<CamlF>,
59        pub alpha: CamlF,
60        pub zeta: CamlF,
61        pub v: CamlF,
62        pub u: CamlF,
63        pub zeta_chal: CamlScalarChallenge<CamlF>,
64        pub v_chal: CamlScalarChallenge<CamlF>,
65        pub u_chal: CamlScalarChallenge<CamlF>,
66    }
67
68    impl<F, CamlF> From<RandomOracles<F>> for CamlRandomOracles<CamlF>
69    where
70        F: Field,
71        CamlF: From<F>,
72    {
73        fn from(ro: RandomOracles<F>) -> Self {
74            Self {
75                joint_combiner: ro.joint_combiner.map(|(l, r)| (l.into(), r.into())),
76                beta: ro.beta.into(),
77                gamma: ro.gamma.into(),
78                alpha_chal: ro.alpha_chal.into(),
79                alpha: ro.alpha.into(),
80                zeta: ro.zeta.into(),
81                v: ro.v.into(),
82                u: ro.u.into(),
83                zeta_chal: ro.zeta_chal.into(),
84                v_chal: ro.v_chal.into(),
85                u_chal: ro.u_chal.into(),
86            }
87        }
88    }
89
90    impl<F, CamlF> From<CamlRandomOracles<CamlF>> for RandomOracles<F>
91    where
92        CamlF: Into<F>,
93        F: Field,
94    {
95        fn from(caml_ro: CamlRandomOracles<CamlF>) -> Self {
96            RandomOracles {
97                joint_combiner: caml_ro.joint_combiner.map(|(l, r)| (l.into(), r.into())),
98                beta: caml_ro.beta.into(),
99                gamma: caml_ro.gamma.into(),
100                alpha_chal: caml_ro.alpha_chal.into(),
101                alpha: caml_ro.alpha.into(),
102                zeta: caml_ro.zeta.into(),
103                v: caml_ro.v.into(),
104                u: caml_ro.u.into(),
105                zeta_chal: caml_ro.zeta_chal.into(),
106                v_chal: caml_ro.v_chal.into(),
107                u_chal: caml_ro.u_chal.into(),
108            }
109        }
110    }
111}
kimchi/circuits/scalars.rs

kimchi/circuits/
scalars.rs
