e2e erc20 transfer proving

Makefile

@@ -20,6 +20,9 @@ test: ## Run tests for all the workspace members
 test_benches: ## Compiles the benchmarks
 	@cargo test --verbose --release --all-features -p circuit-benchmarks --no-run
 
+test-doc:
+	@cargo test --release --all --all-features --doc
+
 test-all: fmt doc clippy test_benches test ## Run all the CI checks locally (in your actual toolchain) 
 
 evm_bench: ## Run Evm Circuit benchmarks 

bus-mapping/Cargo.toml

@@ -19,5 +19,6 @@ serde_json = "1.0.66"
 [dev-dependencies]
 mock = { path = "../mock" }
 pretty_assertions = "1.0.0"
+rand = "0.8"
 tokio = { version = "1.13", features = ["macros"] }
 url = "2.2.2"

bus-mapping/src/circuit_input_builder.rs

@@ -174,6 +174,8 @@ pub struct ExecStep {
     /// overflow", this value will **not** be the actual Gas cost of the
     /// step.
     pub gas_cost: GasCost,
+    /// Accumulated gas refund
+    pub gas_refund: Gas,
     /// Call index within the [`Transaction`]
     pub call_index: usize,
     /// The global counter when this step was executed.
@@ -204,6 +206,7 @@ impl ExecStep {
             memory_size: step.memory.0.len(),
             gas_left: step.gas,
             gas_cost: step.gas_cost,
+            gas_refund: Gas(0),
             call_index,
             rwc,
             reversible_write_counter,
@@ -223,6 +226,7 @@ impl Default for ExecStep {
             memory_size: 0,
             gas_left: Gas(0),
             gas_cost: GasCost(0),
+            gas_refund: Gas(0),
             call_index: 0,
             rwc: RWCounter(0),
             reversible_write_counter: 0,
@@ -805,6 +809,9 @@ impl<'a> CircuitInputStateRef<'a> {
         rw: RW,
         op: T,
     ) -> Result<(), Error> {
+        if matches!(rw, RW::WRITE) {
+            self.apply_op(&op.clone().into_enum());
+        }
         let op_ref = self.block.container.insert(Operation::new_reversible(
             self.block_ctx.rwc.inc_pre(),
             rw,
@@ -1076,38 +1083,29 @@ impl<'a> CircuitInputStateRef<'a> {
         }
     }
 
-    /// Apply reverted op to state and push to container.
-    fn apply_reverted_op(&mut self, op: OpEnum) -> OperationRef {
-        match op {
+    /// Apply op to state.
+    fn apply_op(&mut self, op: &OpEnum) {
+        match &op {
             OpEnum::Storage(op) => {
-                let (_, account) = self.sdb.get_storage_mut(&op.address, &op.key);
-                *account = op.value;
-                self.block.container.insert(Operation::new(
-                    self.block_ctx.rwc.inc_pre(),
-                    RW::WRITE,
-                    op,
-                ))
+                self.sdb.set_storage(&op.address, &op.key, &op.value);
             }
             OpEnum::TxAccessListAccount(op) => {
-                if !op.value {
+                if !op.value_prev && op.value {
+                    self.sdb.add_account_to_access_list(op.address);
+                }
+                if op.value_prev && !op.value {
                     self.sdb.remove_account_from_access_list(&op.address);
                 }
-                self.block.container.insert(Operation::new(
-                    self.block_ctx.rwc.inc_pre(),
-                    RW::WRITE,
-                    op,
-                ))
             }
             OpEnum::TxAccessListAccountStorage(op) => {
-                if !op.value {
+                if !op.value_prev && op.value {
+                    self.sdb
+                        .add_account_storage_to_access_list((op.address, op.key));
+                }
+                if op.value_prev && !op.value {
                     self.sdb
                         .remove_account_storage_from_access_list(&(op.address, op.key));
                 }
-                self.block.container.insert(Operation::new(
-                    self.block_ctx.rwc.inc_pre(),
-                    RW::WRITE,
-                    op,
-                ))
             }
             OpEnum::Account(op) => {
                 let (_, account) = self.sdb.get_account_mut(&op.address);
@@ -1118,16 +1116,13 @@ impl<'a> CircuitInputStateRef<'a> {
                         account.code_hash = op.value.to_be_bytes().into();
                     }
                 }
-                self.block.container.insert(Operation::new(
-                    self.block_ctx.rwc.inc_pre(),
-                    RW::WRITE,
-                    op,
-                ))
             }
-            OpEnum::TxRefund(_) => unimplemented!(),
+            OpEnum::TxRefund(op) => {
+                self.sdb.set_refund(op.value);
+            }
             OpEnum::AccountDestructed(_) => unimplemented!(),
             _ => unreachable!(),
-        }
+        };
     }
 
     /// Handle a reversion group
@@ -1141,7 +1136,13 @@ impl<'a> CircuitInputStateRef<'a> {
         // Apply reversions
         for (step_index, op_ref) in reversion_group.op_refs.into_iter().rev() {
             if let Some(op) = self.get_rev_op_by_ref(&op_ref) {
-                let rev_op_ref = self.apply_reverted_op(op);
+                self.apply_op(&op);
+                let rev_op_ref = self.block.container.insert_op_enum(
+                    self.block_ctx.rwc.inc_pre(),
+                    RW::WRITE,
+                    false,
+                    op,
+                );
                 self.tx.steps[step_index]
                     .bus_mapping_instance
                     .push(rev_op_ref);
@@ -1473,6 +1474,7 @@ impl<'a> CircuitInputBuilder {
 
         for (index, geth_step) in geth_trace.struct_logs.iter().enumerate() {
             let mut state_ref = self.state_ref(&mut tx, &mut tx_ctx);
+            log::trace!("handle {}th opcode {:?} ", index, geth_step.op);
             let exec_steps = gen_associated_ops(
                 &geth_step.op,
                 &mut state_ref,
@@ -1488,8 +1490,8 @@ impl<'a> CircuitInputBuilder {
         let end_tx_step = gen_end_tx_ops(&mut self.state_ref(&mut tx, &mut tx_ctx))?;
         tx.steps.push(end_tx_step);
 
+        self.sdb.commit_tx();
         self.block.txs.push(tx);
-        self.sdb.clear_access_list_and_refund();
 
         Ok(())
     }
@@ -2004,6 +2006,7 @@ mod tracer_tests {
                 &GethExecTrace {
                     gas: Gas(0),
                     failed: false,
+                    return_value: "".to_owned(),
                     struct_logs: vec![geth_step.clone()],
                 },
                 false,

bus-mapping/src/evm/opcodes.rs

@@ -16,8 +16,12 @@ use eth_types::{
 use keccak256::EMPTY_HASH;
 use log::warn;
 
+#[cfg(test)]
+mod test_util;
+
 mod call;
 mod calldatacopy;
+mod calldataload;
 mod calldatasize;
 mod caller;
 mod callvalue;
@@ -30,12 +34,14 @@ mod number;
 mod origin;
 mod selfbalance;
 mod sload;
+mod sstore;
 mod stackonlyop;
 mod stop;
 mod swap;
 
 use call::Call;
 use calldatacopy::Calldatacopy;
+use calldataload::Calldataload;
 use calldatasize::Calldatasize;
 use caller::Caller;
 use callvalue::Callvalue;
@@ -47,6 +53,7 @@ use mstore::Mstore;
 use origin::Origin;
 use selfbalance::Selfbalance;
 use sload::Sload;
+use sstore::Sstore;
 use stackonlyop::StackOnlyOpcode;
 use stop::Stop;
 use swap::Swap;
@@ -106,14 +113,14 @@ fn fn_gen_associated_ops(opcode_id: &OpcodeId) -> FnGenAssociatedOps {
         OpcodeId::SHL => StackOnlyOpcode::<2, 1>::gen_associated_ops,
         OpcodeId::SHR => StackOnlyOpcode::<2, 1>::gen_associated_ops,
         OpcodeId::SAR => StackOnlyOpcode::<2, 1>::gen_associated_ops,
-        // OpcodeId::SHA3 => {},
+        OpcodeId::SHA3 => StackOnlyOpcode::<2, 1>::gen_associated_ops,
         // OpcodeId::ADDRESS => {},
         // OpcodeId::BALANCE => {},
         OpcodeId::ORIGIN => Origin::gen_associated_ops,
         OpcodeId::CALLER => Caller::gen_associated_ops,
         OpcodeId::CALLVALUE => Callvalue::gen_associated_ops,
         OpcodeId::CALLDATASIZE => Calldatasize::gen_associated_ops,
-        OpcodeId::CALLDATALOAD => StackOnlyOpcode::<1, 1>::gen_associated_ops,
+        OpcodeId::CALLDATALOAD => Calldataload::gen_associated_ops,
         OpcodeId::CALLDATACOPY => Calldatacopy::gen_associated_ops,
         // OpcodeId::CODESIZE => {},
         // OpcodeId::CODECOPY => {},
@@ -137,7 +144,7 @@ fn fn_gen_associated_ops(opcode_id: &OpcodeId) -> FnGenAssociatedOps {
         OpcodeId::MSTORE => Mstore::<false>::gen_associated_ops,
         OpcodeId::MSTORE8 => Mstore::<true>::gen_associated_ops,
         OpcodeId::SLOAD => Sload::gen_associated_ops,
-        // OpcodeId::SSTORE => {},
+        OpcodeId::SSTORE => Sstore::gen_associated_ops,
         OpcodeId::JUMP => StackOnlyOpcode::<1, 0>::gen_associated_ops,
         OpcodeId::JUMPI => StackOnlyOpcode::<2, 0>::gen_associated_ops,
         OpcodeId::PC => StackOnlyOpcode::<0, 1>::gen_associated_ops,
@@ -211,7 +218,7 @@ fn fn_gen_associated_ops(opcode_id: &OpcodeId) -> FnGenAssociatedOps {
         // OpcodeId::LOG0 => {},
         // OpcodeId::LOG1 => {},
         // OpcodeId::LOG2 => {},
-        // OpcodeId::LOG3 => {},
+        OpcodeId::LOG3 => StackOnlyOpcode::<5, 0>::gen_associated_ops,
         // OpcodeId::LOG4 => {},
         // OpcodeId::CREATE => {},
         OpcodeId::CALL => Call::gen_associated_ops,

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

@@ -158,18 +158,15 @@ fn gen_memory_copy_steps(
 #[cfg(test)]
 mod calldatacopy_tests {
     use crate::{
-        circuit_input_builder::ExecState,
-        mock::BlockData,
+        evm::opcodes::test_util::TestCase,
         operation::{CallContextField, CallContextOp, StackOp, RW},
     };
     use eth_types::{
         bytecode,
         evm_types::{OpcodeId, StackAddress},
-        geth_types::GethData,
         Word,
     };
 
-    use mock::test_ctx::{helpers::*, TestContext};
     use pretty_assertions::assert_eq;
 
     #[test]
@@ -182,30 +179,13 @@ mod calldatacopy_tests {
             STOP
         };
 
-        // Get the execution steps from the external tracer
-        let block: GethData = TestContext::<2, 1>::new(
-            None,
-            account_0_code_account_1_no_code(code),
-            tx_from_1_to_0,
-            |block, _tx| block.number(0xcafeu64),
-        )
-        .unwrap()
-        .into();
-
-        let mut builder = BlockData::new_from_geth_data(block.clone()).new_circuit_input_builder();
-        builder
-            .handle_block(&block.eth_block, &block.geth_traces)
-            .unwrap();
-
-        let step = builder.block.txs()[0]
-            .steps()
-            .iter()
-            .find(|step| step.exec_state == ExecState::Op(OpcodeId::CALLDATACOPY))
-            .unwrap();
+        let test = TestCase::new_from_bytecode(code);
+        let step = test.step_witness(OpcodeId::CALLDATACOPY, 0);
+        let call_id = test.tx_witness().calls()[0].call_id;
 
         assert_eq!(
             [0, 1, 2]
-                .map(|idx| &builder.block.container.stack[step.bus_mapping_instance[idx].as_usize()])
+                .map(|idx| &step.rws.stack[idx])
                 .map(|operation| (operation.rw(), operation.op())),
             [
                 (
@@ -225,14 +205,13 @@ mod calldatacopy_tests {
 
         assert_eq!(
             {
-                let operation =
-                    &builder.block.container.call_context[step.bus_mapping_instance[3].as_usize()];
+                let operation = &step.rws.call_context[0];
                 (operation.rw(), operation.op())
             },
             (
                 RW::READ,
                 &CallContextOp {
-                    call_id: builder.block.txs()[0].calls()[0].call_id,
+                    call_id,
                     field: CallContextField::TxId,
                     value: Word::from(1),
                 }