(WIP) feat: add sload op

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

@@ -1,7 +1,7 @@
 use super::Opcode;
 use crate::circuit_input_builder::CircuitInputStateRef;
 use crate::{
-    operation::{StorageOp, RW},
+    operation::{StorageOp, TxAccessListAccountStorageOp, RW},
     Error,
 };
 use eth_types::GethExecStep;
@@ -26,6 +26,16 @@ impl Opcode for Sload {
         // Manage first stack read at latest stack position
         state.push_stack_op(RW::READ, stack_position, stack_value_read);
 
+        // TxAccessList AccountStorage read
+        state.push_op(TxAccessListAccountStorageOp::new(
+            RW::READ,
+            1usize, // TODO: tx_id
+            state.call().address,
+            stack_value_read,
+            true, // TODO: assume is_warm for now
+            true,
+        ));
+
         // Storage read
         let storage_value_read = step.storage.get_or_err(&stack_value_read)?;
         state.push_op(StorageOp::new(
@@ -36,6 +46,16 @@ impl Opcode for Sload {
             storage_value_read,
         ));
 
+        // TxAccessList AccountStorage write
+        state.push_op(TxAccessListAccountStorageOp::new(
+            RW::WRITE,
+            1usize, // TODO: tx_id
+            state.call().address,
+            stack_value_read,
+            true,
+            true, // TODO: assume always is_warm for now
+        ));
+
         // First stack write
         state.push_stack_op(RW::WRITE, stack_position, storage_value_read);
 
@@ -88,6 +108,16 @@ mod sload_tests {
         let mut state_ref = test_builder.state_ref(&mut tx, &mut tx_ctx, &mut step);
         // Add StackOp associated to the stack pop.
         state_ref.push_stack_op(RW::READ, StackAddress::from(1023), Word::from(0x0u32));
+        // Add TxAccessListAccountStorageOp associated to the TxAccessListAccountStorage
+        // read.
+        state_ref.push_op(TxAccessListAccountStorageOp::new(
+            RW::READ,
+            1usize, // TODO: tx_id
+            state_ref.tx.calls()[0].address,
+            Word::from(0x0u32),
+            true, // TODO: assume is_warm for now
+            true,
+        ));
         // Add StorageOp associated to the storage read.
         state_ref.push_op(StorageOp::new(
             RW::READ,
@@ -96,6 +126,16 @@ mod sload_tests {
             Word::from(0x6fu32),
             Word::from(0x6fu32),
         ));
+        // Add TxAccessListAccountStorageOp associated to the TxAccessListAccountStorage
+        // write.
+        state_ref.push_op(TxAccessListAccountStorageOp::new(
+            RW::WRITE,
+            1usize, // TODO: tx_id
+            state_ref.tx.calls()[0].address,
+            Word::from(0x0u32),
+            true,
+            true,
+        ));
         // Add StackOp associated to the stack push.
         state_ref.push_stack_op(RW::WRITE, StackAddress::from(1023), Word::from(0x6fu32));
         tx.steps_mut().push(step);

bus-mapping/src/operation.rs

@@ -414,6 +414,8 @@ impl Op for TxAccessListAccountOp {
 /// `SLOAD` step of the [`ExecStep`](crate::circuit_input_builder::ExecStep).
 #[derive(Clone, PartialEq, Eq)]
 pub struct TxAccessListAccountStorageOp {
+    /// RW
+    pub rw: RW,
     /// Transaction ID: Transaction index in the block starting at 1.
     pub tx_id: usize,
     /// Account Address
@@ -426,6 +428,64 @@ pub struct TxAccessListAccountStorageOp {
     pub value_prev: bool,
 }
 
+impl TxAccessListAccountStorageOp {
+    /// Create a new instance of a `TxAccessListAccountStorageOp` from it's
+    /// components.
+    pub fn new(
+        rw: RW,
+        tx_id: usize,
+        address: Address,
+        key: Word,
+        value: bool,
+        value_prev: bool,
+    ) -> TxAccessListAccountStorageOp {
+        TxAccessListAccountStorageOp {
+            rw,
+            tx_id,
+            address,
+            key,
+            value,
+            value_prev,
+        }
+    }
+
+    /// Returns the internal [`RW`] which says whether the operation corresponds
+    /// to a Read or a Write into storage_slot access_list.
+    pub const fn rw(&self) -> RW {
+        self.rw
+    }
+
+    /// Returns the [`Target`] (operation type) of this operation.
+    pub const fn target(&self) -> Target {
+        Target::TxAccessListAccountStorage
+    }
+
+    /// Returns the [`TxID`] corresponding to this operation.
+    pub const fn tx_id(&self) -> usize {
+        self.tx_id
+    }
+
+    /// Returns the [`Address`] corresponding to this operation.
+    pub const fn address(&self) -> &Address {
+        &self.address
+    }
+
+    /// Returns the [`Word`] used as key for this operation.
+    pub const fn key(&self) -> &Word {
+        &self.key
+    }
+
+    /// Returns the [`bool`] read or written by this operation.
+    pub const fn value(&self) -> bool {
+        self.value
+    }
+
+    /// Returns the [`bool`] at key found previous to this operation.
+    pub const fn value_prev(&self) -> bool {
+        self.value_prev
+    }
+}
+
 impl fmt::Debug for TxAccessListAccountStorageOp {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("TxAccessListAccountStorageOp { ")?;

bus-mapping/src/operation/container.rs

@@ -121,6 +121,16 @@ impl OperationContainer {
     pub fn sorted_storage(&self) -> Vec<Operation<StorageOp>> {
         self.storage.iter().sorted().cloned().collect()
     }
+
+    /// Returns a sorted vector of all of the [`TxAccessListAccountStorageOp`]s
+    /// contained inside of the container.
+    pub fn sorted_txaccesslist_storage(&self) -> Vec<Operation<TxAccessListAccountStorageOp>> {
+        self.tx_access_list_storage_slot
+            .iter()
+            .sorted()
+            .cloned()
+            .collect()
+    }
 }
 
 #[cfg(test)]

zkevm-circuits/src/evm_circuit/execution.rs

@@ -37,6 +37,7 @@ mod push;
 mod signed_comparator;
 mod signextend;
 mod stop;
+mod storage;
 mod swap;
 mod timestamp;
 
@@ -61,6 +62,7 @@ use push::PushGadget;
 use signed_comparator::SignedComparatorGadget;
 use signextend::SignextendGadget;
 use stop::StopGadget;
+use storage::SloadGadget;
 use swap::SwapGadget;
 use timestamp::TimestampGadget;
 
@@ -111,6 +113,7 @@ pub(crate) struct ExecutionConfig<F> {
     msize_gadget: MsizeGadget<F>,
     coinbase_gadget: CoinbaseGadget<F>,
     timestamp_gadget: TimestampGadget<F>,
+    sload_gadget: SloadGadget<F>,
 }
 
 impl<F: FieldExt> ExecutionConfig<F> {
@@ -239,6 +242,7 @@ impl<F: FieldExt> ExecutionConfig<F> {
             msize_gadget: configure_gadget!(),
             coinbase_gadget: configure_gadget!(),
             timestamp_gadget: configure_gadget!(),
+            sload_gadget: configure_gadget!(),
             step: step_curr,
             presets_map,
         };
@@ -486,9 +490,8 @@ impl<F: FieldExt> ExecutionConfig<F> {
             ExecutionState::DUP => assign_exec_step!(self.dup_gadget),
             ExecutionState::SWAP => assign_exec_step!(self.swap_gadget),
             ExecutionState::COINBASE => assign_exec_step!(self.coinbase_gadget),
-            ExecutionState::TIMESTAMP => {
-                assign_exec_step!(self.timestamp_gadget)
-            }
+            ExecutionState::TIMESTAMP => assign_exec_step!(self.timestamp_gadget),
+            ExecutionState::SLOAD => assign_exec_step!(self.sload_gadget),
             ExecutionState::ErrorOutOfGasPureMemory => {
                 assign_exec_step!(self.error_oog_pure_memory_gadget)
             }

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

@@ -0,0 +1,3 @@
+mod sload;
+
+pub(crate) use sload::SloadGadget;