feat: add sload op (bus-mapping version)

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

@@ -1,10 +1,10 @@
 use super::Opcode;
 use crate::circuit_input_builder::CircuitInputStateRef;
 use crate::{
-    operation::{StorageOp, RW},
+    operation::{CallContextField, CallContextOp, StorageOp, TxAccessListAccountStorageOp, RW},
     Error,
 };
-use eth_types::GethExecStep;
+use eth_types::{GethExecStep, ToWord, Word};
 
 /// Placeholder structure used to implement [`Opcode`] trait over it
 /// corresponding to the [`OpcodeId::SLOAD`](crate::evm::OpcodeId::SLOAD)
@@ -19,6 +19,39 @@ impl Opcode for Sload {
     ) -> Result<(), Error> {
         let step = &steps[0];
 
+        state.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state.call().call_id,
+                field: CallContextField::TxId,
+                value: Word::from(state.tx_ctx.id()),
+            },
+        );
+        state.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state.call().call_id,
+                field: CallContextField::RwCounterEndOfReversion,
+                value: Word::from(state.call().rw_counter_end_of_reversion),
+            },
+        );
+        state.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state.call().call_id,
+                field: CallContextField::IsPersistent,
+                value: Word::from(state.call().is_persistent as u8),
+            },
+        );
+        state.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state.call().call_id,
+                field: CallContextField::CalleeAddress,
+                value: state.call().address.to_word(),
+            },
+        );
+
         // First stack read
         let stack_value_read = step.stack.last()?;
         let stack_position = step.stack.last_filled();
@@ -35,12 +68,25 @@ impl Opcode for Sload {
                 stack_value_read,
                 storage_value_read,
                 storage_value_read,
+                state.tx_ctx.id(),
+                storage_value_read, // TODO: committed_value
             ),
         );
 
         // First stack write
         state.push_stack_op(RW::WRITE, stack_position, storage_value_read);
 
+        state.push_op_reversible(
+            RW::WRITE,
+            TxAccessListAccountStorageOp {
+                tx_id: state.tx_ctx.id(),
+                address: state.call().address,
+                key: stack_value_read,
+                value: true,
+                value_prev: false, // TODO:
+            },
+        );
+
         Ok(())
     }
 }
@@ -49,6 +95,10 @@ impl Opcode for Sload {
 mod sload_tests {
     use super::*;
     use crate::circuit_input_builder::{ExecStep, TransactionContext};
+    use crate::{
+        operation::{CallContextField, CallContextOp, StorageOp, TxAccessListAccountStorageOp, RW},
+        Error,
+    };
     use eth_types::evm_types::StackAddress;
     use eth_types::{bytecode, Address, Word};
     use pretty_assertions::assert_eq;
@@ -90,6 +140,40 @@ mod sload_tests {
             0,
         );
         let mut state_ref = test_builder.state_ref(&mut tx, &mut tx_ctx, &mut step);
+
+        state_ref.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state_ref.call().call_id,
+                field: CallContextField::TxId,
+                value: Word::from(state_ref.tx_ctx.id()),
+            },
+        );
+        state_ref.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state_ref.call().call_id,
+                field: CallContextField::RwCounterEndOfReversion,
+                value: Word::from(state_ref.call().rw_counter_end_of_reversion),
+            },
+        );
+        state_ref.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state_ref.call().call_id,
+                field: CallContextField::IsPersistent,
+                value: Word::from(state_ref.call().is_persistent as u8),
+            },
+        );
+        state_ref.push_op(
+            RW::READ,
+            CallContextOp {
+                call_id: state_ref.call().call_id,
+                field: CallContextField::CalleeAddress,
+                value: state_ref.call().address.to_word(),
+            },
+        );
+
         // Add StackOp associated to the stack pop.
         state_ref.push_stack_op(RW::READ, StackAddress::from(1023), Word::from(0x0u32));
         // Add StorageOp associated to the storage read.
@@ -100,10 +184,23 @@ mod sload_tests {
                 Word::from(0x0u32),
                 Word::from(0x6fu32),
                 Word::from(0x6fu32),
+                1usize,
+                Word::from(0x6fu32),
             ),
         );
         // Add StackOp associated to the stack push.
         state_ref.push_stack_op(RW::WRITE, StackAddress::from(1023), Word::from(0x6fu32));
+        state_ref.push_op_reversible(
+            RW::WRITE,
+            TxAccessListAccountStorageOp {
+                tx_id: state_ref.tx_ctx.id(),
+                address: Address::from([0u8; 20]),
+                key: Word::from(0x0u32),
+                value: true,
+                value_prev: false, // TODO:
+            },
+        );
+
         tx.steps_mut().push(step);
         test_builder.block.txs_mut().push(tx);
 

bus-mapping/src/operation.rs

@@ -286,27 +286,40 @@ pub struct StorageOp {
     pub value: Word,
     /// Storage Value before the operation
     pub value_prev: Word,
+    /// Transaction ID: Transaction index in the block starting at 1.
+    pub tx_id: usize,
+    /// Storage Value before the transaction
+    pub committed_value: Word,
 }
 
 impl fmt::Debug for StorageOp {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("StorageOp { ")?;
         f.write_fmt(format_args!(
-            "addr: {:?}, key: {:?}, val_prev: 0x{:x}, val: 0x{:x}",
-            self.address, self.key, self.value_prev, self.value,
+            "tx_id: {:?}, addr: {:?}, key: {:?}, committed_val: 0x{:x}, val_prev: 0x{:x}, val: 0x{:x}",
+            self.tx_id, self.address, self.key, self.committed_value, self.value_prev, self.value
         ))?;
         f.write_str(" }")
     }
 }
 
 impl StorageOp {
     /// Create a new instance of a `StorageOp` from it's components.
-    pub const fn new(address: Address, key: Word, value: Word, value_prev: Word) -> StorageOp {
+    pub const fn new(
+        address: Address,
+        key: Word,
+        value: Word,
+        value_prev: Word,
+        tx_id: usize,
+        committed_value: Word,
+    ) -> StorageOp {
         StorageOp {
             address,
             key,
             value,
             value_prev,
+            tx_id,
+            committed_value,
         }
     }
 

bus-mapping/src/operation/container.rs

@@ -191,6 +191,8 @@ mod container_test {
                 Word::default(),
                 Word::from(0x1),
                 Word::default(),
+                1usize,
+                Word::default(),
             ),
         );
         let stack_ref = operation_container.insert(stack_operation.clone());

zkevm-circuits/src/evm_circuit/execution.rs

@@ -44,6 +44,7 @@ mod selfbalance;
 mod signed_comparator;
 mod signextend;
 mod stop;
+mod storage;
 mod swap;
 mod timestamp;
 
@@ -74,6 +75,7 @@ use selfbalance::SelfbalanceGadget;
 use signed_comparator::SignedComparatorGadget;
 use signextend::SignextendGadget;
 use stop::StopGadget;
+use storage::SloadGadget;
 use swap::SwapGadget;
 use timestamp::TimestampGadget;
 
@@ -130,6 +132,7 @@ pub(crate) struct ExecutionConfig<F> {
     coinbase_gadget: CoinbaseGadget<F>,
     timestamp_gadget: TimestampGadget<F>,
     selfbalance_gadget: SelfbalanceGadget<F>,
+    sload_gadget: SloadGadget<F>,
 }
 
 impl<F: Field> ExecutionConfig<F> {
@@ -264,6 +267,7 @@ impl<F: Field> ExecutionConfig<F> {
             msize_gadget: configure_gadget!(),
             coinbase_gadget: configure_gadget!(),
             timestamp_gadget: configure_gadget!(),
+            sload_gadget: configure_gadget!(),
             step: step_curr,
             presets_map,
         };
@@ -519,6 +523,7 @@ impl<F: Field> ExecutionConfig<F> {
                 assign_exec_step!(self.timestamp_gadget)
             }
             ExecutionState::SELFBALANCE => assign_exec_step!(self.selfbalance_gadget),
+            ExecutionState::SLOAD => assign_exec_step!(self.sload_gadget),
             ExecutionState::CALLDATACOPY => {
                 assign_exec_step!(self.calldatacopy_gadget)
             }

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

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