Struct zkevm_circuits::test_util::CircuitTestBuilder

pub struct CircuitTestBuilder<const NACC: usize, const NTX: usize> { /* private fields */ }

Struct used to easily generate tests for EVM &| State circuits being able to customize all of the steps involved in the testing itself.

By default, the tests run through prover.assert_satisfied_par() but the builder pattern provides functions that allow to pass different functions that the prover should execute when verifying the CTB correctness.

The CTB also includes a mechanism to receive calls that will modify the block produced from the TestContext and apply them before starting to compute the proof.

Example:

use eth_types::geth_types::Account;
use eth_types::{address, bytecode, Address, Bytecode, ToWord, Word, U256, word};
use mock::{TestContext, MOCK_ACCOUNTS, gwei, eth};
use zkevm_circuits::test_util::CircuitTestBuilder;
    let code = bytecode! {
// [ADDRESS, STOP]
    PUSH32(word!("
3000000000000000000000000000000000000000000000000000000000000000"))
    PUSH1(0)
    MSTORE

    PUSH1(2)
    PUSH1(0)
    RETURN
};
let ctx = TestContext::<1, 1>::new(
    None,
    |accs| {
        accs[0].address(MOCK_ACCOUNTS[0]).balance(eth(20));
    },
    |mut txs, _accs| {
        txs[0]
            .from(MOCK_ACCOUNTS[0])
            .gas_price(gwei(2))
            .gas(Word::from(0x10000))
            .value(eth(2))
            .input(code.into());
    },
    |block, _tx| block.number(0xcafeu64),
)
.unwrap();

CircuitTestBuilder::new_from_test_ctx(ctx)
   .block_modifier(Box::new(|_block, chunk| {
       chunk
           .iter_mut()
           .for_each(|chunk| chunk.fixed_param.max_evm_rows = (1 << 18) - 100);
   }))
   .run()

Implementations

impl<const NACC: usize, const NTX: usize> CircuitTestBuilder<NACC, NTX>

pub fn new_from_test_ctx(ctx: TestContext<NACC, NTX>) -> Self

Generates a CTBC from a TestContext passed with all the other fields set to Default.

pub fn new_from_block(block: Block<Fr>, chunks: Vec<Chunk<Fr>>) -> Self

Generates a CTBC from a Block passed with all the other fields set to Default.

pub fn test_ctx(self, ctx: TestContext<NACC, NTX>) -> Self

Allows to produce a TestContext which will serve as the generator of the Block.

pub fn params(self, params: FixedCParams) -> Self

Allows to pass a non-default FixedCParams to the builder. This means that we can increase for example, the max_rws or max_txs.

pub fn feature(self, feature_config: FeatureConfig) -> Self

Configure FeatureConfig

pub fn set_block_chunk(self, block: Block<Fr>, chunks: Vec<Chunk<Fr>>) -> Self

Allows to pass a Block, Chunk vectors already built to the constructor.

pub fn block_modifier( self, modifier: Box<dyn Fn(&mut Block<Fr>, &mut Vec<Chunk<Fr>>)> ) -> Self

Allows to provide modifier functions for the [Block, Chunk] that will be generated within this builder.

That removes the need in a lot of tests to build the block outside of the builder because they need to modify something particular.

impl<const NACC: usize, const NTX: usize> CircuitTestBuilder<NACC, NTX>

pub fn build_block( &self, total_chunks: Option<usize> ) -> Result<(Block<Fr>, Vec<Chunk<Fr>>), CircuitTestError>

build block

pub fn run_with_result(self) -> Result<(), CircuitTestError>

Triggers the CircuitTestBuilder to convert the TestContext if any, into a Block and apply the default or provided block_modifiers or circuit checks to the provers generated for the State and EVM circuits.

pub fn run_multiple_chunks_with_result( self, total_chunks: Option<usize> ) -> Result<(), CircuitTestError>

Triggers the CircuitTestBuilder to convert the TestContext if any, into a Block and apply the default or provided block_modifiers or circuit checks to the provers generated for the State and EVM circuits.

pub fn run(self)

Convenient method to run in test cases that error handling is not required.