add int decomposition type

zkevm-circuits/src/evm_circuit/execution/balance.rs

@@ -1,7 +1,6 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::N_BYTES_ACCOUNT_ADDRESS,
         step::ExecutionState,
         util::{
             common_gadget::SameContextGadget,
@@ -20,7 +19,7 @@ use crate::{
         Expr,
     },
 };
-use eth_types::{evm_types::GasCost, Field, ToLittleEndian, ToWord};
+use eth_types::{evm_types::GasCost, Field, ToWord};
 use halo2_proofs::{circuit::Value, plonk::Error};
 
 #[derive(Clone, Debug)]
@@ -119,15 +118,7 @@ impl<F: Field> ExecutionGadget<F> for BalanceGadget<F> {
         self.same_context.assign_exec_step(region, offset, step)?;
 
         let address = block.get_rws(step, 0).stack_value();
-        self.address.assign(
-            region,
-            offset,
-            Some(
-                address.to_le_bytes()[0..N_BYTES_ACCOUNT_ADDRESS]
-                    .try_into()
-                    .unwrap(),
-            ),
-        )?;
+        self.address.assign_u256(region, offset, address)?;
 
         self.tx_id
             .assign(region, offset, Value::known(F::from(tx.id as u64)))?;

zkevm-circuits/src/evm_circuit/execution/begin_tx.rs

@@ -34,7 +34,6 @@ use halo2_proofs::{
     circuit::Value,
     plonk::{Error, Expression},
 };
-use itertools::Itertools;
 
 #[derive(Clone, Debug)]
 pub(crate) struct BeginTxGadget<F> {
@@ -252,7 +251,6 @@ impl<F: Field> ExecutionGadget<F> for BeginTxGadget<F> {
                         .to_vec()
                         .try_into()
                         .unwrap(),
-                    256.expr(),
                 )
                 .to_word(),
             );
@@ -554,21 +552,14 @@ impl<F: Field> ExecutionGadget<F> for BeginTxGadget<F> {
         )?;
         self.tx_callee_address
             .assign_h160(region, offset, tx.callee_address)?;
-        self.call_callee_address.assign(
+        self.call_callee_address.assign_h160(
             region,
             offset,
             if tx.is_create {
                 get_contract_address(tx.caller_address, tx.nonce)
             } else {
                 tx.callee_address
-            }
-            .to_fixed_bytes()
-            .iter()
-            .rev()
-            .copied()
-            .collect_vec()
-            .try_into()
-            .ok(),
+            },
         )?;
         self.is_caller_callee_equal.assign(
             region,

zkevm-circuits/src/evm_circuit/execution/create.rs

@@ -109,7 +109,6 @@ impl<F: Field, const IS_CREATE2: bool, const S: ExecutionState> ExecutionGadget<
                 .to_vec()
                 .try_into()
                 .unwrap(),
-            256.expr(),
         );
 
         // stack operations

zkevm-circuits/src/evm_circuit/execution/error_oog_memory_copy.rs

@@ -1,7 +1,7 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::{N_BYTES_ACCOUNT_ADDRESS, N_BYTES_GAS, N_BYTES_MEMORY_WORD_SIZE},
+        param::{N_BYTES_GAS, N_BYTES_MEMORY_WORD_SIZE},
         step::ExecutionState,
         util::{
             common_gadget::CommonErrorGadget,
@@ -20,7 +20,7 @@ use crate::{
 };
 use eth_types::{
     evm_types::{GasCost, OpcodeId},
-    Field, ToLittleEndian, U256,
+    Field, U256,
 };
 use halo2_proofs::{circuit::Value, plonk::Error};
 
@@ -186,13 +186,8 @@ impl<F: Field> ExecutionGadget<F> for ErrorOOGMemoryCopyGadget<F> {
             .assign(region, offset, Value::known(F::from(u64::from(is_warm))))?;
         self.tx_id
             .assign(region, offset, Value::known(F::from(transaction.id as u64)))?;
-        self.external_address.assign(
-            region,
-            offset,
-            external_address.to_le_bytes()[0..N_BYTES_ACCOUNT_ADDRESS]
-                .try_into()
-                .ok(),
-        )?;
+        self.external_address
+            .assign_u256(region, offset, external_address)?;
         self.src_offset.assign_u256(region, offset, src_offset)?;
         let memory_addr = self
             .dst_memory_addr

zkevm-circuits/src/evm_circuit/execution/error_write_protection.rs

@@ -1,7 +1,6 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::N_BYTES_ACCOUNT_ADDRESS,
         step::ExecutionState,
         util::{
             common_gadget::CommonErrorGadget,
@@ -17,7 +16,7 @@ use crate::{
         Expr,
     },
 };
-use eth_types::{evm_types::OpcodeId, Field, ToLittleEndian, U256};
+use eth_types::{evm_types::OpcodeId, Field, U256};
 use halo2_proofs::{circuit::Value, plonk::Error};
 
 #[derive(Clone, Debug)]
@@ -120,13 +119,8 @@ impl<F: Field> ExecutionGadget<F> for ErrorWriteProtectionGadget<F> {
         }
 
         self.gas.assign_u256(region, offset, gas)?;
-        self.code_address.assign(
-            region,
-            offset,
-            code_address.to_le_bytes()[0..N_BYTES_ACCOUNT_ADDRESS]
-                .try_into()
-                .ok(),
-        )?;
+        self.code_address
+            .assign_u256(region, offset, code_address)?;
         self.value.assign_u256(region, offset, value)?;
 
         self.is_call.assign(

zkevm-circuits/src/evm_circuit/execution/extcodecopy.rs

@@ -58,7 +58,6 @@ impl<F: Field> ExecutionGadget<F> for ExtcodecopyGadget<F> {
                 .to_vec()
                 .try_into()
                 .unwrap(),
-            256.expr(),
         );
 
         let code_size = cb.query_cell();

zkevm-circuits/src/evm_circuit/execution/extcodehash.rs

@@ -44,7 +44,6 @@ impl<F: Field> ExecutionGadget<F> for ExtcodehashGadget<F> {
                 .to_vec()
                 .try_into()
                 .unwrap(),
-            256.expr(),
         );
 
         let tx_id = cb.call_context(None, CallContextFieldTag::TxId);

zkevm-circuits/src/evm_circuit/execution/extcodesize.rs

@@ -47,7 +47,6 @@ impl<F: Field> ExecutionGadget<F> for ExtcodesizeGadget<F> {
                 .to_vec()
                 .try_into()
                 .unwrap(),
-            256.expr(),
         );
         cb.stack_pop_word(address_word.to_word());
 

zkevm-circuits/src/evm_circuit/execution/jump.rs

@@ -1,7 +1,6 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::N_BYTES_PROGRAM_COUNTER,
         step::ExecutionState,
         util::{
             common_gadget::SameContextGadget,
@@ -15,7 +14,7 @@ use crate::{
     },
     util::{word::WordExpr, Expr},
 };
-use eth_types::{evm_types::OpcodeId, Field, ToLittleEndian};
+use eth_types::{evm_types::OpcodeId, Field};
 use halo2_proofs::plonk::Error;
 
 #[derive(Clone, Debug)]
@@ -67,15 +66,7 @@ impl<F: Field> ExecutionGadget<F> for JumpGadget<F> {
         self.same_context.assign_exec_step(region, offset, step)?;
 
         let destination = block.get_rws(step, 0).stack_value();
-        self.destination.assign(
-            region,
-            offset,
-            Some(
-                destination.to_le_bytes()[..N_BYTES_PROGRAM_COUNTER]
-                    .try_into()
-                    .unwrap(),
-            ),
-        )?;
+        self.destination.assign_u256(region, offset, destination)?;
 
         Ok(())
     }

zkevm-circuits/src/evm_circuit/execution/memory.rs

@@ -1,7 +1,7 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::{N_BYTES_MEMORY_ADDRESS, N_BYTES_MEMORY_WORD_SIZE},
+        param::N_BYTES_MEMORY_WORD_SIZE,
         step::ExecutionState,
         util::{
             common_gadget::SameContextGadget,
@@ -20,7 +20,7 @@ use crate::{
         Expr,
     },
 };
-use eth_types::{evm_types::OpcodeId, Field, ToLittleEndian};
+use eth_types::{evm_types::OpcodeId, Field};
 use halo2_proofs::plonk::Error;
 
 #[derive(Clone, Debug)]
@@ -129,13 +129,7 @@ impl<F: Field> ExecutionGadget<F> for MemoryGadget<F> {
 
         // Inputs/Outputs
         let [address, value] = [0, 1].map(|index| block.get_rws(step, index).stack_value());
-        self.address.assign(
-            region,
-            offset,
-            address.to_le_bytes()[0..N_BYTES_MEMORY_ADDRESS]
-                .try_into()
-                .ok(),
-        )?;
+        self.address.assign_u256(region, offset, address)?;
         self.value.assign_u256(region, offset, value)?;
 
         // Check if this is an MLOAD

zkevm-circuits/src/evm_circuit/execution/origin.rs

@@ -1,7 +1,6 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::N_BYTES_ACCOUNT_ADDRESS,
         step::ExecutionState,
         util::{
             common_gadget::SameContextGadget,
@@ -14,7 +13,7 @@ use crate::{
     util::{word::WordExpr, Expr},
 };
 use bus_mapping::evm::OpcodeId;
-use eth_types::{Field, ToLittleEndian};
+use eth_types::Field;
 use halo2_proofs::{circuit::Value, plonk::Error};
 
 #[derive(Clone, Debug)]
@@ -79,13 +78,7 @@ impl<F: Field> ExecutionGadget<F> for OriginGadget<F> {
             .assign(region, offset, Value::known(F::from(tx.id as u64)))?;
 
         // Assign Origin addr.
-        self.origin.assign(
-            region,
-            offset,
-            origin.to_le_bytes()[..N_BYTES_ACCOUNT_ADDRESS]
-                .try_into()
-                .ok(),
-        )?;
+        self.origin.assign_u256(region, offset, origin)?;
 
         // Assign SameContextGadget witnesses.
         self.same_context.assign_exec_step(region, offset, step)?;

zkevm-circuits/src/evm_circuit/execution/returndatacopy.rs

@@ -1,7 +1,7 @@
 use crate::{
     evm_circuit::{
         execution::ExecutionGadget,
-        param::{N_BYTES_MEMORY_ADDRESS, N_BYTES_MEMORY_WORD_SIZE},
+        param::N_BYTES_MEMORY_WORD_SIZE,
         step::ExecutionState,
         util::{
             common_gadget::SameContextGadget,
@@ -22,7 +22,7 @@ use crate::{
     },
 };
 use bus_mapping::{circuit_input_builder::CopyDataType, evm::OpcodeId};
-use eth_types::{evm_types::GasCost, Field, ToLittleEndian, ToScalar};
+use eth_types::{evm_types::GasCost, Field, ToScalar};
 use gadgets::util::not;
 use halo2_proofs::{circuit::Value, plonk::Error};
 
@@ -176,15 +176,7 @@ impl<F: Field> ExecutionGadget<F> for ReturnDataCopyGadget<F> {
         let [dest_offset, data_offset, size] =
             [0, 1, 2].map(|index| block.get_rws(step, index).stack_value());
 
-        self.data_offset.assign(
-            region,
-            offset,
-            Some(
-                data_offset.to_le_bytes()[..N_BYTES_MEMORY_ADDRESS]
-                    .try_into()
-                    .unwrap(),
-            ),
-        )?;
+        self.data_offset.assign_u256(region, offset, data_offset)?;
 
         let [last_callee_id, return_data_offset, return_data_size] = [
             (3, CallContextFieldTag::LastCalleeId),

zkevm-circuits/src/evm_circuit/util.rs

@@ -10,6 +10,7 @@ use crate::{
         },
         table::Table,
     },
+    util::int_decomposition::IntDecomposition,
     witness::{Block, ExecStep, Rw, RwMap},
 };
 use bus_mapping::state_db::CodeDB;
@@ -36,7 +37,7 @@ pub use gadgets::util::{and, not, or, select, sum};
 use super::param::{N_BYTES_ACCOUNT_ADDRESS, N_BYTES_U64};
 
 #[derive(Clone, Debug)]
-pub(crate) struct Cell<F> {
+pub struct Cell<F> {
     // expression for constraint
     expression: Expression<F>,
     column: Column<Advice>,
@@ -490,6 +491,7 @@ pub struct RandomLinearCombination<F, const N: usize> {
 impl<F: Field, const N: usize> RandomLinearCombination<F, N> {
     const N_BYTES: usize = N;
 
+    /// XXX for randomness 256.expr(), consider using IntDecomposition instead
     pub(crate) fn new(cells: [Cell<F>; N], randomness: Expression<F>) -> Self {
         Self {
             expression: rlc::expr(&cells.clone().map(|cell| cell.expr()), randomness),
@@ -521,44 +523,11 @@ impl<F: Field, const N: usize> Expr<F> for RandomLinearCombination<F, N> {
     }
 }
 
-pub(crate) type MemoryAddress<F> = RandomLinearCombination<F, N_BYTES_MEMORY_ADDRESS>;
+pub(crate) type MemoryAddress<F> = IntDecomposition<F, N_BYTES_MEMORY_ADDRESS>;
 
-impl<F: Field> WordExpr<F> for MemoryAddress<F> {
-    fn to_word(&self) -> Word<Expression<F>> {
-        Word::from_lo_unchecked(self.expr())
-    }
-}
-
-pub(crate) type AccountAddress<F> = RandomLinearCombination<F, N_BYTES_ACCOUNT_ADDRESS>;
-
-impl<F: Field> WordExpr<F> for AccountAddress<F> {
-    fn to_word(&self) -> Word<Expression<F>> {
-        Word::new([
-            rlc::expr(
-                &self.cells[0..16]
-                    .iter()
-                    .map(|cell| cell.expr())
-                    .collect_vec(),
-                256.expr(),
-            ),
-            rlc::expr(
-                &self.cells[16..]
-                    .iter()
-                    .map(|cell| cell.expr())
-                    .collect_vec(),
-                256.expr(),
-            ),
-        ])
-    }
-}
-
-pub(crate) type U64Cell<F> = RandomLinearCombination<F, N_BYTES_U64>;
+pub(crate) type AccountAddress<F> = IntDecomposition<F, N_BYTES_ACCOUNT_ADDRESS>;
 
-impl<F: Field> WordExpr<F> for U64Cell<F> {
-    fn to_word(&self) -> Word<Expression<F>> {
-        Word::from_lo_unchecked(self.expr())
-    }
-}
+pub(crate) type U64Cell<F> = IntDecomposition<F, N_BYTES_U64>;
 
 /// Decodes a field element from its byte representation in little endian order
 pub(crate) mod from_bytes {