Struct zkevm_circuits::super_circuit::SuperCircuit

pub struct SuperCircuit<F: Field> {
    pub chunk: Option<Chunk<F>>,
    pub evm_circuit: EvmCircuit<F>,
    pub state_circuit: StateCircuit<F>,
    pub tx_circuit: TxCircuit<F>,
    pub pi_circuit: PiCircuit<F>,
    pub bytecode_circuit: BytecodeCircuit<F>,
    pub copy_circuit: CopyCircuit<F>,
    pub exp_circuit: ExpCircuit<F>,
    pub keccak_circuit: KeccakCircuit<F>,
    pub circuits_params: FixedCParams,
    pub feature_config: FeatureConfig,
    pub mock_randomness: F,
}

The Super Circuit contains all the zkEVM circuits

Fields

chunk: Option<Chunk<F>>

Chunk

evm_circuit: EvmCircuit<F>

EVM Circuit

state_circuit: StateCircuit<F>

State Circuit

tx_circuit: TxCircuit<F>

The transaction circuit that will be used in the synthesize step.

pi_circuit: PiCircuit<F>

Public Input Circuit

bytecode_circuit: BytecodeCircuit<F>

Bytecode Circuit

copy_circuit: CopyCircuit<F>

Copy Circuit

exp_circuit: ExpCircuit<F>

Exp Circuit

keccak_circuit: KeccakCircuit<F>

Keccak Circuit

circuits_params: FixedCParams

Circuits Parameters

feature_config: FeatureConfig

Feature Config

mock_randomness: F

Mock randomness

Implementations

impl<F: Field> SuperCircuit<F>

pub fn get_num_rows_required(block: &Block<F>, chunk: &Chunk<F>) -> usize

Return the number of rows required to verify a given block

impl<F: Field> SuperCircuit<F>

pub fn build( geth_data: GethData, circuits_params: FixedCParams, mock_randomness: F ) -> Result<(u32, Vec<Self>, Vec<Vec<Vec<F>>>, CircuitInputBuilder<FixedCParams>), Error>

From the witness data, generate a SuperCircuit instance with all of the sub-circuits filled with their corresponding witnesses.

Also, return with it the minimum required SRS degree for the circuit and the Public Inputs needed.

pub fn build_from_circuit_input_builder( builder: &CircuitInputBuilder<FixedCParams>, mock_randomness: F ) -> Result<(u32, Vec<Self>, Vec<Vec<Vec<F>>>), Error>

From CircuitInputBuilder, generate a SuperCircuit instance with all of the sub-circuits filled with their corresponding witnesses.

Also, return with it the minimum required SRS degree for the circuit and the Public Inputs needed.

Trait Implementations

impl<F: Field> Circuit<F> for SuperCircuit<F>

type Config = SuperCircuitConfig<F>

This is a configuration object that stores things like columns.

type FloorPlanner = SimpleFloorPlanner

The floor planner used for this circuit. This is an associated type of the Circuit trait because its behaviour is circuit-critical.

type Params = SuperCircuitParams<F>

Optional circuit configuration parameters. Requires the circuit-params feature.

fn without_witnesses(&self) -> Self

Returns a copy of this circuit with no witness values (i.e. all witnesses set to None). For most circuits, this will be equal to Self::default().

fn params(&self) -> Self::Params

Returns a reference to the parameters that should be used to configure the circuit. Requires the circuit-params feature.

fn configure_with_params( meta: &mut ConstraintSystem<F>, params: Self::Params ) -> Self::Config

The circuit is given an opportunity to describe the exact gate arrangement, column arrangement, etc. Takes a runtime parameter. The default implementation calls configure ignoring the _params argument in order to easily support circuits that don’t use configuration parameters.

fn configure(_meta: &mut ConstraintSystem<F>) -> Self::Config

The circuit is given an opportunity to describe the exact gate arrangement, column arrangement, etc.

fn synthesize( &self, config: Self::Config, layouter: impl Layouter<F> ) -> Result<(), Error>

Given the provided cs, synthesize the circuit. The concrete type of the caller will be different depending on the context, and they may or may not expect to have a witness present.

impl<F: Clone + Field> Clone for SuperCircuit<F>

fn clone(&self) -> SuperCircuit<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for SuperCircuit<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default + Field> Default for SuperCircuit<F>

fn default() -> SuperCircuit<F>

Returns the “default value” for a type.

impl<F: Field> SubCircuit<F> for SuperCircuit<F>

fn instance(&self) -> Vec<Vec<F>>

Returns suitable inputs for the SuperCircuit.

fn min_num_rows_block(block: &Block<F>, chunk: &Chunk<F>) -> (usize, usize)

Return the minimum number of rows required to prove the block

fn synthesize_sub( &self, config: &Self::Config, challenges: &Challenges<Value<F>>, layouter: &mut impl Layouter<F> ) -> Result<(), Error>

Make the assignments to the SuperCircuit

type Config = SuperCircuitConfig<F>

Configuration of the SubCircuit.

fn unusable_rows() -> usize

Returns number of unusable rows of the SubCircuit, which should be meta.blinding_factors() + 1.

fn new_from_block(block: &Block<F>, chunk: &Chunk<F>) -> Self

Create a new SubCircuit from a witness Block