zkevm_circuits 0.153.9

ZKsync Era circuits for EraVM
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

use super::*;
use crate::base_structures::recursion_query::*;
use crate::base_structures::vm_state::*;
use boojum::cs::implementations::proof::Proof;
use boojum::cs::implementations::verifier::VerificationKey;
use boojum::cs::{traits::cs::ConstraintSystem, Variable};
use boojum::field::SmallField;
use boojum::gadgets::num::Num;
use boojum::gadgets::queue::full_state_queue::FullStateCircuitQueueRawWitness;
use boojum::gadgets::traits::auxiliary::PrettyComparison;
use boojum::gadgets::{
    boolean::Boolean,
    traits::{
        allocatable::*, encodable::CircuitVarLengthEncodable, encodable::WitnessVarLengthEncodable,
        selectable::Selectable, witnessable::WitnessHookable,
    },
};
use cs_derive::*;

use boojum::field::FieldExtension;
use boojum::serde_utils::BigArraySerde;

#[derive(
    Derivative,
    CSAllocatable,
    CSSelectable,
    CSVarLengthEncodable,
    WitnessHookable,
    WitVarLengthEncodable,
)]
#[derivative(Clone, Copy, Debug)]
#[DerivePrettyComparison("true")]
pub struct RecursionLeafParameters<F: SmallField> {
    pub circuit_type: Num<F>,
    pub basic_circuit_vk_commitment: [Num<F>; VK_COMMITMENT_LENGTH],
    pub leaf_layer_vk_commitment: [Num<F>; VK_COMMITMENT_LENGTH],
}

impl<F: SmallField> CSPlaceholder<F> for RecursionLeafParameters<F> {
    fn placeholder<CS: ConstraintSystem<F>>(cs: &mut CS) -> Self {
        let zero = Num::zero(cs);
        Self {
            circuit_type: zero,
            basic_circuit_vk_commitment: [zero; VK_COMMITMENT_LENGTH],
            leaf_layer_vk_commitment: [zero; VK_COMMITMENT_LENGTH],
        }
    }
}

impl<F: SmallField> RecursionLeafParameters<F> {
    pub fn allocated_constant<CS: ConstraintSystem<F>>(
        cs: &mut CS,
        value: <Self as CSAllocatable<F>>::Witness,
    ) -> Self {
        let circuit_type = Num::allocated_constant(cs, value.circuit_type);
        let basic_circuit_vk_commitment = value
            .basic_circuit_vk_commitment
            .map(|el| Num::allocated_constant(cs, el));
        let leaf_layer_vk_commitment = value
            .leaf_layer_vk_commitment
            .map(|el| Num::allocated_constant(cs, el));

        Self {
            circuit_type,
            basic_circuit_vk_commitment,
            leaf_layer_vk_commitment,
        }
    }
}

#[derive(Derivative, CSAllocatable, CSSelectable, CSVarLengthEncodable, WitnessHookable)]
#[derivative(Clone, Copy, Debug)]
#[DerivePrettyComparison("true")]
pub struct RecursionLeafInput<F: SmallField> {
    pub params: RecursionLeafParameters<F>,
    pub queue_state: QueueState<F, FULL_SPONGE_QUEUE_STATE_WIDTH>,
}

impl<F: SmallField> CSPlaceholder<F> for RecursionLeafInput<F> {
    fn placeholder<CS: ConstraintSystem<F>>(cs: &mut CS) -> Self {
        Self {
            params: RecursionLeafParameters::placeholder(cs),
            queue_state: QueueState::<F, FULL_SPONGE_QUEUE_STATE_WIDTH>::placeholder(cs),
        }
    }
}

#[derive(Derivative, serde::Serialize, serde::Deserialize)]
#[derivative(
    Clone,
    Debug(bound = ""),
    Default(bound = "RecursionLeafInputWitness<F>: Default")
)]
#[serde(
    bound = "<H::CircuitOutput as CSAllocatable<F>>::Witness: serde::Serialize + serde::de::DeserializeOwned"
)]
pub struct RecursionLeafInstanceWitness<
    F: SmallField,
    H: RecursiveTreeHasher<F, Num<F>>,
    EXT: FieldExtension<2, BaseField = F>,
> {
    pub input: RecursionLeafInputWitness<F>,
    pub vk_witness: VerificationKey<F, H::NonCircuitSimulator>,
    pub queue_witness: FullStateCircuitQueueRawWitness<
        F,
        RecursionQuery<F>,
        FULL_SPONGE_QUEUE_STATE_WIDTH,
        RECURSION_QUERY_PACKED_WIDTH,
    >,
    pub proof_witnesses: VecDeque<Proof<F, H::NonCircuitSimulator, EXT>>,
}