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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::*;
use boojum::cs::implementations::proof::Proof;

use boojum::field::SmallField;

use boojum::gadgets::{queue::*, traits::allocatable::*};

use crate::base_structures::precompile_input_outputs::PrecompileFunctionOutputDataWitness;

use crate::base_structures::vm_state::*;
use crate::code_unpacker_sha256::input::CodeDecommitterOutputDataWitness;

use crate::fsm_input_output::circuit_inputs::main_vm::VmOutputDataWitness;
use crate::linear_hasher::input::LinearHasherOutputDataWitness;
use crate::log_sorter::input::EventsDeduplicatorOutputDataWitness;

use crate::fsm_input_output::ClosedFormInputCompactFormWitness;
use crate::storage_application::input::StorageApplicationOutputDataWitness;
use crate::storage_validity_by_grand_product::input::StorageDeduplicatorOutputDataWitness;
use boojum::gadgets::num::Num;
use boojum::gadgets::recursion::recursive_tree_hasher::RecursiveTreeHasher;
use std::collections::VecDeque;

use crate::recursion::leaf_layer::input::*;
use crate::recursion::*;
use boojum::field::FieldExtension;

// This structure only keeps witness, but there is a lot of in unfortunately
#[derive(Derivative, serde::Serialize, serde::Deserialize)]
#[derivative(Clone, Debug)]
#[serde(
    bound = "<H::CircuitOutput as CSAllocatable<F>>::Witness: serde::Serialize + serde::de::DeserializeOwned,
    [RecursionLeafParametersWitness<F>; NUM_BASE_LAYER_CIRCUITS]: serde::Serialize + serde::de::DeserializeOwned"
)]
pub struct SchedulerCircuitInstanceWitness<
    F: SmallField,
    H: RecursiveTreeHasher<F, Num<F>>,
    EXT: FieldExtension<2, BaseField = F>,
> {
    pub prev_block_data: BlockPassthroughDataWitness<F>,
    pub block_meta_parameters: BlockMetaParametersWitness<F>,

    // passthrough outputs for all the circuits that produce such
    pub vm_end_of_execution_observable_output: VmOutputDataWitness<F>,
    pub decommits_sorter_observable_output: CodeDecommittmentsDeduplicatorOutputDataWitness<F>,
    pub code_decommitter_observable_output: CodeDecommitterOutputDataWitness<F>,
    pub log_demuxer_observable_output: LogDemuxerOutputDataWitness<F>,
    pub keccak256_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub sha256_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub ecrecover_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub secp256r1_verify_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub modexp_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub ecadd_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub ecmul_observable_output: PrecompileFunctionOutputDataWitness<F>,
    pub ecpairing_observable_output: PrecompileFunctionOutputDataWitness<F>,

    // RAM permutation doesn't produce anything
    pub storage_sorter_observable_output: StorageDeduplicatorOutputDataWitness<F>,
    pub storage_application_observable_output: StorageApplicationOutputDataWitness<F>,
    pub events_sorter_observable_output: EventsDeduplicatorOutputDataWitness<F>,
    pub l1messages_sorter_observable_output: EventsDeduplicatorOutputDataWitness<F>,
    pub l1messages_linear_hasher_observable_output: LinearHasherOutputDataWitness<F>,

    // very few things that we need to properly produce this block
    pub storage_log_tail: [F; QUEUE_STATE_WIDTH],
    pub per_circuit_closed_form_inputs: VecDeque<ClosedFormInputCompactFormWitness<F>>,

    pub bootloader_heap_memory_state: QueueTailStateWitness<F, FULL_SPONGE_QUEUE_STATE_WIDTH>,
    pub ram_sorted_queue_state: QueueTailStateWitness<F, FULL_SPONGE_QUEUE_STATE_WIDTH>,
    pub decommits_sorter_intermediate_queue_state:
        QueueTailStateWitness<F, FULL_SPONGE_QUEUE_STATE_WIDTH>,

    // all multi-circuits responsible for sorting
    pub rollup_storage_sorter_intermediate_queue_state: QueueTailStateWitness<F, QUEUE_STATE_WIDTH>,
    pub events_sorter_intermediate_queue_state: QueueTailStateWitness<F, QUEUE_STATE_WIDTH>,
    pub l1messages_sorter_intermediate_queue_state: QueueTailStateWitness<F, QUEUE_STATE_WIDTH>,
    pub transient_storage_sorter_intermediate_queue_state:
        QueueTailStateWitness<F, QUEUE_STATE_WIDTH>,

    // extra information about the previous block
    pub previous_block_meta_hash: [u8; 32],
    pub previous_block_aux_hash: [u8; 32],

    // eip4844 witnesses
    pub eip4844_witnesses: [Option<EIP4844OutputDataWitness<F>>; MAX_4844_BLOBS_PER_BLOCK],

    // proofs for every individual circuit type's aggregation subtree
    #[derivative(Debug = "ignore")]
    pub proof_witnesses: VecDeque<Proof<F, H::NonCircuitSimulator, EXT>>,
}

impl<F: SmallField, H: RecursiveTreeHasher<F, Num<F>>, EXT: FieldExtension<2, BaseField = F>>
    SchedulerCircuitInstanceWitness<F, H, EXT>
{
    pub fn placeholder() -> Self {
        Self {
            prev_block_data: BlockPassthroughData::placeholder_witness(),
            block_meta_parameters: BlockMetaParameters::placeholder_witness(),

            vm_end_of_execution_observable_output: VmOutputData::placeholder_witness(),
            decommits_sorter_observable_output:
                CodeDecommittmentsDeduplicatorOutputData::placeholder_witness(),
            code_decommitter_observable_output: CodeDecommitterOutputData::placeholder_witness(),
            log_demuxer_observable_output: LogDemuxerOutputData::placeholder_witness(),

            keccak256_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            sha256_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            ecrecover_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            secp256r1_verify_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            modexp_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            ecadd_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            ecmul_observable_output: PrecompileFunctionOutputData::placeholder_witness(),
            ecpairing_observable_output: PrecompileFunctionOutputData::placeholder_witness(),

            storage_sorter_observable_output: StorageDeduplicatorOutputData::placeholder_witness(),
            storage_application_observable_output:
                StorageApplicationOutputData::placeholder_witness(),
            events_sorter_observable_output: EventsDeduplicatorOutputData::placeholder_witness(),
            l1messages_sorter_observable_output: EventsDeduplicatorOutputData::placeholder_witness(
            ),
            l1messages_linear_hasher_observable_output: LinearHasherOutputData::placeholder_witness(
            ),

            storage_log_tail: [F::ZERO; QUEUE_STATE_WIDTH],
            per_circuit_closed_form_inputs: VecDeque::new(),

            bootloader_heap_memory_state: QueueTailState::placeholder_witness(),
            ram_sorted_queue_state: QueueTailState::placeholder_witness(),
            decommits_sorter_intermediate_queue_state: QueueTailState::placeholder_witness(),

            rollup_storage_sorter_intermediate_queue_state: QueueTailState::placeholder_witness(),
            events_sorter_intermediate_queue_state: QueueTailState::placeholder_witness(),
            l1messages_sorter_intermediate_queue_state: QueueTailState::placeholder_witness(),
            transient_storage_sorter_intermediate_queue_state: QueueTailState::placeholder_witness(
            ),

            previous_block_meta_hash: [0u8; 32],
            previous_block_aux_hash: [0u8; 32],

            eip4844_witnesses: std::array::from_fn(|_| None),

            proof_witnesses: VecDeque::new(),
        }
    }
}