Struct mock::test_ctx::TestContext

pub struct TestContext<const NACC: usize, const NTX: usize> {
    pub chain_id: Word,
    pub accounts: [Account; NACC],
    pub history_hashes: Vec<Word>,
    pub eth_block: Block<Transaction>,
    pub geth_traces: Vec<GethExecTrace>,
}

TestContext is a type that contains all the information from a block required to build the circuit inputs.

It is specifically used to generate Test cases with very precise information details about any specific part of a block. That includes of course, its transactions too and the accounts involved in all of them.

The intended way to interact with the structure is through the fn new which is designed to return a GethData which then can be used to query any specific part of the logs generated by the transactions executed within this context.

Example

use eth_types::evm_types::{stack::Stack, OpcodeId};
use eth_types::{address, bytecode, geth_types::GethData, word, Bytecode, ToWord, Word};
use lazy_static::lazy_static;
use mock::test_ctx::{helpers::*, TestContext};
// code_a calls code
// jump to 0x10 which is outside the code (and also not marked with
        // JUMPDEST)
let code = bytecode! {
    PUSH1(0x10)
    JUMP
    STOP
};
let code_a = bytecode! {
    PUSH1(0x0) // retLength
    PUSH1(0x0) // retOffset
    PUSH1(0x0) // argsLength
    PUSH1(0x0) // argsOffset
    PUSH32(address!("0x000000000000000000000000000000000cafe001").to_word()) // addr
    PUSH32(0x1_0000) // gas
    STATICCALL
    PUSH2(0xaa)
};
let index = 8; // JUMP

// Get the execution steps from the external tracer
let block: GethData = TestContext::<3, 2>::new(
    None,
    |accs| {
        accs[0]
            .address(address!("0x0000000000000000000000000000000000000000"))
            .code(code_a);
        accs[1].address(address!("0x000000000000000000000000000000000cafe001")).code(code);
        accs[2]
            .address(address!("0x000000000000000000000000000000000cafe002"))
            .balance(Word::from(1u64 << 30));
    },
    |mut txs, accs| {
        txs[0].to(accs[0].address).from(accs[2].address);
        txs[1]
            .to(accs[1].address)
            .from(accs[2].address);
    },
    |block, _tx| block.number(0xcafeu64),
)
.unwrap()
.into();

// Now we can start generating the traces and items we need to inspect
// the behaviour of the generated env.

Fields

chain_id: Word

chain id

accounts: [Account; NACC]

Account list

history_hashes: Vec<Word>

history hashes contains most recent 256 block hashes in history, where the latest one is at history_hashes[history_hashes.len() - 1].

eth_block: Block<Transaction>

Block from geth

geth_traces: Vec<GethExecTrace>

Execution Trace from geth

Implementations

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

pub fn new_with_logger_config<FAcc, FTx, Fb>( history_hashes: Option<Vec<Word>>, acc_fns: FAcc, func_tx: FTx, func_block: Fb, logger_config: LoggerConfig ) -> Result<Self, Error>

where FTx: FnOnce(Vec<&mut MockTransaction>, [MockAccount; NACC]), Fb: FnOnce(&mut MockBlock, Vec<MockTransaction>) -> &mut MockBlock, FAcc: FnOnce([&mut MockAccount; NACC]),

pub fn new<FAcc, FTx, Fb>( history_hashes: Option<Vec<Word>>, acc_fns: FAcc, func_tx: FTx, func_block: Fb ) -> Result<Self, Error>

where FTx: FnOnce(Vec<&mut MockTransaction>, [MockAccount; NACC]), Fb: FnOnce(&mut MockBlock, Vec<MockTransaction>) -> &mut MockBlock, FAcc: FnOnce([&mut MockAccount; NACC]),

Create a new TestContext which starts with NACC default accounts and NTX default transactions. Afterwards, we apply the acc_fns function to the accounts, the func_tx to the transactions and the func_block to the block, where each of these functions can mutate their target using the builder pattern. Finally an execution trace is generated of the resulting input block and state.

pub fn simple_ctx_with_bytecode( bytecode: Bytecode ) -> Result<TestContext<2, 1>, Error>

Returns a simple TestContext setup with a single tx executing the bytecode passed as parameters. The balances of the 2 accounts and addresses are the ones used in [TestContext:: account_0_code_account_1_no_code]. Extra accounts, txs and/or block configs are set as Default.

Trait Implementations

impl<const NACC: usize, const NTX: usize> Clone for TestContext<NACC, NTX>

fn clone(&self) -> TestContext<NACC, NTX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const NACC: usize, const NTX: usize> Debug for TestContext<NACC, NTX>

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

Formats the value using the given formatter.

impl<const NACC: usize, const NTX: usize> From<TestContext<NACC, NTX>> for GethData

fn from(ctx: TestContext<NACC, NTX>) -> GethData

Converts to this type from the input type.