scroll-tech · DreamWuGit · Sep 20, 2023 · Sep 21, 2023 · Sep 24, 2023 · Sep 25, 2023
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/aggregator/src/core.rs b/aggregator/src/core.rs
@@ -284,7 +284,8 @@ pub(crate) fn extract_hash_cells(
                     keccak_packed_multi::get_input_bytes_col_idx_in_cell_manager()
                         + <KeccakTable as LookupTable<Fr>>::columns(&keccak_config.keccak_table)
                             .len()
-                        - 1;
+                        - 1
+                        - 2; // exclude last word limbs' columns
                 for (offset, keccak_row) in witness.iter().enumerate() {
                     let row = keccak_config.set_row(&mut region, offset, keccak_row)?;
 

diff --git a/eth-types/src/evm_types/opcode_ids.rs b/eth-types/src/evm_types/opcode_ids.rs
@@ -1240,8 +1240,11 @@ impl FromStr for OpcodeId {
             "BASEFEE" => OpcodeId::BASEFEE,
             #[cfg(feature = "scroll")]
             "BASEFEE" => OpcodeId::INVALID(0x48),
-            "TLOAD" => OpcodeId::INVALID(0xb3),
-            "TSTORE" => OpcodeId::INVALID(0xb4),
+            "BLOBHASH" => OpcodeId::INVALID(0x49),
+            "BLOBBASEFEE" => OpcodeId::INVALID(0x4a),
+            "TLOAD" => OpcodeId::INVALID(0x5c),
+            "TSTORE" => OpcodeId::INVALID(0x5d),
+            "MCOPY" => OpcodeId::INVALID(0x5e),
             _ => {
                 // Parse an invalid opcode value as reported by geth
                 static RE: LazyLock<Regex> = LazyLock::new(|| {

diff --git a/gadgets/src/comparator.rs b/gadgets/src/comparator.rs
@@ -4,7 +4,7 @@
 use eth_types::Field;
 use halo2_proofs::{
     circuit::{Chip, Region, Value},
-    plonk::{ConstraintSystem, Error, Expression, TableColumn, VirtualCells},
+    plonk::{Column, ConstraintSystem, Error, Expression, Fixed, VirtualCells},
     poly::Rotation,
 };
 
@@ -64,7 +64,7 @@ impl<F: Field, const N_BYTES: usize> ComparatorChip<F, N_BYTES> {
         q_enable: impl FnOnce(&mut VirtualCells<F>) -> Expression<F> + Clone,
         lhs: impl FnOnce(&mut VirtualCells<F>) -> Expression<F> + Clone,
         rhs: impl FnOnce(&mut VirtualCells<F>) -> Expression<F> + Clone,
-        u8_table: TableColumn,
+        u8_table: Column<Fixed>,
     ) -> ComparatorConfig<F, N_BYTES> {
         let lt_config =
             LtChip::configure(meta, q_enable.clone(), lhs.clone(), rhs.clone(), u8_table);

diff --git a/gadgets/src/less_than.rs b/gadgets/src/less_than.rs
@@ -3,7 +3,7 @@
 use eth_types::Field;
 use halo2_proofs::{
     circuit::{Chip, Region, Value},
-    plonk::{Advice, Column, ConstraintSystem, Error, Expression, TableColumn, VirtualCells},
+    plonk::{Advice, Column, ConstraintSystem, Error, Expression, Fixed, VirtualCells},
     poly::Rotation,
 };
 
@@ -37,7 +37,9 @@ pub struct LtConfig<F, const N_BYTES: usize> {
     /// Denotes the bytes representation of the difference between lhs and rhs.
     pub diff: [Column<Advice>; N_BYTES],
     /// Denotes the range within which each byte should lie.
-    pub u8_table: TableColumn,
+    //pub u8_table: TableColumn,
+    pub u8_table: Column<Fixed>,
+
     /// Denotes the range within which both lhs and rhs lie.
     pub range: F,
 }
@@ -68,7 +70,8 @@ impl<F: Field, const N_BYTES: usize> LtChip<F, N_BYTES> {
         q_enable: impl FnOnce(&mut VirtualCells<'_, F>) -> Expression<F> + Clone,
         lhs: impl FnOnce(&mut VirtualCells<F>) -> Expression<F>,
         rhs: impl FnOnce(&mut VirtualCells<F>) -> Expression<F>,
-        u8_table: TableColumn,
+        //u8_table: TableColumn,
+        u8_table: Column<Fixed>,
     ) -> LtConfig<F, N_BYTES> {
         let lt = meta.advice_column();
         let diff = [(); N_BYTES].map(|_| meta.advice_column());
@@ -94,11 +97,11 @@ impl<F: Field, const N_BYTES: usize> LtChip<F, N_BYTES> {
         });
 
         for cell_column in diff {
-            meta.lookup("range check for u8", |meta| {
+            meta.lookup_any("range check for u8", |meta| {
                 let q_enable = q_enable.clone()(meta);
                 vec![(
                     q_enable * meta.query_advice(cell_column, Rotation::cur()),
-                    u8_table,
+                    meta.query_fixed(u8_table, Rotation::cur()),
                 )]
             });
         }
@@ -156,11 +159,12 @@ impl<F: Field, const N_BYTES: usize> LtInstruction<F> for LtChip<F, N_BYTES> {
     ) -> Result<(), Error> {
         const RANGE: usize = u8::MAX as usize;
 
-        layouter.assign_table(
+        //layouter.assign_table(
+        layouter.assign_region(
             || "load u8 range check table",
-            |mut table| {
+            |mut region| {
                 for i in 0..=RANGE {
-                    table.assign_cell(
+                    region.assign_fixed(
                         || "assign cell in fixed column",
                         self.config.u8_table,
                         i,
@@ -265,7 +269,7 @@ mod test {
                 let q_enable = meta.complex_selector();
                 let value = meta.advice_column();
                 let check = meta.advice_column();
-                let u8_table = meta.lookup_table_column();
+                let u8_table = meta.fixed_column();
 
                 let lt = LtChip::configure(
                     meta,
@@ -389,7 +393,7 @@ mod test {
                 let q_enable = meta.complex_selector();
                 let (value_a, value_b) = (meta.advice_column(), meta.advice_column());
                 let check = meta.advice_column();
-                let u16_table = meta.lookup_table_column();
+                let u16_table = meta.fixed_column();
 
                 let lt = LtChip::configure(
                     meta,

diff --git a/gadgets/src/mul_add.rs b/gadgets/src/mul_add.rs
@@ -19,7 +19,7 @@
 use eth_types::{Field, Word, ToU16LittleEndian};
 use halo2_proofs::{
     circuit::{Region, Value},
-    plonk::{Advice, Column, ConstraintSystem, Error, Expression, TableColumn, VirtualCells},
+    plonk::{Advice, Column, ConstraintSystem, Error, Expression, Fixed, VirtualCells},
     poly::Rotation,
 };
 
@@ -46,7 +46,8 @@ pub struct MulAddConfig<F> {
     /// Sum of the parts higher than 256-bit in the product.
     pub overflow: Expression<F>,
     /// Lookup table for LtChips and carry_lo/hi.
-    pub u16_table: TableColumn,
+    // pub u16_table: TableColumn,
+    pub u16_table: Column<Fixed>,
     /// Range check of a, b which needs to be in [0, 2^64)
     pub range_check_64: UIntRangeCheckChip<F, { UIntRangeCheckChip::SIZE_U64 }, 8>,
     /// Range check of c, d which needs to be in [0, 2^128)
@@ -118,7 +119,8 @@ impl<F: Field> MulAddChip<F> {
     pub fn configure(
         meta: &mut ConstraintSystem<F>,
         q_enable: impl FnOnce(&mut VirtualCells<'_, F>) -> Expression<F> + Clone,
-        u16_table: TableColumn,
+        //u16_table: TableColumn,
+        u16_table: Column<Fixed>,
     ) -> MulAddConfig<F> {
         let col0 = meta.advice_column();
         let col1 = meta.advice_column();
@@ -157,9 +159,10 @@ impl<F: Field> MulAddChip<F> {
             carry_cols.append(&mut carry_hi_cols.clone());
 
             for (col, rot) in carry_cols.into_iter() {
-                meta.lookup("mul carry range check lo/hi lookup u16", |meta| {
+                meta.lookup_any("mul carry range check lo/hi lookup u16", |meta| {
                     let q_enable = q_enable.clone()(meta);
-                    vec![(q_enable * meta.query_advice(col, Rotation(rot)), u16_table)]
+                    let u16_expr = meta.query_fixed(u16_table, Rotation::cur());
+                    vec![(q_enable * meta.query_advice(col, Rotation(rot)), u16_expr)]
                 });
             }
         }
@@ -506,7 +509,8 @@ mod test {
 
             fn configure(meta: &mut halo2_proofs::plonk::ConstraintSystem<F>) -> Self::Config {
                 let q_enable = meta.complex_selector();
-                let u16_table = meta.lookup_table_column();
+                //let u16_table = meta.lookup_table_column();
+                let u16_table = meta.fixed_column();
                 let mul_config =
                     MulAddChip::configure(meta, |meta| meta.query_selector(q_enable), u16_table);
                 Self::Config {
@@ -522,11 +526,12 @@ mod test {
             ) -> Result<(), halo2_proofs::plonk::Error> {
                 let chip = MulAddChip::construct(config.mul_config);
 
-                layouter.assign_table(
+                //layouter.assign_table(
+                layouter.assign_region(
                     || "u16 table",
-                    |mut table| {
+                    |mut region| {
                         for i in 0..=65535 {
-                            table.assign_cell(
+                            region.assign_fixed(
                                 || format!("u16 table row {i}"),
                                 chip.config.u16_table,
                                 i,

diff --git a/gadgets/src/range.rs b/gadgets/src/range.rs
@@ -10,7 +10,7 @@ use crate::util::Expr;
 use eth_types::Field;
 use halo2_proofs::{
     circuit::{Chip, Region, Value},
-    plonk::{Advice, Column, ConstraintSystem, Error, Expression, TableColumn, VirtualCells},
+    plonk::{Advice, Column, ConstraintSystem, Error, Expression, Fixed, VirtualCells},
     poly::Rotation,
 };
 
@@ -36,7 +36,8 @@ pub struct UIntRangeCheckConfig<F, const N_2BYTE: usize, const N_EXPR: usize> {
     /// Denotes the little-endian representation of expression in u16.
     pub u16_repr: [Column<Advice>; N_2BYTE],
     /// Denotes the u16 lookup table.
-    pub u16_table: TableColumn,
+    //pub u16_table: TableColumn,
+    pub u16_table: Column<Fixed>,
     _marker: std::marker::PhantomData<F>,
 }
 
@@ -61,7 +62,8 @@ impl<F: Field, const N_2BYTE: usize, const N_EXPR: usize> UIntRangeCheckChip<F,
         meta: &mut ConstraintSystem<F>,
         q_enable: impl FnOnce(&mut VirtualCells<F>) -> Expression<F> + Clone,
         expressions: impl FnOnce(&mut VirtualCells<F>) -> [Expression<F>; N_EXPR],
-        u16_table: TableColumn,
+        //u16_table: TableColumn,
+        u16_table: Column<Fixed>,
     ) -> UIntRangeCheckConfig<F, N_2BYTE, N_EXPR> {
         let u16_repr = [(); N_2BYTE].map(|_| meta.advice_column());
 
@@ -83,9 +85,10 @@ impl<F: Field, const N_2BYTE: usize, const N_EXPR: usize> UIntRangeCheckChip<F,
         });
 
         for column in u16_repr {
-            meta.lookup(concat!("u16 cell range check"), |meta| {
+            meta.lookup_any(concat!("u16 cell range check"), |meta| {
                 let cell = meta.query_advice(column, Rotation::cur());
-                vec![(cell, u16_table)]
+                let u16_expr = meta.query_fixed(u16_table, Rotation::cur());
+                vec![(cell, u16_expr)]
             });
         }
 

diff --git a/testool/Config.toml b/testool/Config.toml
@@ -202,10 +202,10 @@ paths = [
 [[skip_paths]]
 desc = "too big"
 paths = [
-#    "stTimeConsuming", # full of useless sstore tests
+    "stTimeConsuming", # full of useless sstore tests
 #    "stExample",
 #    "stQuadraticComplexityTest",
-#    "50000"
+    "50000"
 ]
 
 [[skip_paths]]

diff --git a/testool/src/statetest/yaml.rs b/testool/src/statetest/yaml.rs
@@ -771,6 +771,7 @@ arith:
         run_test(t1, TestSuite::default(), CircuitsConfig::default())?;
         Ok(())
     }
+
     #[test]
     fn test_result_bad_storage() -> Result<()> {
         let mut tc = YamlStateTestBuilder::new(&Compiler::default()).load_yaml(
@@ -796,6 +797,7 @@ arith:
 
         Ok(())
     }
+
     #[test]
     fn bad_balance() -> Result<()> {
         let mut tc = YamlStateTestBuilder::new(&Compiler::default()).load_yaml(

diff --git a/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs b/zkevm-circuits/src/bytecode_circuit/bytecode_unroller.rs
@@ -1,20 +1,25 @@
-use crate::{table::BytecodeFieldTag, util::get_push_size};
+use crate::{
+    table::BytecodeFieldTag,
+    util::{get_push_size, word::Word},
+};
+use halo2_proofs::circuit::Value;
+
 use bus_mapping::state_db::CodeDB;
-use eth_types::{Field, ToWord, Word, U256};
+use eth_types::{Field, ToWord, U256};
 use std::vec;
 
 /// Public data for the bytecode
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Default)]
 pub(crate) struct BytecodeRow<F: Field> {
-    pub(crate) code_hash: Word,
+    pub(crate) code_hash: Word<Value<F>>,
     pub(crate) tag: F,
     pub(crate) index: F,
     pub(crate) is_code: F,
     pub(crate) value: F,
 }
 
 /// Unrolled bytecode
-#[derive(Clone, Debug, PartialEq, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct UnrolledBytecode<F: Field> {
     pub(crate) bytes: Vec<u8>,
     pub(crate) rows: Vec<BytecodeRow<F>>,
@@ -23,11 +28,15 @@ pub struct UnrolledBytecode<F: Field> {
 /// Get unrolled bytecode from raw bytes
 pub fn unroll<F: Field>(bytes: Vec<u8>) -> UnrolledBytecode<F> {
     let code_hash = CodeDB::hash(&bytes[..]);
-    unroll_with_codehash(code_hash.to_word(), bytes)
+    let code_hash_word = Word::from(code_hash.to_word()).map(Value::known);
+    unroll_with_codehash(code_hash_word, bytes)
 }
 
 /// Get unrolled bytecode from raw bytes and codehash
-pub fn unroll_with_codehash<F: Field>(code_hash: U256, bytes: Vec<u8>) -> UnrolledBytecode<F> {
+pub fn unroll_with_codehash<F: Field>(
+    code_hash: Word<Value<F>>,
+    bytes: Vec<u8>,
+) -> UnrolledBytecode<F> {
     let mut rows = vec![BytecodeRow::<F> {
         code_hash,
         tag: F::from(BytecodeFieldTag::Header as u64),