diff --git a/zkevm-circuits/src/bytecode_circuit/circuit.rs b/zkevm-circuits/src/bytecode_circuit/circuit.rs index cdcc3e260b..2214c12e03 100644 --- a/zkevm-circuits/src/bytecode_circuit/circuit.rs +++ b/zkevm-circuits/src/bytecode_circuit/circuit.rs @@ -378,6 +378,7 @@ impl SubCircuitConfig for BytecodeCircuitConfig { is_byte_to_header(meta), ])) }); + #[cfg(not(feature = "poseidon-codehash"))] meta.lookup_any( "keccak256_table_lookup(cur.value_rlc, cur.length, cur.hash)", |meta| { diff --git a/zkevm-circuits/src/evm_circuit/execution.rs b/zkevm-circuits/src/evm_circuit/execution.rs index c7917b6027..f8a8481f2e 100644 --- a/zkevm-circuits/src/evm_circuit/execution.rs +++ b/zkevm-circuits/src/evm_circuit/execution.rs @@ -300,7 +300,8 @@ pub(crate) struct ExecutionConfig { shl_shr_gadget: Box>, returndatasize_gadget: Box>, returndatacopy_gadget: Box>, - create_gadget: Box>, + create_gadget: Box>, + create2_gadget: Box>, selfdestruct_gadget: Box>, signed_comparator_gadget: Box>, signextend_gadget: Box>, @@ -570,6 +571,7 @@ impl ExecutionConfig { returndatasize_gadget: configure_gadget!(), returndatacopy_gadget: configure_gadget!(), create_gadget: configure_gadget!(), + create2_gadget: configure_gadget!(), selfdestruct_gadget: configure_gadget!(), shl_shr_gadget: configure_gadget!(), signed_comparator_gadget: configure_gadget!(), @@ -1367,6 +1369,7 @@ impl ExecutionConfig { ExecutionState::BLOCKHASH => assign_exec_step!(self.blockhash_gadget), ExecutionState::SELFBALANCE => assign_exec_step!(self.selfbalance_gadget), ExecutionState::CREATE => assign_exec_step!(self.create_gadget), + ExecutionState::CREATE2 => assign_exec_step!(self.create2_gadget), // dummy gadgets ExecutionState::EXTCODECOPY => assign_exec_step!(self.extcodecopy_gadget), ExecutionState::SELFDESTRUCT => assign_exec_step!(self.selfdestruct_gadget), diff --git a/zkevm-circuits/src/evm_circuit/execution/create.rs b/zkevm-circuits/src/evm_circuit/execution/create.rs index bd63162120..defeb74b8b 100644 --- a/zkevm-circuits/src/evm_circuit/execution/create.rs +++ b/zkevm-circuits/src/evm_circuit/execution/create.rs @@ -3,7 +3,7 @@ use crate::{ execution::ExecutionGadget, param::{ N_BYTES_ACCOUNT_ADDRESS, N_BYTES_GAS, N_BYTES_MEMORY_ADDRESS, N_BYTES_MEMORY_WORD_SIZE, - N_BYTES_U64, + N_BYTES_WORD, }, step::ExecutionState, util::{ @@ -12,10 +12,9 @@ use crate::{ ConstraintBuilder, ReversionInfo, StepStateTransition, Transition::{Delta, To}, }, - from_bytes, - math_gadget::{ConstantDivisionGadget, IsZeroGadget}, + math_gadget::{ConstantDivisionGadget, ContractCreateGadget}, memory_gadget::{MemoryAddressGadget, MemoryExpansionGadget}, - not, rlc, select, sum, CachedRegion, Cell, RandomLinearCombination, Word, + not, select, CachedRegion, Cell, Word, }, witness::{Block, Call, ExecStep, Transaction}, }, @@ -24,53 +23,38 @@ use crate::{ }; use bus_mapping::{circuit_input_builder::CopyDataType, evm::OpcodeId}; use eth_types::{evm_types::GasCost, Field, ToBigEndian, ToLittleEndian, ToScalar, U256}; -use ethers_core::utils::{keccak256, rlp}; -use halo2_proofs::{ - circuit::Value, - plonk::{Error, Expression}, -}; +use ethers_core::utils::keccak256; +use gadgets::util::expr_from_bytes; +use halo2_proofs::{circuit::Value, plonk::Error}; use std::iter::once; /// Gadget for CREATE and CREATE2 opcodes #[derive(Clone, Debug)] -pub(crate) struct CreateGadget { +pub(crate) struct CreateGadget { opcode: Cell, - is_create2: Cell, - value: Word, - salt: Word, - tx_id: Cell, reversion_info: ReversionInfo, was_warm: Cell, - depth: Cell, - caller_address: RandomLinearCombination, - nonce: RlpU64Gadget, - callee_reversion_info: ReversionInfo, callee_is_success: Cell, - transfer: TransferGadget, - - initialization_code: MemoryAddressGadget, - initialization_code_word_size: ConstantDivisionGadget, + init_code: MemoryAddressGadget, + init_code_word_size: ConstantDivisionGadget, memory_expansion: MemoryExpansionGadget, - gas_left: ConstantDivisionGadget, - - code_hash: Cell, - - keccak_input: Cell, - keccak_input_length: Cell, + create: ContractCreateGadget, keccak_output: Word, } -impl ExecutionGadget for CreateGadget { +impl ExecutionGadget + for CreateGadget +{ const NAME: &'static str = "CREATE"; - const EXECUTION_STATE: ExecutionState = ExecutionState::CREATE; + const EXECUTION_STATE: ExecutionState = S; fn configure(cb: &mut ConstraintBuilder) -> Self { // Use rw_counter of the step which triggers next call as its call_id. @@ -79,62 +63,71 @@ impl ExecutionGadget for CreateGadget { let opcode = cb.query_cell(); cb.opcode_lookup(opcode.expr(), 1.expr()); - let is_create2 = cb.query_bool(); cb.require_equal( "Opcode is CREATE or CREATE2", opcode.expr(), select::expr( - is_create2.expr(), + IS_CREATE2.expr(), OpcodeId::CREATE2.expr(), OpcodeId::CREATE.expr(), ), ); let value = cb.query_word_rlc(); - cb.stack_pop(value.expr()); - let initialization_code = MemoryAddressGadget::construct_2(cb); - cb.stack_pop(initialization_code.offset_rlc()); - cb.stack_pop(initialization_code.length_rlc()); - - let salt = cb.condition(is_create2.expr(), |cb| { - let salt = cb.query_word_rlc(); - cb.stack_pop(salt.expr()); - salt - }); + let init_code_memory_offset = cb.query_cell_phase2(); + let init_code_length = cb.query_word_rlc(); + let init_code = + MemoryAddressGadget::construct(cb, init_code_memory_offset, init_code_length); let keccak_output = cb.query_word_rlc(); - let new_address_array: [Expression; 20] = keccak_output.cells[..20] - .iter() - .map(Expr::expr) - .collect::>() - .try_into() - .unwrap(); - let new_address_rlc = cb.word_rlc(new_address_array); + let new_address_rlc = cb.word_rlc::( + keccak_output + .cells + .iter() + .take(N_BYTES_ACCOUNT_ADDRESS) + .map(Expr::expr) + .collect::>() + .try_into() + .unwrap(), + ); + let new_address = expr_from_bytes(&keccak_output.cells[..N_BYTES_ACCOUNT_ADDRESS]); let callee_is_success = cb.query_bool(); + + let create = ContractCreateGadget::construct(cb); + + cb.stack_pop(value.expr()); + cb.stack_pop(init_code.offset_rlc()); + cb.stack_pop(init_code.length_rlc()); + cb.condition(IS_CREATE2.expr(), |cb| { + cb.stack_pop(create.salt_keccak_rlc()); + }); + cb.stack_push(callee_is_success.expr() * new_address_rlc); - let code_hash = cb.query_cell_phase2(); - cb.condition(initialization_code.has_length(), |cb| { + cb.condition(init_code.has_length(), |cb| { cb.copy_table_lookup( cb.curr.state.call_id.expr(), CopyDataType::Memory.expr(), - code_hash.expr(), + create.code_hash_word_rlc(cb), CopyDataType::Bytecode.expr(), - initialization_code.offset(), - initialization_code.address(), + init_code.offset(), + init_code.address(), 0.expr(), - initialization_code.length(), + init_code.length(), 0.expr(), - initialization_code.length(), + init_code.length(), ); }); - cb.condition(not::expr(initialization_code.has_length()), |cb| { - cb.require_equal("", code_hash.expr(), cb.empty_code_hash_rlc()); + cb.condition(not::expr(init_code.has_length()), |cb| { + cb.require_equal( + "Empty code", + create.code_hash_word_rlc(cb), + cb.empty_code_hash_rlc(), + ); }); let tx_id = cb.call_context(None, CallContextFieldTag::TxId); - let new_address = from_bytes::expr(&keccak_output.cells[..20]); let mut reversion_info = cb.reversion_info_read(None); let was_warm = cb.query_bool(); cb.account_access_list_write( @@ -145,24 +138,21 @@ impl ExecutionGadget for CreateGadget { Some(&mut reversion_info), ); - let caller_address = cb.query_word_rlc(); cb.call_context_lookup( 0.expr(), None, CallContextFieldTag::CalleeAddress, - from_bytes::expr(&caller_address.cells), + create.caller_address(), ); - let nonce = RlpU64Gadget::construct(cb); cb.account_write( - from_bytes::expr(&caller_address.cells), + create.caller_address(), AccountFieldTag::Nonce, - nonce.value() + 1.expr(), - nonce.value(), + create.caller_nonce() + 1.expr(), + create.caller_nonce(), Some(&mut reversion_info), ); - // TODO: deduplicate with the code in CallOpGadget let mut callee_reversion_info = cb.reversion_info_write(Some(callee_call_id.expr())); cb.require_equal( "callee_is_persistent == is_persistent ⋅ is_success", @@ -179,7 +169,7 @@ impl ExecutionGadget for CreateGadget { let transfer = TransferGadget::construct( cb, - from_bytes::expr(&caller_address.cells), + create.caller_address(), new_address.clone(), 0.expr(), 1.expr(), @@ -195,14 +185,15 @@ impl ExecutionGadget for CreateGadget { Some(&mut callee_reversion_info), ); - let memory_expansion = - MemoryExpansionGadget::construct(cb, [initialization_code.address()]); + let memory_expansion = MemoryExpansionGadget::construct(cb, [init_code.address()]); - let initialization_code_word_size = - ConstantDivisionGadget::construct(cb, initialization_code.length() + 31.expr(), 32); - let keccak_gas_cost = GasCost::COPY_SHA3.expr() - * is_create2.expr() - * initialization_code_word_size.quotient(); + let init_code_word_size = ConstantDivisionGadget::construct( + cb, + init_code.length() + (N_BYTES_WORD - 1).expr(), + N_BYTES_WORD as u64, + ); + let keccak_gas_cost = + GasCost::COPY_SHA3.expr() * IS_CREATE2.expr() * init_code_word_size.quotient(); let gas_cost = GasCost::CREATE.expr() + memory_expansion.gas_cost() + keccak_gas_cost; let gas_remaining = cb.curr.state.gas_left.expr() - gas_cost.clone(); @@ -215,7 +206,7 @@ impl ExecutionGadget for CreateGadget { ), ( CallContextFieldTag::StackPointer, - cb.curr.state.stack_pointer.expr() + 2.expr() + is_create2.expr(), + cb.curr.state.stack_pointer.expr() + 2.expr() + IS_CREATE2.expr(), ), (CallContextFieldTag::GasLeft, gas_left.quotient()), ( @@ -240,10 +231,7 @@ impl ExecutionGadget for CreateGadget { callee_reversion_info.is_persistent(), ), (CallContextFieldTag::TxId, tx_id.expr()), - ( - CallContextFieldTag::CallerAddress, - from_bytes::expr(&caller_address.cells), - ), + (CallContextFieldTag::CallerAddress, create.caller_address()), (CallContextFieldTag::CalleeAddress, new_address), ( CallContextFieldTag::RwCounterEndOfReversion, @@ -253,26 +241,31 @@ impl ExecutionGadget for CreateGadget { (CallContextFieldTag::IsRoot, false.expr()), (CallContextFieldTag::IsStatic, false.expr()), (CallContextFieldTag::IsCreate, true.expr()), - (CallContextFieldTag::CodeHash, code_hash.expr()), + (CallContextFieldTag::CodeHash, create.code_hash_word_rlc(cb)), (CallContextFieldTag::Value, value.expr()), ] { cb.call_context_lookup(true.expr(), Some(callee_call_id.expr()), field_tag, value); } - cb.condition(initialization_code.has_length(), |cb| { + cb.keccak_table_lookup( + create.input_rlc(cb), + create.input_length(), + keccak_output.expr(), + ); + cb.condition(init_code.has_length(), |cb| { cb.require_step_state_transition(StepStateTransition { rw_counter: Delta(cb.rw_counter_offset()), call_id: To(callee_call_id.expr()), is_root: To(false.expr()), is_create: To(true.expr()), - code_hash: To(code_hash.expr()), + code_hash: To(create.code_hash_word_rlc(cb)), gas_left: To(callee_gas_left), reversible_write_counter: To(1.expr() + transfer.reversible_w_delta()), ..StepStateTransition::new_context() }) }); - cb.condition(not::expr(initialization_code.has_length()), |cb| { + cb.condition(not::expr(init_code.has_length()), |cb| { for field_tag in [ CallContextFieldTag::LastCalleeId, CallContextFieldTag::LastCalleeReturnDataOffset, @@ -283,90 +276,29 @@ impl ExecutionGadget for CreateGadget { cb.require_step_state_transition(StepStateTransition { rw_counter: Delta(cb.rw_counter_offset()), program_counter: Delta(1.expr()), - stack_pointer: Delta(2.expr() + is_create2.expr()), + stack_pointer: Delta(2.expr() + IS_CREATE2.expr()), gas_left: Delta(-gas_cost), reversible_write_counter: Delta(3.expr() + transfer.reversible_w_delta()), ..Default::default() }) }); - let keccak_input = cb.query_cell_phase2(); - let keccak_input_length = cb.query_cell(); - // cb.condition(is_create2.expr(), |cb| { - // For CREATE2, the keccak input is the concatenation of 0xff, address, salt, - // and code_hash. Each sequence of bytes occurs in a fixed position, so to - // compute the RLC of the input, we only need to compute some fixed powers of - // the randomness. - // let randomness_raised_to_16 = cb.power_of_randomness()[15].clone(); - // let randomness_raised_to_32 = randomness_raised_to_16.square(); - // let randomness_raised_to_64 = randomness_raised_to_32.clone().square(); - // let randomness_raised_to_84 = - // randomness_raised_to_64.clone() * cb.power_of_randomness()[19].clone(); - // cb.require_equal( - // "for CREATE2, keccak input is 0xff ++ address ++ salt ++ code_hash", - // keccak_input.expr(), - // 0xff.expr() * randomness_raised_to_84 - // + caller_address.expr() * randomness_raised_to_64 - // + salt.expr() * randomness_raised_to_32 - // + code_hash.expr(), - // ); - // cb.require_equal( - // "for CREATE2, keccak input length is 85", - // keccak_input_length.expr(), - // (1 + 20 + 32 + 32).expr(), - // ); - // }); - // - // - // cb.condition(not::expr(is_create2.expr()), |cb| { - // let randomness_raised_to_20 = cb.power_of_randomness()[19].clone(); - // let randomness_raised_to_21 = cb.power_of_randomness()[20].clone(); - // cb.require_equal( - // "for CREATE, keccak input is rlp([address, nonce])", - // keccak_input.expr(), - // nonce.rlp_rlc(cb) - // + nonce.randomness_raised_to_rlp_length(cb) - // (((0xc0.expr() + 21.expr() + nonce.rlp_length()) - // randomness_raised_to_21) - // + (0x80 + 20).expr() * randomness_raised_to_20 - // + caller_address.expr()), - // ); - // cb.require_equal( - // "for CREATE, keccak input length is rlp([address, nonce]).len()", - // keccak_input_length.expr(), - // (1 + 1 + 20).expr() + nonce.rlp_length(), - // ); - // }); - // - // - // cb.keccak_table_lookup( - // keccak_input.expr(), - // keccak_input_length.expr(), - // keccak_output.expr(), - // ); - Self { opcode, - is_create2, reversion_info, tx_id, was_warm, value, - salt, - caller_address, - nonce, depth, callee_reversion_info, transfer, - initialization_code, + init_code, memory_expansion, gas_left, callee_is_success, - code_hash, + init_code_word_size, + create, keccak_output, - keccak_input, - keccak_input_length, - initialization_code_word_size, } } @@ -383,15 +315,12 @@ impl ExecutionGadget for CreateGadget { let is_create2 = opcode == OpcodeId::CREATE2; self.opcode .assign(region, offset, Value::known(F::from(opcode.as_u64())))?; - self.is_create2.assign( - region, - offset, - Value::known(is_create2.to_scalar().unwrap()), - )?; - let [value, initialization_code_start, initialization_code_length] = [0, 1, 2] + let [value, init_code_start, init_code_length] = [0, 1, 2] .map(|i| step.rw_indices[i]) .map(|idx| block.rws[idx].stack_value()); + self.value + .assign(region, offset, Some(value.to_le_bytes()))?; let salt = if is_create2 { block.rws[step.rw_indices[3]].stack_value() } else { @@ -399,23 +328,13 @@ impl ExecutionGadget for CreateGadget { }; let values: Vec<_> = (4 + usize::from(is_create2) - ..4 + usize::from(is_create2) + initialization_code_length.as_usize()) + ..4 + usize::from(is_create2) + init_code_length.as_usize()) .map(|i| block.rws[step.rw_indices[i]].memory_value()) .collect(); - let mut code_hash = keccak256(&values); - code_hash.reverse(); - let code_hash_rlc = region.word_rlc(U256::from_little_endian(&code_hash)); - self.code_hash.assign(region, offset, code_hash_rlc)?; - for (word, assignment) in [(&self.value, value), (&self.salt, salt)] { - word.assign(region, offset, Some(assignment.to_le_bytes()))?; - } - let initialization_code_address = self.initialization_code.assign( - region, - offset, - initialization_code_start, - initialization_code_length, - )?; + let init_code_address = + self.init_code + .assign(region, offset, init_code_start, init_code_length)?; self.tx_id .assign(region, offset, Value::known(tx.id.to_scalar().unwrap()))?; @@ -432,7 +351,7 @@ impl ExecutionGadget for CreateGadget { call.is_persistent, )?; - let copy_rw_increase = initialization_code_length.as_usize(); + let copy_rw_increase = init_code_length.as_usize(); let tx_access_rw = block.rws[step.rw_indices[7 + usize::from(is_create2) + copy_rw_increase]]; self.was_warm.assign( @@ -447,17 +366,11 @@ impl ExecutionGadget for CreateGadget { ), )?; - let mut caller_address_bytes = call.callee_address.to_fixed_bytes(); - caller_address_bytes.reverse(); - self.caller_address - .assign(region, offset, Some(caller_address_bytes))?; - let caller_nonce = block.rws [step.rw_indices[9 + usize::from(is_create2) + copy_rw_increase]] .account_value_pair() .1 .low_u64(); - self.nonce.assign(region, offset, caller_nonce)?; let [callee_rw_counter_end_of_reversion, callee_is_persistent] = [10, 11].map(|i| { let rw = block.rws[step.rw_indices[i + usize::from(is_create2) + copy_rw_increase]]; @@ -503,21 +416,20 @@ impl ExecutionGadget for CreateGadget { region, offset, step.memory_word_size(), - [initialization_code_address], + [init_code_address], )?; - let (initialization_code_word_size, _remainder) = - self.initialization_code_word_size.assign( - region, - offset, - (31u64 + initialization_code_length.as_u64()).into(), - )?; + let (init_code_word_size, _remainder) = self.init_code_word_size.assign( + region, + offset, + (31u64 + init_code_length.as_u64()).into(), + )?; let gas_left = step.gas_left - GasCost::CREATE.as_u64() - memory_expansion_gas_cost - if is_create2 { - u64::try_from(initialization_code_word_size).unwrap() * GasCost::COPY_SHA3.as_u64() + u64::try_from(init_code_word_size).unwrap() * GasCost::COPY_SHA3.as_u64() } else { 0 }; @@ -542,180 +454,29 @@ impl ExecutionGadget for CreateGadget { .chain(keccak256(&values)) .collect() } else { - let mut stream = rlp::RlpStream::new(); + let mut stream = ethers_core::utils::rlp::RlpStream::new(); stream.begin_list(2); stream.append(&call.callee_address); stream.append(&U256::from(caller_nonce)); stream.out().to_vec() }; - let mut keccak_output = keccak256(&keccak_input); + let mut keccak_output = keccak256(keccak_input); keccak_output.reverse(); - let keccak_input_rlc = region - .challenges() - .keccak_input() - .map(|randomness| rlc::value(keccak_input.iter().rev(), randomness)); - self.keccak_input.assign(region, offset, keccak_input_rlc)?; - self.keccak_input_length.assign( - region, - offset, - Value::known(keccak_input.len().to_scalar().unwrap()), - )?; self.keccak_output .assign(region, offset, Some(keccak_output))?; - Ok(()) - } -} - -#[derive(Clone, Debug)] -struct RlpU64Gadget { - bytes: RandomLinearCombination, - is_most_significant_byte: [Cell; N_BYTES_U64], - most_significant_byte_is_zero: IsZeroGadget, - is_less_than_128: Cell, -} - -impl RlpU64Gadget { - fn construct(cb: &mut ConstraintBuilder) -> Self { - let bytes = cb.query_word_rlc(); - let is_most_significant_byte = [(); N_BYTES_U64].map(|()| cb.query_bool()); - let most_significant_byte = sum::expr( - bytes - .cells - .iter() - .zip(&is_most_significant_byte) - .map(|(byte, indicator)| byte.expr() * indicator.expr()), - ); - let most_significant_byte_is_zero = IsZeroGadget::construct(cb, most_significant_byte); - let is_less_than_128 = cb.query_bool(); - - cb.require_boolean( - "at most one of is_most_significant_byte is one", - sum::expr(&is_most_significant_byte), - ); - - let value = from_bytes::expr(&bytes.cells); - cb.condition(most_significant_byte_is_zero.expr(), |cb| { - cb.require_zero("if most significant byte is 0, value is 0", value.clone()); - }); - for (i, is_most_significant) in is_most_significant_byte.iter().enumerate() { - cb.condition(is_most_significant.expr(), |cb| { - cb.require_equal( - "most significant byte is non-zero", - most_significant_byte_is_zero.expr(), - 0.expr(), - ); - cb.require_equal( - "higher bytes are 0", - from_bytes::expr(&bytes.cells[..i + 1]), - value.clone(), - ); - }); - } - - cb.condition(is_less_than_128.expr(), |cb| { - cb.range_lookup(value, 128); - }); - - Self { - bytes, - is_most_significant_byte, - most_significant_byte_is_zero, - is_less_than_128, - } - } - - fn assign( - &self, - region: &mut CachedRegion<'_, '_, F>, - offset: usize, - value: u64, - ) -> Result<(), Error> { - let bytes = value.to_le_bytes(); - let most_significant_byte_index = bytes - .iter() - .rev() - .position(|byte| *byte != 0) - .map(|i| N_BYTES_U64 - i - 1); - self.most_significant_byte_is_zero.assign( - region, - offset, - most_significant_byte_index - .map(|i| u64::from(bytes[i]).into()) - .unwrap_or_default(), - )?; - self.bytes.assign(region, offset, Some(bytes))?; - for i in 0..N_BYTES_U64 { - self.is_most_significant_byte[i].assign( - region, - offset, - Value::known( - (Some(i) == most_significant_byte_index) - .to_scalar() - .unwrap(), - ), - )?; - } - self.is_less_than_128.assign( + let code_hash = keccak256(&values); + self.create.assign( region, offset, - Value::known((value < 128).to_scalar().unwrap()), + call.callee_address, + caller_nonce, + Some(U256::from_big_endian(&code_hash)), + Some(salt), )?; Ok(()) } - - fn value(&self) -> Expression { - from_bytes::expr(&self.bytes.cells) - } - - fn n_bytes_nonce(&self) -> Expression { - sum::expr( - self.is_most_significant_byte - .iter() - .enumerate() - .map(|(i, indicator)| (1 + i).expr() * indicator.expr()), - ) - } - - fn rlp_length(&self) -> Expression { - 1.expr() + not::expr(self.is_less_than_128.expr()) * self.n_bytes_nonce() - } - // fn rlp_rlc(&self, cb: &ConstraintBuilder) -> Expression { - // select::expr( - // and::expr(&[ - // self.is_less_than_128.expr(), - // not::expr(self.most_significant_byte_is_zero.expr()), - // ]), - // self.value(), - // (0x80.expr() + self.n_bytes_nonce()) * self.randomness_raised_n_bytes_nonce(cb) - // + self.bytes.expr(), - // ) - // } - // - // fn randomness_raised_to_rlp_length(&self, cb: &ConstraintBuilder) -> Expression { - // let powers_of_randomness = cb.power_of_randomness(); - // powers_of_randomness[0].clone() - // select::expr( - // self.is_less_than_128.expr(), - // 1.expr(), - // self.randomness_raised_n_bytes_nonce(cb), - // ) - // } - // - // fn randomness_raised_n_bytes_nonce(&self, cb: &ConstraintBuilder) -> Expression { - // let powers_of_randomness = cb.power_of_randomness(); - // select::expr( - // self.most_significant_byte_is_zero.expr(), - // 1.expr(), - // sum::expr( - // self.is_most_significant_byte - // .iter() - // .zip(powers_of_randomness) - // .map(|(indicator, power)| indicator.expr() * power.clone()), - // ), - // ) - // } } #[cfg(test)] @@ -826,8 +587,8 @@ mod test { .cartesian_product(&[true, false]) .cartesian_product(&[true, false]) { - let initialization_code = initialization_bytecode(*is_success); - let root_code = creater_bytecode(initialization_code, *is_create2, *is_persistent); + let init_code = initialization_bytecode(*is_success); + let root_code = creater_bytecode(init_code, *is_create2, *is_persistent); let caller = Account { address: *CALLER_ADDRESS, code: root_code.into(), @@ -854,7 +615,7 @@ mod test { } #[test] - fn test_create_empty_initialization_code() { + fn test_create_empty_init_code() { for is_create2 in [true, false] { let caller = Account { address: *CALLER_ADDRESS, diff --git a/zkevm-circuits/src/evm_circuit/execution/return_revert.rs b/zkevm-circuits/src/evm_circuit/execution/return_revert.rs index 17645f7eb6..c68abfa80d 100644 --- a/zkevm-circuits/src/evm_circuit/execution/return_revert.rs +++ b/zkevm-circuits/src/evm_circuit/execution/return_revert.rs @@ -607,7 +607,7 @@ mod test { bytecode.write_op(OpcodeId::MSTORE); } bytecode.append(&bytecode! { - PUSH3(0x123456) // salt + PUSH3(0x12) // salt PUSH1(initializer.len()) // length PUSH1(0) // offset PUSH1(0) // value diff --git a/zkevm-circuits/src/evm_circuit/step.rs b/zkevm-circuits/src/evm_circuit/step.rs index 7d4f27596e..cb30606df0 100644 --- a/zkevm-circuits/src/evm_circuit/step.rs +++ b/zkevm-circuits/src/evm_circuit/step.rs @@ -76,11 +76,12 @@ pub enum ExecutionState { MSIZE, GAS, JUMPDEST, - PUSH, // PUSH1, PUSH2, ..., PUSH32 - DUP, // DUP1, DUP2, ..., DUP16 - SWAP, // SWAP1, SWAP2, ..., SWAP16 - LOG, // LOG0, LOG1, ..., LOG4 - CREATE, // CREATE, CREATE2 + PUSH, // PUSH1, PUSH2, ..., PUSH32 + DUP, // DUP1, DUP2, ..., DUP16 + SWAP, // SWAP1, SWAP2, ..., SWAP16 + LOG, // LOG0, LOG1, ..., LOG4 + CREATE, + CREATE2, CALL_OP, // CALL, CALLCODE, DELEGATECALL, STATICCALL RETURN_REVERT, // RETURN, REVERT SELFDESTRUCT, diff --git a/zkevm-circuits/src/util.rs b/zkevm-circuits/src/util.rs index e62e34aa8e..5be194497a 100644 --- a/zkevm-circuits/src/util.rs +++ b/zkevm-circuits/src/util.rs @@ -63,9 +63,9 @@ impl MockChallenges { /// .. pub fn construct(_meta: &mut ConstraintSystem) -> Self { Self { - evm_word: 0x10000, - keccak_input: 0x100000, - lookup_input: 0x1000000, + evm_word: 0x100, + keccak_input: 0x100, + lookup_input: 0x100, } } /// .. diff --git a/zkevm-circuits/src/witness/step.rs b/zkevm-circuits/src/witness/step.rs index e2ea4c6b15..285c5db1c4 100644 --- a/zkevm-circuits/src/witness/step.rs +++ b/zkevm-circuits/src/witness/step.rs @@ -189,11 +189,11 @@ impl From<&circuit_input_builder::ExecStep> for ExecutionState { OpcodeId::RETURN | OpcodeId::REVERT => ExecutionState::RETURN_REVERT, OpcodeId::RETURNDATASIZE => ExecutionState::RETURNDATASIZE, OpcodeId::RETURNDATACOPY => ExecutionState::RETURNDATACOPY, - OpcodeId::CREATE | OpcodeId::CREATE2 => ExecutionState::CREATE, + OpcodeId::CREATE => ExecutionState::CREATE, + OpcodeId::CREATE2 => ExecutionState::CREATE2, OpcodeId::EXTCODECOPY => ExecutionState::EXTCODECOPY, // dummy ops OpcodeId::SELFDESTRUCT => dummy!(ExecutionState::SELFDESTRUCT), - OpcodeId::INVALID(_) => ExecutionState::ErrorInvalidOpcode, _ => unimplemented!("unimplemented opcode {:?}", op), } }