diff --git a/bus-mapping/src/circuit_input_builder/execution.rs b/bus-mapping/src/circuit_input_builder/execution.rs index 875e5b936f..e7e101be3f 100644 --- a/bus-mapping/src/circuit_input_builder/execution.rs +++ b/bus-mapping/src/circuit_input_builder/execution.rs @@ -158,15 +158,17 @@ pub enum CopyDataType { /// When the source for the copy event is the bytecode table. Bytecode = 1, /// When the source/destination for the copy event is memory. - Memory, + Memory = 2, /// When the source for the copy event is tx's calldata. - TxCalldata, + TxCalldata = 3, /// When the destination for the copy event is tx's log. - TxLog, + TxLog = 4, + /// + SHA3 = 5, /// When the destination rows are not directly for copying but for a special /// scenario where we wish to accumulate the value (RLC) over all rows. /// This is used for Copy Lookup from SHA3 opcode verification. - RlcAcc, + RlcAcc = 6, } impl From for usize { @@ -252,10 +254,10 @@ impl CopyEvent { .checked_sub(self.src_addr) .unwrap_or_default(), ), - CopyDataType::RlcAcc | CopyDataType::TxLog => unreachable!(), + CopyDataType::RlcAcc | CopyDataType::TxLog | CopyDataType::SHA3 => unreachable!(), }; let destination_rw_increase = match self.dst_type { - CopyDataType::RlcAcc | CopyDataType::Bytecode => 0, + CopyDataType::RlcAcc | CopyDataType::Bytecode | CopyDataType::SHA3 => 0, CopyDataType::TxLog | CopyDataType::Memory => u64::try_from(step_index).unwrap() / 2, CopyDataType::TxCalldata => unreachable!(), }; diff --git a/bus-mapping/src/evm/opcodes/sha3.rs b/bus-mapping/src/evm/opcodes/sha3.rs index d40a55aeb5..136d1de7d9 100644 --- a/bus-mapping/src/evm/opcodes/sha3.rs +++ b/bus-mapping/src/evm/opcodes/sha3.rs @@ -68,8 +68,8 @@ impl Opcode for Sha3 { src_type: CopyDataType::Memory, src_id: NumberOrHash::Number(call_id), dst_addr: 0, - dst_type: CopyDataType::RlcAcc, - dst_id: NumberOrHash::Number(call_id), + dst_type: CopyDataType::SHA3, + dst_id: NumberOrHash::Hash(sha3.into()), log_id: None, rw_counter_start, bytes: steps, diff --git a/circuit-benchmarks/src/lib.rs b/circuit-benchmarks/src/lib.rs index c6238d95d3..d0084f3732 100644 --- a/circuit-benchmarks/src/lib.rs +++ b/circuit-benchmarks/src/lib.rs @@ -16,14 +16,6 @@ pub mod tx_circuit; #[cfg(feature = "benches")] pub mod super_circuit; -#[cfg(test)] -#[cfg(feature = "benches")] -pub mod bit_keccak; - -#[cfg(test)] -#[cfg(feature = "benches")] -pub mod packed_keccak; - #[cfg(test)] #[cfg(feature = "benches")] pub mod packed_multi_keccak; diff --git a/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs b/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs index 895efef532..96981752e7 100644 --- a/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs +++ b/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs @@ -2,7 +2,7 @@ use crate::{ evm_circuit::util::{ and, constraint_builder::BaseConstraintBuilder, not, or, select, RandomLinearCombination, }, - table::{BytecodeFieldTag, BytecodeTable, DynamicTableColumns, KeccakTable}, + table::{BytecodeFieldTag, BytecodeTable, KeccakTable}, util::{Challenges, Expr}, }; use bus_mapping::evm::OpcodeId; @@ -16,6 +16,7 @@ use halo2_proofs::{ }, poly::Rotation, }; +use itertools::zip; use keccak256::plain::Keccak; use std::vec; @@ -349,15 +350,20 @@ impl Config { meta.query_advice(is_final, Rotation::cur()), not::expr(meta.query_advice(padding, Rotation::cur())), ]); - let lookup_columns = vec![hash_input_rlc, code_length, bytecode_table.code_hash]; + let lookup_input_columns = vec![hash_input_rlc, code_length, bytecode_table.code_hash]; + let lookup_table_columns = vec![ + keccak_table.input_rlc, + keccak_table.input_len, + keccak_table.output_rlc, + ]; let mut constraints = vec![( enable.clone(), meta.query_advice(keccak_table.is_enabled, Rotation::cur()), )]; - for (i, column) in keccak_table.columns().iter().skip(1).enumerate() { + for (input_column, table_column) in zip(lookup_input_columns, lookup_table_columns) { constraints.push(( - enable.clone() * meta.query_advice(lookup_columns[i], Rotation::cur()), - meta.query_advice(*column, Rotation::cur()), + enable.clone() * meta.query_advice(input_column, Rotation::cur()), + meta.query_advice(table_column, Rotation::cur()), )) } constraints @@ -793,10 +799,15 @@ mod tests { } /// Tests a circuit with incomplete bytecode + #[ignore = "keccak rows larger than bytecode rows"] #[test] fn bytecode_incomplete() { - let k = 9; - test_bytecode_circuit_unrolled::(k, vec![unroll(vec![7u8; 2usize.pow(k) + 1])], false); + let k = 12; + test_bytecode_circuit_unrolled::( + k - 3, + vec![unroll(vec![7u8; 2usize.pow(k) + 1])], + false, + ); } /// Tests multiple bytecodes in a single circuit diff --git a/zkevm-circuits/src/bytecode_circuit/dev.rs b/zkevm-circuits/src/bytecode_circuit/dev.rs index 6a79d74709..ad5d58a68a 100644 --- a/zkevm-circuits/src/bytecode_circuit/dev.rs +++ b/zkevm-circuits/src/bytecode_circuit/dev.rs @@ -103,6 +103,7 @@ pub fn test_bytecode_circuit_unrolled( bytecodes: Vec>, success: bool, ) { + let k = k + 3; let circuit = BytecodeCircuitTester:: { bytecodes, size: 2usize.pow(k), diff --git a/zkevm-circuits/src/evm_circuit/execution/sha3.rs b/zkevm-circuits/src/evm_circuit/execution/sha3.rs index 2b09155c13..88615ee73b 100644 --- a/zkevm-circuits/src/evm_circuit/execution/sha3.rs +++ b/zkevm-circuits/src/evm_circuit/execution/sha3.rs @@ -52,13 +52,13 @@ impl ExecutionGadget for Sha3Gadget { cb.copy_table_lookup( cb.curr.state.call_id.expr(), CopyDataType::Memory.expr(), - cb.curr.state.call_id.expr(), - CopyDataType::RlcAcc.expr(), + sha3_rlc.expr(), + CopyDataType::SHA3.expr(), memory_address.offset(), memory_address.address(), 0.expr(), // dst_addr for CopyDataType::RlcAcc is 0. memory_address.length(), - rlc_acc.expr(), + 0.expr(), copy_rwc_inc.expr(), ); }); @@ -66,7 +66,7 @@ impl ExecutionGadget for Sha3Gadget { cb.require_zero("copy_rwc_inc == 0 for size = 0", copy_rwc_inc.expr()); cb.require_zero("rlc_acc == 0 for size = 0", rlc_acc.expr()); }); - cb.keccak_table_lookup(rlc_acc.expr(), memory_address.length(), sha3_rlc.expr()); + cb.keccak_table_lookup(sha3_rlc.expr(), sha3_rlc.expr()); let memory_expansion = MemoryExpansionGadget::construct(cb, [memory_address.address()]); let memory_copier_gas = MemoryCopierGasGadget::construct( @@ -167,7 +167,7 @@ mod tests { TestContext::<2, 1>::simple_ctx_with_bytecode(code).unwrap(), None, CircuitsParams { - max_rws: 5500, + max_rws: 11000, ..Default::default() } ), diff --git a/zkevm-circuits/src/evm_circuit/table.rs b/zkevm-circuits/src/evm_circuit/table.rs index 222b4dbf40..e8cf8b7c6c 100644 --- a/zkevm-circuits/src/evm_circuit/table.rs +++ b/zkevm-circuits/src/evm_circuit/table.rs @@ -260,9 +260,9 @@ pub(crate) enum Lookup { /// Lookup to keccak table. KeccakTable { /// Accumulator to the input. - input_rlc: Expression, + hash_id: Expression, /// Length of input that is being hashed. - input_len: Expression, + //input_len: Expression, /// Output (hash) until this state. This is the RLC representation of /// the final output keccak256 hash of the input. output_rlc: Expression, @@ -381,14 +381,16 @@ impl Lookup { rwc_inc.clone(), ], Self::KeccakTable { - input_rlc, - input_len, + hash_id, output_rlc, } => vec![ 1.expr(), // is_enabled - input_rlc.clone(), - input_len.clone(), + //input_rlc.clone(), + //input_len.clone(), output_rlc.clone(), + hash_id.clone(), + //0.expr(), // byte_value + //0.expr(), // bytes_left ], Self::ExpTable { identifier, diff --git a/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs b/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs index 7494606514..359fbfaed8 100644 --- a/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs +++ b/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs @@ -1214,15 +1214,13 @@ impl<'a, F: Field> ConstraintBuilder<'a, F> { pub(crate) fn keccak_table_lookup( &mut self, - input_rlc: Expression, - input_len: Expression, + hash_id: Expression, output_rlc: Expression, ) { self.add_lookup( "keccak lookup", Lookup::KeccakTable { - input_rlc, - input_len, + hash_id, output_rlc, }, ); diff --git a/zkevm-circuits/src/keccak_circuit.rs b/zkevm-circuits/src/keccak_circuit.rs index 832997c23b..2bed937cb9 100644 --- a/zkevm-circuits/src/keccak_circuit.rs +++ b/zkevm-circuits/src/keccak_circuit.rs @@ -1,9 +1,9 @@ //! The keccak circuit implementation. /// Keccak bit -pub mod keccak_bit; +//pub mod keccak_bit; /// Keccak packed -pub mod keccak_packed; +//pub mod keccak_packed; /// Keccak packed multi pub mod keccak_packed_multi; /// Util diff --git a/zkevm-circuits/src/keccak_circuit/keccak_packed_multi.rs b/zkevm-circuits/src/keccak_circuit/keccak_packed_multi.rs index afaeee9808..33bd378fef 100644 --- a/zkevm-circuits/src/keccak_circuit/keccak_packed_multi.rs +++ b/zkevm-circuits/src/keccak_circuit/keccak_packed_multi.rs @@ -20,9 +20,10 @@ use halo2_proofs::{ poly::Rotation, }; use log::{debug, info}; -use std::{env::var, marker::PhantomData, vec}; +use std::env::var; +use std::{marker::PhantomData, vec}; -const MAX_DEGREE: usize = 3; +const MAX_DEGREE: usize = 4; const ABSORB_LOOKUP_RANGE: usize = 3; const THETA_C_LOOKUP_RANGE: usize = 6; const RHO_PI_LOOKUP_RANGE: usize = 4; @@ -30,7 +31,7 @@ const CHI_BASE_LOOKUP_RANGE: usize = 5; fn get_num_rows_per_round() -> usize { var("KECCAK_ROWS") - .unwrap_or_else(|_| "5".to_string()) + .unwrap_or_else(|_| "25".to_string()) .parse() .expect("Cannot parse KECCAK_ROWS env var as usize") } @@ -69,6 +70,7 @@ pub(crate) struct SqueezeData { #[derive(Clone, Debug, PartialEq)] pub(crate) struct KeccakRow { q_enable: bool, + q_enable_row: bool, q_round: bool, q_absorb: bool, q_round_last: bool, @@ -80,6 +82,9 @@ pub(crate) struct KeccakRow { length: usize, data_rlc: F, hash_rlc: F, + bytes_left: F, // from len to 1 + hash_id: F, // 0 when first row, then 1,2,3,.. + value: F, // byte } /// Part @@ -314,7 +319,14 @@ impl CellManager { /// KeccakConfig #[derive(Clone, Debug)] pub struct KeccakPackedConfig { + // q_enable only on the first row of valid rounds, + // while q_enable_row on every row of valid rounds + // q_enable_row can be optimzied out using expression like + // (1..get_num_rows_per_round() as i32).map(|i| meta.query_fixed(q_enable, + // Rotation(-i))).fold(0.expr(), |acc, elem| acc + elem), now we keep it here to make codes + // easier to read q_enable: Column, + q_enable_row: Column, q_first: Column, q_round: Column, q_absorb: Column, @@ -780,6 +792,7 @@ mod transform_to { impl KeccakPackedConfig { pub(crate) fn configure(meta: &mut ConstraintSystem, r: Expression) -> Self { let q_enable = meta.fixed_column(); + let q_enable_row = meta.fixed_column(); let q_first = meta.fixed_column(); let q_round = meta.fixed_column(); let q_absorb = meta.fixed_column(); @@ -1320,6 +1333,158 @@ impl KeccakPackedConfig { cb.gate(meta.query_fixed(q_first, Rotation::cur())) }); + // some utility query functions + let q = |col: Column, meta: &mut VirtualCells<'_, F>| { + meta.query_fixed(col, Rotation::cur()) + }; + let q_in_round = |col: Column, meta: &mut VirtualCells<'_, F>| { + (0..get_num_rows_per_round() as i32) + .map(|i| meta.query_fixed(col, Rotation(-i))) + .fold(0.expr(), |acc, elem| acc + elem) + }; + let q_prev_round = |col: Column, meta: &mut VirtualCells<'_, F>| { + meta.query_fixed(col, Rotation(-(get_num_rows_per_round() as i32))) + }; + /* + eg： + data: + get_num_rows_per_round: 18 + input: "12345678abc" + + table: + Note[1]: be careful: is_paddings is not column here! It is [Cell; 8]. + + offset value bytes_left is_paddings q_enable q_padding_last + 18 1 11 0 1 0 // 1st round begin + 19 2 10 0 0 0 + 20 3 9 0 0 0 + 21 4 8 0 0 0 + 22 5 7 0 0 0 + 23 6 6 0 0 0 + 24 7 5 0 0 0 + 25 8 4 0 0 0 + 26 8 4 NA 0 0 + ... + 35 8 4 NA 0 0 // 1st round end + 36 a 3 0 1 1 // 2nd round begin + 37 b 2 0 0 0 + 38 c 1 0 0 0 + 39 0 0 1 0 0 + 40 0 0 1 0 0 + 41 0 0 1 0 0 + 42 0 0 1 0 0 + 43 0 0 1 0 0 + + */ + + meta.create_gate("hash_id", |meta| { + let mut cb = BaseConstraintBuilder::new(MAX_DEGREE); + + cb.condition(q_in_round(q_first, meta), |cb| { + cb.require_zero( + "hash_id needs to be zero on the first row", + meta.query_advice(keccak_table.hash_id, Rotation::cur()), + ); + }); + cb.condition( + (q(q_enable, meta) - q(q_first, meta)) + * meta.query_advice(is_final, Rotation::cur()), + |cb| { + let hash_id = meta.query_advice(keccak_table.hash_id, Rotation::cur()); + let hash_rlc = meta.query_advice(hash_rlc, Rotation::cur()); + cb.require_equal("hash_id == hash_output", hash_rlc, hash_id); + }, + ); + cb.condition( + q_in_round(q_enable, meta) + - q_in_round(q_first, meta) + - q(q_enable, meta) * q_prev_round(q_absorb, meta), + |cb| { + let counter = meta.query_advice(keccak_table.hash_id, Rotation::cur()); + let counter_prev = meta.query_advice(keccak_table.hash_id, Rotation::prev()); + cb.require_equal( + "hash_id keeps same when no new hash input", + counter_prev, + counter, + ); + }, + ); + cb.gate(1.expr()) + }); + meta.create_gate("byte_value", |meta| { + let mut cb = BaseConstraintBuilder::new(MAX_DEGREE); + for idx in 0..get_num_rows_per_round() { + cb.condition( + q(q_padding, meta) * not::expr(is_paddings[std::cmp::min(idx, 7)].expr()), + |cb| { + cb.require_equal( + "input byte", + input_bytes[std::cmp::min(idx, 7)].expr.clone(), + meta.query_advice(keccak_table.byte_value, Rotation(idx as i32)), + ); + }, + ); + } + cb.gate(q(q_enable, meta)) + }); + meta.create_gate("bytes_left", |meta| { + let mut cb = BaseConstraintBuilder::new(MAX_DEGREE); + // TODO: is this needed? + cb.condition(q_in_round(q_first, meta), |cb| { + cb.require_zero( + "bytes_left needs to be zero on the first row", + meta.query_advice(keccak_table.bytes_left, Rotation::cur()), + ); + }); + // is_paddings only be true when + cb.condition(q(q_padding, meta), |cb| { + for i in 0..get_num_rows_per_round() { + let bytes_left = meta.query_advice(keccak_table.bytes_left, Rotation(i as i32)); + let bytes_left_next = + meta.query_advice(keccak_table.bytes_left, Rotation(i as i32 + 1)); + // real input only when !is_paddings[i] && i < 8 + cb.require_equal( + "if not padding, bytes_left decreases by 1, else, stay same", + bytes_left_next, + bytes_left.clone() + - if i < 7 || i == get_num_rows_per_round() - 1 { + not::expr(is_paddings[std::cmp::min(i, 7)].expr()) + } else { + 0.expr() + }, + ); + cb.require_zero( + "bytes_left should be 0 when padding", + bytes_left * is_paddings[std::cmp::min(i, 7)].expr(), + ); + } + }); + cb.condition( + (q_in_round(q_enable, meta) + - q_in_round(q_padding, meta) + - q_in_round(q_first, meta)) + * meta.query_advice(is_final, Rotation::next()), + |cb| { + let bytes_left = meta.query_advice(keccak_table.bytes_left, Rotation::cur()); + let bytes_left_next = + meta.query_advice(keccak_table.bytes_left, Rotation::next()); + cb.require_equal( + "bytes_left should stay same on non absorb round", + bytes_left, + bytes_left_next, + ); + }, + ); + cb.condition( + q(q_enable, meta) * meta.query_advice(is_final, Rotation::cur()), + |cb| { + let bytes_left = meta.query_advice(keccak_table.bytes_left, Rotation::cur()); + cb.require_zero("bytes_left should be 0 when is_final", bytes_left); + }, + ); + cb.gate(1.expr()) + }); + // Enforce logic for when this block is the last block for a hash let last_is_padding_in_block = is_paddings.last().unwrap().at_offset( meta, @@ -1536,6 +1701,7 @@ impl KeccakPackedConfig { KeccakPackedConfig { q_enable, + q_enable_row, q_first, q_round, q_absorb, @@ -1621,6 +1787,9 @@ impl KeccakPackedConfig { row.data_rlc, F::from(row.length as u64), row.hash_rlc, + row.hash_id, + row.value, + row.bytes_left, ], )?; @@ -1679,6 +1848,9 @@ fn keccak(rows: &mut Vec>, bytes: &[u8], r: F) { } bits.push(1); + let mut hash_out: [u8; 32] = ethers_core::utils::keccak256(bytes); + hash_out.reverse(); + let hash_id = rlc::value(&hash_out, r); let mut length = 0usize; let mut data_rlc = F::zero(); let chunks = bits.chunks(RATE_IN_BITS); @@ -1953,6 +2125,7 @@ fn keccak(rows: &mut Vec>, bytes: &[u8], r: F) { .flat_map(|a| to_bytes::value(&unpack(a[0]))) .rev() .collect::>(); + debug_assert_eq!(hash_bytes_le, hash_out.to_vec()); rlc::value(&hash_bytes_le, r) } else { F::zero() @@ -1986,8 +2159,25 @@ fn keccak(rows: &mut Vec>, bytes: &[u8], r: F) { for round in 0..NUM_ROUNDS + 1 { let round_cst = pack_u64(ROUND_CST[round]); for row_idx in 0..get_num_rows_per_round() { + let byte_idx = if round < NUM_WORDS_TO_ABSORB { + round * 8 + std::cmp::min(row_idx, 7) + } else { + NUM_WORDS_TO_ABSORB * 8 + } + idx * NUM_WORDS_TO_ABSORB * 8; + + let byte = if byte_idx >= bytes.len() { + 0 + } else { + bytes[byte_idx] + }; + let bytes_left = if byte_idx >= bytes.len() { + 0 + } else { + bytes.len() - byte_idx + }; rows.push(KeccakRow { q_enable: row_idx == 0, + q_enable_row: true, q_round: row_idx == 0 && round < NUM_ROUNDS, q_absorb: row_idx == 0 && round == NUM_ROUNDS, q_round_last: row_idx == 0 && round == NUM_ROUNDS, @@ -1999,9 +2189,25 @@ fn keccak(rows: &mut Vec>, bytes: &[u8], r: F) { data_rlc: round_data_rlcs[round], hash_rlc, cell_values: regions[round].rows[row_idx].clone(), + value: F::from_u128(byte as u128), + // from len to 1 + bytes_left: F::from_u128(bytes_left as u128), + hash_id, }); + { + let mut r = rows.last().unwrap().clone(); + r.cell_values.clear(); + log::trace!( + "offset {:?} row idx {} row {:?}", + rows.len() - 1, + row_idx, + r + ); + } } + log::trace!(" = = = = = = round {} end", round); } + log::trace!(" ====================== chunk {} end", idx); } let hash_bytes = s @@ -2031,6 +2237,7 @@ fn multi_keccak( for idx in 0..get_num_rows_per_round() { rows.push(KeccakRow { q_enable: idx == 0, + q_enable_row: true, q_round: false, q_absorb: idx == 0, q_round_last: false, @@ -2042,10 +2249,13 @@ fn multi_keccak( data_rlc: F::zero(), hash_rlc: F::zero(), cell_values: Vec::new(), + hash_id: F::zero(), + value: F::zero(), + bytes_left: F::zero(), }); } // Actual keccaks - for bytes in bytes { + for bytes in bytes.iter() { keccak(&mut rows, bytes, r); } if let Some(capacity) = capacity { @@ -2084,7 +2294,7 @@ mod tests { #[test] fn packed_multi_keccak_simple() { - let k = 11; + let k = 14; let inputs = vec![ vec![], (0u8..1).collect::>(), diff --git a/zkevm-circuits/src/super_circuit.rs b/zkevm-circuits/src/super_circuit.rs index 373db3287d..c233930670 100644 --- a/zkevm-circuits/src/super_circuit.rs +++ b/zkevm-circuits/src/super_circuit.rs @@ -64,17 +64,20 @@ use crate::table::{BlockTable, BytecodeTable, CopyTable, ExpTable, MptTable, RwT use crate::tx_circuit::{TxCircuit, TxCircuitConfig}; use crate::util::Challenges; use crate::witness::{block_convert, Block, MptUpdates}; +use bus_mapping::circuit_input_builder::CopyDataType; use bus_mapping::circuit_input_builder::{CircuitInputBuilder, CircuitsParams}; use bus_mapping::mock::BlockData; use eth_types::geth_types::{self, GethData, Transaction}; use eth_types::Field; use ethers_core::types::H256; +use gadgets::util::not; use halo2_proofs::arithmetic::CurveAffine; use halo2_proofs::halo2curves::{ bn256::Fr, group::{Curve, Group}, secp256k1::Secp256k1Affine, }; +use halo2_proofs::poly::Rotation; use halo2_proofs::{ circuit::{Layouter, SimpleFloorPlanner, Value}, plonk::{Circuit, ConstraintSystem, Error, Expression}, @@ -202,6 +205,39 @@ impl keccak circuit + meta.lookup_any("copy<->keccak", |meta| { + let input_enabled = meta.query_fixed(copy_circuit.q_enable, Rotation::cur()) + * not::expr(meta.query_selector(copy_circuit.q_step)) + * copy_table + .tag + .value_equals(CopyDataType::SHA3, Rotation::cur())(meta); + + vec![ + ( + input_enabled.clone() * meta.query_advice(copy_table.id, Rotation::cur()), + meta.query_advice(keccak_table.hash_id, Rotation::cur()), + ), + ( + input_enabled.clone() + * meta.query_advice(copy_table.bytes_left, Rotation::cur()), + meta.query_advice(keccak_table.bytes_left, Rotation::cur()), + ), + ( + input_enabled * meta.query_advice(copy_circuit.value, Rotation::cur()), + meta.query_advice(keccak_table.byte_value, Rotation::cur()), + ), + ] + }); Self::Config { tx_table: tx_table.clone(), @@ -213,15 +249,7 @@ impl::build(block, &mut ChaCha20Rng::seed_from_u64(2)) .unwrap(); + println!("k is {}", k); let prover = MockProver::run(k, &circuit, instance).unwrap(); let res = prover.verify_par(); if let Err(err) = res { diff --git a/zkevm-circuits/src/table.rs b/zkevm-circuits/src/table.rs index c8b9a55683..879148d190 100644 --- a/zkevm-circuits/src/table.rs +++ b/zkevm-circuits/src/table.rs @@ -733,6 +733,12 @@ pub struct KeccakTable { pub input_len: Column, /// RLC of the hash result pub output_rlc: Column, // RLC of hash of input bytes + /// .. + pub hash_id: Column, + /// .. + pub byte_value: Column, + /// .. + pub bytes_left: Column, } impl KeccakTable { @@ -743,14 +749,29 @@ impl KeccakTable { input_rlc: meta.advice_column_in(SecondPhase), input_len: meta.advice_column(), output_rlc: meta.advice_column_in(SecondPhase), + hash_id: meta.advice_column(), + byte_value: meta.advice_column(), + bytes_left: meta.advice_column(), } } + fn all_columns(&self) -> Vec> { + vec![ + self.is_enabled, + self.input_rlc, + self.input_len, + self.output_rlc, + self.hash_id, + self.byte_value, + self.bytes_left, + ] + } + /// Generate the keccak table assignments from a byte array input. pub fn assignments( input: &[u8], challenges: &Challenges>, - ) -> Vec<[Value; 4]> { + ) -> Vec<[Value; 7]> { let input_rlc = challenges .keccak_input() .map(|challenge| rlc::value(input.iter().rev(), challenge)); @@ -765,12 +786,32 @@ impl KeccakTable { ) }); - vec![[ + let mut assignments = Vec::new(); + // used for "id based keccak". the input part of keccak circuit + for (idx, byte) in input.iter().enumerate() { + assignments.push([ + Value::known(F::zero()), // is_final + Value::known(F::zero()), // place holder + Value::known(F::zero()), // place holder + Value::known(F::zero()), // place holder + output_rlc, + Value::known(F::from_u128(*byte as u128)), + Value::known(F::from_u128((input.len() - idx) as u128)), + ]); + } + // used for "rlc based keccak". the output part of keccak circuit + let final_row = [ Value::known(F::one()), input_rlc, Value::known(input_len), output_rlc, - ]] + output_rlc, // place holder + Value::known(F::zero()), // place holder + Value::known(F::zero()), // place holder + ]; + //println!("final row {:?}", final_row); + assignments.push(final_row); + assignments } /// Assign a table row for keccak table @@ -778,9 +819,10 @@ impl KeccakTable { &self, region: &mut Region, offset: usize, - values: [F; 4], + values: [F; 7], ) -> Result<(), Error> { - for (column, value) in self.columns().iter().zip(values.iter()) { + //println!("keccak table assign row {:?}", values); + for (column, value) in self.all_columns().iter().zip_eq(values.iter()) { region.assign_advice( || format!("assign {}", offset), *column, @@ -803,7 +845,7 @@ impl KeccakTable { || "keccak table", |mut region| { let mut offset = 0; - for column in self.columns() { + for column in self.all_columns() { region.assign_advice( || "keccak table all-zero row", column, @@ -813,7 +855,7 @@ impl KeccakTable { } offset += 1; - let keccak_table_columns = self.columns(); + let keccak_table_columns = self.all_columns(); for input in inputs.clone() { for row in Self::assignments(input, challenges) { // let mut column_index = 0; @@ -835,12 +877,16 @@ impl KeccakTable { } impl DynamicTableColumns for KeccakTable { + // only used in evm circuit fn columns(&self) -> Vec> { vec![ self.is_enabled, - self.input_rlc, - self.input_len, + //self.input_rlc, + //self.input_len, self.output_rlc, + self.hash_id, + //self.byte_value, + //self.bytes_left, ] } }