remove Memory related codes (#574)

* remove Memory related

* update inline doc

* remove memory constraints

* fix inline doc

* remove outdated test

Author: lightsing

bus-mapping/src/circuit_input_builder.rs

@@ -125,7 +125,7 @@ impl Default for CircuitsParams {
 ///
 /// The generated bus-mapping operations are:
 /// [`StackOp`](crate::operation::StackOp)s,
-/// [`MemoryOp`](crate::operation::MemoryOp)s and
+/// [`MemoryWordOp`](crate::operation::MemoryWordOp)s and
 /// [`StorageOp`](crate::operation::StorageOp), which correspond to each
 /// [`OpcodeId`](crate::evm::OpcodeId)s used in each `ExecTrace` step so that
 /// the State Proof witnesses are already generated on a structured manner and
@@ -313,7 +313,7 @@ impl<'a> CircuitInputBuilder {
                     values.1 += step
                         .bus_mapping_instance
                         .iter()
-                        .filter(|rw| rw.0 == operation::Target::Memory)
+                        .filter(|rw| rw.0 == operation::Target::MemoryWord)
                         .count();
                     values.2 += step
                         .bus_mapping_instance
@@ -330,7 +330,7 @@ impl<'a> CircuitInputBuilder {
             .rev()
         {
             log::debug!(
-                "op {:?}, count {}, mem rw {}(avg {:.2}), stack rw {}(avg {:.2})",
+                "op {:?}, count {}, memory_word rw {}(avg {:.2}), stack rw {}(avg {:.2})",
                 op,
                 count,
                 mem,
@@ -339,7 +339,10 @@ impl<'a> CircuitInputBuilder {
                 *stack as f32 / *count as f32
             );
         }
-        log::debug!("memory num: {}", self.block.container.memory.len());
+        log::debug!(
+            "memory_word num: {}",
+            self.block.container.memory_word.len()
+        );
         log::debug!("stack num: {}", self.block.container.stack.len());
         log::debug!("storage num: {}", self.block.container.storage.len());
         log::debug!(

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -15,9 +15,9 @@ use crate::{
     },
     exec_trace::OperationRef,
     operation::{
-        AccountField, AccountOp, CallContextField, CallContextOp, MemoryOp, MemoryWordOp, Op,
-        OpEnum, Operation, StackOp, Target, TxAccessListAccountOp, TxLogField, TxLogOp,
-        TxReceiptField, TxReceiptOp, RW,
+        AccountField, AccountOp, CallContextField, CallContextOp, MemoryWordOp, Op, OpEnum,
+        Operation, StackOp, Target, TxAccessListAccountOp, TxLogField, TxLogOp, TxReceiptField,
+        TxReceiptOp, RW,
     },
     precompile::is_precompiled,
     state_db::{CodeDB, StateDB},
@@ -214,24 +214,7 @@ impl<'a> CircuitInputStateRef<'a> {
         Ok(())
     }
 
-    /// Push a read type [`MemoryOp`] into the
-    /// [`OperationContainer`](crate::operation::OperationContainer) with the
-    /// next [`RWCounter`](crate::operation::RWCounter) and `call_id`, and then
-    /// adds a reference to the stored operation ([`OperationRef`]) inside
-    /// the bus-mapping instance of the current [`ExecStep`].  Then increase
-    /// the `block_ctx` [`RWCounter`](crate::operation::RWCounter) by one.
-    pub fn memory_read(
-        &mut self,
-        step: &mut ExecStep,
-        address: MemoryAddress,
-        value: u8,
-    ) -> Result<(), Error> {
-        let call_id = self.call()?.call_id;
-        self.push_op(step, RW::READ, MemoryOp::new(call_id, address, value));
-        Ok(())
-    }
-
-    /// Push a read type [`MemoryOp`] into the
+    /// Push a read type [`MemoryWordOp`] into the
     /// [`OperationContainer`](crate::operation::OperationContainer) with the
     /// next [`RWCounter`](crate::operation::RWCounter) and `call_id`, and then
     /// adds a reference to the stored operation ([`OperationRef`]) inside
@@ -248,23 +231,6 @@ impl<'a> CircuitInputStateRef<'a> {
         Ok(())
     }
 
-    /// Push a write type [`MemoryOp`] into the
-    /// [`OperationContainer`](crate::operation::OperationContainer) with the
-    /// next [`RWCounter`](crate::operation::RWCounter) and `call_id`, and then
-    /// adds a reference to the stored operation ([`OperationRef`]) inside
-    /// the bus-mapping instance of the current [`ExecStep`].  Then increase
-    /// the `block_ctx` [`RWCounter`](crate::operation::RWCounter)  by one.
-    pub fn memory_write(
-        &mut self,
-        step: &mut ExecStep,
-        address: MemoryAddress,
-        value: u8,
-    ) -> Result<(), Error> {
-        let call_id = self.call()?.call_id;
-        self.push_op(step, RW::WRITE, MemoryOp::new(call_id, address, value));
-        Ok(())
-    }
-
     /// Push a write type [`MemoryWordOp`] into the
     /// [`OperationContainer`](crate::operation::OperationContainer) with the
     /// next [`RWCounter`](crate::operation::RWCounter) and `call_id`, and then

bus-mapping/src/evm/opcodes.rs

@@ -132,7 +132,7 @@ use swap::Swap;
 /// or multiple [`ExecStep`](crate::circuit_input_builder::ExecStep) depending
 /// of the [`OpcodeId`] it contains.
 pub trait Opcode: Debug {
-    /// Generate the associated [`MemoryOp`](crate::operation::MemoryOp)s,
+    /// Generate the associated [`MemoryWordOp`](crate::operation::MemoryWordOp)s,
     /// [`StackOp`](crate::operation::StackOp)s, and
     /// [`StorageOp`](crate::operation::StorageOp)s associated to the Opcode
     /// is implemented for.

bus-mapping/src/evm/opcodes/mload.rs

@@ -9,7 +9,7 @@ use log::trace;
 /// Placeholder structure used to implement [`Opcode`] trait over it
 /// corresponding to the [`OpcodeId::MLOAD`](crate::evm::OpcodeId::MLOAD)
 /// `OpcodeId`. This is responsible of generating all of the associated
-/// [`crate::operation::StackOp`]s and [`crate::operation::MemoryOp`]s and place
+/// [`crate::operation::StackOp`]s and [`crate::operation::MemoryWordOp`]s and place
 /// them inside the trace's [`crate::operation::OperationContainer`].
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct Mload;

bus-mapping/src/exec_trace.rs

@@ -14,7 +14,6 @@ impl fmt::Debug for OperationRef {
             "OperationRef{{ {}, {} }}",
             match self.0 {
                 Target::Start => "Start",
-                Target::Memory => "Memory",
                 Target::MemoryWord => "MemoryWord",
                 Target::Stack => "Stack",
                 Target::Storage => "Storage",

bus-mapping/src/operation.rs

@@ -1,5 +1,5 @@
 //! Collection of structs and functions used to:
-//! - Define the internals of a [`MemoryOp`], [`StackOp`] and [`StorageOp`].
+//! - Define the internals of a [`MemoryWordOp`], [`StackOp`] and [`StorageOp`].
 //! - Define the actual operation types and a wrapper over them (the [`Operation`] enum).
 //! - Define structures that interact with operations such as [`OperationContainer`].
 pub(crate) mod container;
@@ -86,8 +86,6 @@ impl RWCounter {
 pub enum Target {
     /// Start is a padding operation.
     Start,
-    /// Means the target of the operation is the Memory.
-    Memory,
     /// Means the target of the operation is the MemoryWord.
     MemoryWord,
     /// Means the target of the operation is the Stack.
@@ -120,83 +118,6 @@ pub trait Op: Clone + Eq + Ord {
     fn reverse(&self) -> Self;
 }
 
-/// Represents a [`READ`](RW::READ)/[`WRITE`](RW::WRITE) into the memory implied
-/// by an specific [`OpcodeId`](eth_types::evm_types::opcode_ids::OpcodeId) of
-/// the [`ExecStep`](crate::circuit_input_builder::ExecStep).
-#[derive(Clone, PartialEq, Eq)]
-pub struct MemoryOp {
-    /// Call ID
-    pub call_id: usize,
-    /// Memory Address
-    pub address: MemoryAddress,
-    /// Value
-    pub value: u8,
-}
-
-impl fmt::Debug for MemoryOp {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("MemoryOp { ")?;
-        f.write_fmt(format_args!(
-            "call_id: {:?}, addr: {:?}, value: 0x{:02x}",
-            self.call_id, self.address, self.value
-        ))?;
-        f.write_str(" }")
-    }
-}
-
-impl MemoryOp {
-    /// Create a new instance of a `MemoryOp` from it's components.
-    pub fn new(call_id: usize, address: MemoryAddress, value: u8) -> MemoryOp {
-        MemoryOp {
-            call_id,
-            address,
-            value,
-        }
-    }
-
-    /// Returns the [`Target`] (operation type) of this operation.
-    pub const fn target(&self) -> Target {
-        Target::Memory
-    }
-
-    /// Returns the call id associated to this Operation.
-    pub const fn call_id(&self) -> usize {
-        self.call_id
-    }
-
-    /// Returns the [`MemoryAddress`] associated to this Operation.
-    pub const fn address(&self) -> &MemoryAddress {
-        &self.address
-    }
-
-    /// Returns the bytes read or written by this operation.
-    pub fn value(&self) -> u8 {
-        self.value
-    }
-}
-
-impl Op for MemoryOp {
-    fn into_enum(self) -> OpEnum {
-        OpEnum::Memory(self)
-    }
-
-    fn reverse(&self) -> Self {
-        unreachable!("MemoryOp can't be reverted")
-    }
-}
-
-impl PartialOrd for MemoryOp {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for MemoryOp {
-    fn cmp(&self, other: &Self) -> Ordering {
-        (&self.call_id, &self.address).cmp(&(&other.call_id, &other.address))
-    }
-}
-
 // new Memory ops for word value
 /// Represents a [`READ`](RW::READ)/[`WRITE`](RW::WRITE) into the memory implied
 /// by an specific [`OpcodeId`](eth_types::evm_types::opcode_ids::OpcodeId) of
@@ -223,7 +144,7 @@ impl fmt::Debug for MemoryWordOp {
 }
 
 impl MemoryWordOp {
-    /// Create a new instance of a `MemoryOp` from it's components.
+    /// Create a new instance of a `MemoryWordOp` from it's components.
     pub fn new(call_id: usize, address: MemoryAddress, value: Word) -> MemoryWordOp {
         MemoryWordOp {
             call_id,
@@ -234,7 +155,7 @@ impl MemoryWordOp {
 
     /// Returns the [`Target`] (operation type) of this operation.
     pub const fn target(&self) -> Target {
-        Target::Memory
+        Target::MemoryWord
     }
 
     /// Returns the call id associated to this Operation.
@@ -259,7 +180,7 @@ impl Op for MemoryWordOp {
     }
 
     fn reverse(&self) -> Self {
-        unreachable!("MemoryOp can't be reverted")
+        unreachable!("MemoryWordOp can't be reverted")
     }
 }
 
@@ -985,13 +906,11 @@ impl Op for TxReceiptOp {
 }
 
 /// Generic enum that wraps over all the operation types possible.
-/// In particular [`StackOp`], [`MemoryOp`] and [`StorageOp`].
+/// In particular [`StackOp`], [`MemoryWordOp`] and [`StorageOp`].
 #[derive(Debug, Clone)]
 pub enum OpEnum {
     /// Stack
     Stack(StackOp),
-    /// Memory
-    Memory(MemoryOp),
     /// Memory word
     MemoryWord(MemoryWordOp),
     /// Storage
@@ -1159,7 +1078,7 @@ mod operation_tests {
 
         let stack_op_as_operation = Operation::new(RWCounter(1), RW::WRITE, stack_op.clone());
 
-        let memory_op = MemoryOp::new(1, MemoryAddress(0x40), 0x40);
+        let memory_op = MemoryWordOp::new(1, MemoryAddress(0x40), Word::from(0x40));
 
         let memory_op_as_operation = Operation::new(RWCounter(1), RW::WRITE, memory_op.clone());
 

bus-mapping/src/operation/container.rs

@@ -1,7 +1,7 @@
 use super::{
-    AccountOp, CallContextOp, MemoryOp, MemoryWordOp, Op, OpEnum, Operation, RWCounter, StackOp,
-    StartOp, StorageOp, Target, TxAccessListAccountOp, TxAccessListAccountStorageOp, TxLogOp,
-    TxReceiptOp, TxRefundOp, RW,
+    AccountOp, CallContextOp, MemoryWordOp, Op, OpEnum, Operation, RWCounter, StackOp, StartOp,
+    StorageOp, Target, TxAccessListAccountOp, TxAccessListAccountStorageOp, TxLogOp, TxReceiptOp,
+    TxRefundOp, RW,
 };
 use crate::exec_trace::OperationRef;
 use itertools::Itertools;
@@ -22,9 +22,7 @@ use itertools::Itertools;
 /// order to construct the State proof.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct OperationContainer {
-    /// Operations of MemoryOp
-    pub memory: Vec<Operation<MemoryOp>>,
-    /// Operations of MemoryOp
+    /// Operations of MemoryWordOp
     pub memory_word: Vec<Operation<MemoryWordOp>>,
     /// Operations of StackOp
     pub stack: Vec<Operation<StackOp>>,
@@ -59,7 +57,6 @@ impl OperationContainer {
     /// Generates a new instance of an `OperationContainer`.
     pub fn new() -> Self {
         Self {
-            memory: Vec::new(),
             memory_word: Vec::new(),
             stack: Vec::new(),
             storage: Vec::new(),
@@ -97,10 +94,6 @@ impl OperationContainer {
         op_enum: OpEnum,
     ) -> OperationRef {
         match op_enum {
-            OpEnum::Memory(op) => {
-                self.memory.push(Operation::new(rwc, rw, op));
-                OperationRef::from((Target::Memory, self.memory.len() - 1))
-            }
             OpEnum::MemoryWord(op) => {
                 self.memory_word.push(Operation::new(rwc, rw, op));
                 //TODO: use new Target type i.e. MemoryWord
@@ -175,10 +168,10 @@ impl OperationContainer {
         }
     }
 
-    /// Returns a sorted vector of all of the [`MemoryOp`]s contained inside of
+    /// Returns a sorted vector of all of the [`MemoryWordOp`]s contained inside of
     /// the container.
-    pub fn sorted_memory(&self) -> Vec<Operation<MemoryOp>> {
-        self.memory.iter().sorted().cloned().collect()
+    pub fn sorted_memory_word(&self) -> Vec<Operation<MemoryWordOp>> {
+        self.memory_word.iter().sorted().cloned().collect()
     }
 
     /// Returns a sorted vector of all of the [`StackOp`]s contained inside of
@@ -216,7 +209,7 @@ mod container_test {
         let memory_operation = Operation::new(
             global_counter.inc_pre(),
             RW::WRITE,
-            MemoryOp::new(1, MemoryAddress::from(1), 1),
+            MemoryWordOp::new(1, MemoryAddress::from(1), 1.into()),
         );
         let storage_operation = Operation::new(
             global_counter.inc_pre(),
@@ -235,10 +228,13 @@ mod container_test {
         let storage_ref = operation_container.insert(storage_operation.clone());
 
         assert_eq!(operation_container.sorted_stack()[0], stack_operation);
-        assert_eq!(operation_container.sorted_memory()[0], memory_operation);
+        assert_eq!(
+            operation_container.sorted_memory_word()[0],
+            memory_operation
+        );
         assert_eq!(operation_container.sorted_storage()[0], storage_operation);
         assert_eq!(stack_ref, OperationRef::from((Target::Stack, 0)));
-        assert_eq!(memory_ref, OperationRef::from((Target::Memory, 0)));
+        assert_eq!(memory_ref, OperationRef::from((Target::MemoryWord, 0)));
         assert_eq!(storage_ref, OperationRef::from((Target::Storage, 0)));
     }
 }