[MPT] Misc refactoring (#972)

Some refactoring which I believe decreases code duplication and
increases code readability.

Some TODOs:
- [x] The code required to get the previous rlc/mult data or the
inclusion in the parent check is quite complicated because of the
different node types. Instead it may be better to use a fixed location
to store this data in so a node can simply use this data directly
instead of having to figure out on its own where to find the data. This
is cleaner because this way each node can decide on its own how these
should be handled.
- [x] Currently RLP decoding is done using a couple of selectors that
are inputs from the prover. Then there are some checks if these are
correct, though these are not complete. I think it's easier to think
about this if we would just use a lookup to directly verify if these
selectors are set correctly so we don't have to worry about edge cases
are cases that are hard to constrain using custom gates.
- [x] There are currently many cases in the main state maching because
each row type is it's own state. However there is not really any reuse
between custom gates between these rows, except for branches. It'll
likely be quite a bit simple to just have a single state for account,
storage and extension and just use multiple rows in those states
- [x] May be a good idea to split up branches and extension nodes. (semi
done)
- [ ] There's a couple of circuit tools that were added in this PR to
make writing the MPT circuit more manageable. A lot of these tools can
still be greatly improved.
- [ ] Number of lookups has been reduced a lot, but there are still many
optimization possibilities (have not looked into reducing the expression
degree for example).
- [x] The circuit uses a fixed layout which uses around 100 columns (of
which a lot need to be byte constrained so needs a lot of lookups as
well). This makes the circuit quite a bit more dense than probably
required, a more flexible way to manager the required data so the
width/height can be choses would be very useful I think.

Author: Brechtpd

gadgets/src/is_zero.rs

@@ -4,6 +4,7 @@
 //!  - witnesses `inv0(value)`, where `inv0(x)` is 0 when `x` = 0, and
 //!  `1/x` otherwise
 
+use eth_types::Field;
 use halo2_proofs::{
     arithmetic::FieldExt,
     circuit::{Chip, Region, Value},
@@ -51,7 +52,7 @@ pub struct IsZeroChip<F> {
 }
 
 #[rustfmt::skip]
-impl<F: FieldExt> IsZeroChip<F> {
+impl<F: Field> IsZeroChip<F> {
     /// Sets up the configuration of the chip by creating the required columns
     /// and defining the constraints that take part when using `is_zero` gate.
     ///
@@ -138,8 +139,8 @@ impl<F: FieldExt> Chip<F> for IsZeroChip<F> {
 #[cfg(test)]
 mod test {
     use super::{IsZeroChip, IsZeroConfig, IsZeroInstruction};
+    use eth_types::Field;
     use halo2_proofs::{
-        arithmetic::FieldExt,
         circuit::{Layouter, SimpleFloorPlanner, Value},
         dev::MockProver,
         halo2curves::bn256::Fr as Fp,
@@ -193,14 +194,14 @@ mod test {
         }
 
         #[derive(Default)]
-        struct TestCircuit<F: FieldExt> {
+        struct TestCircuit<F: Field> {
             values: Option<Vec<u64>>,
             // checks[i] = is_zero(values[i + 1] - values[i])
             checks: Option<Vec<bool>>,
             _marker: PhantomData<F>,
         }
 
-        impl<F: FieldExt> Circuit<F> for TestCircuit<F> {
+        impl<F: Field> Circuit<F> for TestCircuit<F> {
             type Config = TestCircuitConfig<F>;
             type FloorPlanner = SimpleFloorPlanner;
 
@@ -325,14 +326,14 @@ mod test {
         }
 
         #[derive(Default)]
-        struct TestCircuit<F: FieldExt> {
+        struct TestCircuit<F: Field> {
             values: Option<Vec<(u64, u64)>>,
             // checks[i] = is_zero(values[i].0 - values[i].1)
             checks: Option<Vec<bool>>,
             _marker: PhantomData<F>,
         }
 
-        impl<F: FieldExt> Circuit<F> for TestCircuit<F> {
+        impl<F: Field> Circuit<F> for TestCircuit<F> {
             type Config = TestCircuitConfig<F>;
             type FloorPlanner = SimpleFloorPlanner;
 

gadgets/src/util.rs

@@ -1,14 +1,18 @@
 //! Utility traits, functions used in the crate.
-use eth_types::evm_types::{GasCost, OpcodeId};
-use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
+use eth_types::{
+    evm_types::{GasCost, OpcodeId},
+    Field,
+};
+use halo2_proofs::plonk::Expression;
 
 /// Returns the sum of the passed in cells
 pub mod sum {
     use crate::util::Expr;
+    use eth_types::Field;
     use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
 
     /// Returns an expression for the sum of the list of expressions.
-    pub fn expr<F: FieldExt, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
+    pub fn expr<F: Field, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
         inputs
             .into_iter()
             .fold(0.expr(), |acc, input| acc + input.expr())
@@ -26,11 +30,12 @@ pub mod sum {
 /// otherwise. Inputs need to be boolean
 pub mod and {
     use crate::util::Expr;
+    use eth_types::Field;
     use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
 
     /// Returns an expression that evaluates to 1 only if all the expressions in
     /// the given list are 1, else returns 0.
-    pub fn expr<F: FieldExt, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
+    pub fn expr<F: Field, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
         inputs
             .into_iter()
             .fold(1.expr(), |acc, input| acc * input.expr())
@@ -47,11 +52,12 @@ pub mod and {
 pub mod or {
     use super::{and, not};
     use crate::util::Expr;
+    use eth_types::Field;
     use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
 
     /// Returns an expression that evaluates to 1 if any expression in the given
     /// list is 1. Returns 0 if all the expressions were 0.
-    pub fn expr<F: FieldExt, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
+    pub fn expr<F: Field, E: Expr<F>, I: IntoIterator<Item = E>>(inputs: I) -> Expression<F> {
         not::expr(and::expr(inputs.into_iter().map(not::expr)))
     }
 
@@ -65,10 +71,11 @@ pub mod or {
 /// `b` needs to be boolean
 pub mod not {
     use crate::util::Expr;
+    use eth_types::Field;
     use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
 
     /// Returns an expression that represents the NOT of the given expression.
-    pub fn expr<F: FieldExt, E: Expr<F>>(b: E) -> Expression<F> {
+    pub fn expr<F: Field, E: Expr<F>>(b: E) -> Expression<F> {
         1.expr() - b.expr()
     }
 
@@ -82,10 +89,11 @@ pub mod not {
 /// `a` and `b` needs to be boolean
 pub mod xor {
     use crate::util::Expr;
+    use eth_types::Field;
     use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
 
     /// Returns an expression that represents the XOR of the given expression.
-    pub fn expr<F: FieldExt, E: Expr<F>>(a: E, b: E) -> Expression<F> {
+    pub fn expr<F: Field, E: Expr<F>>(a: E, b: E) -> Expression<F> {
         a.expr() + b.expr() - 2.expr() * a.expr() * b.expr()
     }
 
@@ -99,11 +107,12 @@ pub mod xor {
 /// `selector == 0`. `selector` needs to be boolean.
 pub mod select {
     use crate::util::Expr;
-    use halo2_proofs::{arithmetic::FieldExt, plonk::Expression};
+    use eth_types::Field;
+    use halo2_proofs::plonk::Expression;
 
     /// Returns the `when_true` expression when the selector is true, else
     /// returns the `when_false` expression.
-    pub fn expr<F: FieldExt>(
+    pub fn expr<F: Field>(
         selector: Expression<F>,
         when_true: Expression<F>,
         when_false: Expression<F>,
@@ -113,13 +122,13 @@ pub mod select {
 
     /// Returns the `when_true` value when the selector is true, else returns
     /// the `when_false` value.
-    pub fn value<F: FieldExt>(selector: F, when_true: F, when_false: F) -> F {
+    pub fn value<F: Field>(selector: F, when_true: F, when_false: F) -> F {
         selector * when_true + (F::one() - selector) * when_false
     }
 
     /// Returns the `when_true` word when selector is true, else returns the
     /// `when_false` word.
-    pub fn value_word<F: FieldExt>(
+    pub fn value_word<F: Field>(
         selector: F,
         when_true: [u8; 32],
         when_false: [u8; 32],
@@ -132,9 +141,37 @@ pub mod select {
     }
 }
 
+/// Trait that implements functionality to get a scalar from
+/// commonly used types.
+pub trait Scalar<F: Field> {
+    /// Returns a scalar for the type.
+    fn scalar(&self) -> F;
+}
+
+/// Implementation trait `Scalar` for type able to be casted to u64
+#[macro_export]
+macro_rules! impl_scalar {
+    ($type:ty) => {
+        impl<F: eth_types::Field> $crate::util::Scalar<F> for $type {
+            #[inline]
+            fn scalar(&self) -> F {
+                F::from(*self as u64)
+            }
+        }
+    };
+    ($type:ty, $method:path) => {
+        impl<F: eth_types::Field> $crate::util::Scalar<F> for $type {
+            #[inline]
+            fn scalar(&self) -> F {
+                F::from($method(self) as u64)
+            }
+        }
+    };
+}
+
 /// Trait that implements functionality to get a constant expression from
 /// commonly used types.
-pub trait Expr<F: FieldExt> {
+pub trait Expr<F: Field> {
     /// Returns an expression for the type.
     fn expr(&self) -> Expression<F>;
 }
@@ -143,15 +180,17 @@ pub trait Expr<F: FieldExt> {
 #[macro_export]
 macro_rules! impl_expr {
     ($type:ty) => {
-        impl<F: halo2_proofs::arithmetic::FieldExt> $crate::util::Expr<F> for $type {
+        $crate::impl_scalar!($type);
+        impl<F: eth_types::Field> $crate::util::Expr<F> for $type {
             #[inline]
             fn expr(&self) -> Expression<F> {
                 Expression::Constant(F::from(*self as u64))
             }
         }
     };
     ($type:ty, $method:path) => {
-        impl<F: halo2_proofs::arithmetic::FieldExt> $crate::util::Expr<F> for $type {
+        $crate::impl_scalar!($type, $method);
+        impl<F: eth_types::Field> $crate::util::Expr<F> for $type {
             #[inline]
             fn expr(&self) -> Expression<F> {
                 Expression::Constant(F::from($method(self) as u64))
@@ -164,40 +203,53 @@ impl_expr!(bool);
 impl_expr!(u8);
 impl_expr!(u64);
 impl_expr!(usize);
+impl_expr!(isize);
 impl_expr!(OpcodeId, OpcodeId::as_u8);
 impl_expr!(GasCost, GasCost::as_u64);
 
-impl<F: FieldExt> Expr<F> for Expression<F> {
+impl<F: Field> Scalar<F> for i32 {
+    #[inline]
+    fn scalar(&self) -> F {
+        F::from(self.unsigned_abs() as u64)
+            * if self.is_negative() {
+                -F::one()
+            } else {
+                F::one()
+            }
+    }
+}
+
+impl<F: Field> Scalar<F> for &F {
+    #[inline]
+    fn scalar(&self) -> F {
+        *self.clone()
+    }
+}
+
+impl<F: Field> Expr<F> for i32 {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        self.clone()
+        Expression::Constant(self.scalar())
     }
 }
 
-impl<F: FieldExt> Expr<F> for &Expression<F> {
+impl<F: Field> Expr<F> for Expression<F> {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        (*self).clone()
+        self.clone()
     }
 }
 
-impl<F: FieldExt> Expr<F> for i32 {
+impl<F: Field> Expr<F> for &Expression<F> {
     #[inline]
     fn expr(&self) -> Expression<F> {
-        Expression::Constant(
-            F::from(self.unsigned_abs() as u64)
-                * if self.is_negative() {
-                    -F::one()
-                } else {
-                    F::one()
-                },
-        )
+        (*self).clone()
     }
 }
 
 /// Given a bytes-representation of an expression, it computes and returns the
 /// single expression.
-pub fn expr_from_bytes<F: FieldExt, E: Expr<F>>(bytes: &[E]) -> Expression<F> {
+pub fn expr_from_bytes<F: Field, E: Expr<F>>(bytes: &[E]) -> Expression<F> {
     let mut value = 0.expr();
     let mut multiplier = F::one();
     for byte in bytes.iter() {
@@ -208,6 +260,6 @@ pub fn expr_from_bytes<F: FieldExt, E: Expr<F>>(bytes: &[E]) -> Expression<F> {
 }
 
 /// Returns 2**by as FieldExt
-pub fn pow_of_two<F: FieldExt>(by: usize) -> F {
+pub fn pow_of_two<F: Field>(by: usize) -> F {
     F::from(2).pow(&[by as u64, 0, 0, 0])
 }

zkevm-circuits/src/circuit_tools.rs

@@ -0,0 +1,6 @@
+//! Circuit utilities
+#[macro_use]
+pub mod constraint_builder;
+pub mod cell_manager;
+pub mod gadgets;
+pub mod memory;