Scroll dev 0512

Makefile

@@ -5,7 +5,7 @@ help: ## Display this help screen
 
 clippy: ## Run clippy checks over all workspace members
 	@cargo check --all-features
-	@cargo clippy --all-features --all-targets -- -D clippy::all
+	@cargo clippy --all-features --all-targets -- -D warnings
 
 doc: ## Generate and tests docs including private items
 	@cargo doc --no-deps --all --document-private-items
@@ -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/src/circuit_input_builder.rs

@@ -20,7 +20,8 @@ pub use access::{Access, AccessSet, AccessValue, CodeSource};
 pub use block::{Block, BlockContext};
 pub use call::{Call, CallContext, CallKind};
 use core::fmt::Debug;
-use eth_types::{self, Address, GethExecStep, GethExecTrace, Word};
+use eth_types::evm_types::GasCost;
+use eth_types::{self, Address, GethExecStep, GethExecTrace, ToWord, Word};
 use ethers_providers::JsonRpcClient;
 pub use execution::{CopyDetails, ExecState, ExecStep, StepAuxiliaryData};
 pub use input_state_ref::CircuitInputStateRef;
@@ -167,11 +168,21 @@ impl<'a> CircuitInputBuilder {
         let mut tx = self.new_tx(eth_tx, !geth_trace.failed)?;
         let mut tx_ctx = TransactionContext::new(eth_tx, geth_trace, is_last_tx)?;
 
+        if let Some(al) = &eth_tx.access_list {
+            for item in &al.0 {
+                self.sdb.add_account_to_access_list(item.address);
+                for k in &item.storage_keys {
+                    self.sdb
+                        .add_account_storage_to_access_list((item.address, (*k).to_word()));
+                }
+            }
+        }
         // TODO: Move into gen_associated_steps with
         // - execution_state: BeginTx
         // - op: None
         // Generate BeginTx step
-        let begin_tx_step = gen_begin_tx_ops(&mut self.state_ref(&mut tx, &mut tx_ctx))?;
+        let mut begin_tx_step = gen_begin_tx_ops(&mut self.state_ref(&mut tx, &mut tx_ctx))?;
+        begin_tx_step.gas_cost = GasCost(tx.gas - geth_trace.struct_logs[0].gas.0);
         tx.steps_mut().push(begin_tx_step);
 
         for (index, geth_step) in geth_trace.struct_logs.iter().enumerate() {

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -275,6 +275,13 @@ impl<'a> CircuitInputStateRef<'a> {
             .ok_or(Error::CodeNotFound(code_hash))
     }
 
+    /// Reference to the caller's Call
+    pub fn caller(&self) -> Result<&Call, Error> {
+        self.tx_ctx
+            .caller_index()
+            .map(|caller_idx| &self.tx.calls()[caller_idx])
+    }
+
     /// Reference to the current Call
     pub fn call(&self) -> Result<&Call, Error> {
         self.tx_ctx
@@ -294,6 +301,11 @@ impl<'a> CircuitInputStateRef<'a> {
         self.tx_ctx.call_ctx()
     }
 
+    /// Reference to the current CallContext
+    pub fn caller_ctx(&self) -> Result<&CallContext, Error> {
+        self.tx_ctx.caller_ctx()
+    }
+
     /// Mutable reference to the call CallContext
     pub fn call_ctx_mut(&mut self) -> Result<&mut CallContext, Error> {
         self.tx_ctx.call_ctx_mut()

bus-mapping/src/circuit_input_builder/transaction.rs

@@ -96,14 +96,24 @@ impl TransactionContext {
         &self.calls
     }
 
+    /// Return the index of the caller (the second last call in the call stack).
+    pub fn caller_index(&self) -> Result<usize, Error> {
+        self.caller_ctx().map(|call| call.index)
+    }
+
     /// Return the index of the current call (the last call in the call stack).
     pub(crate) fn call_index(&self) -> Result<usize, Error> {
+        self.call_ctx().map(|call| call.index)
+    }
+
+    pub(crate) fn caller_ctx(&self) -> Result<&CallContext, Error> {
         self.calls
-            .last()
+            .len()
+            .checked_sub(2)
+            .map(|idx| &self.calls[idx])
             .ok_or(Error::InvalidGethExecTrace(
                 "Call stack is empty but call is used",
             ))
-            .map(|call| call.index)
     }
 
     pub(crate) fn call_ctx(&self) -> Result<&CallContext, Error> {

bus-mapping/src/evm/opcodes.rs

@@ -32,6 +32,7 @@ mod mload;
 mod mstore;
 mod number;
 mod origin;
+mod r#return;
 mod selfbalance;
 mod sload;
 mod sstore;
@@ -52,6 +53,7 @@ use gasprice::GasPrice;
 use mload::Mload;
 use mstore::Mstore;
 use origin::Origin;
+use r#return::Return;
 use selfbalance::Selfbalance;
 use sload::Sload;
 use sstore::Sstore;
@@ -118,7 +120,7 @@ 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,
@@ -191,18 +193,18 @@ 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,
         // OpcodeId::CALLCODE => {},
-        // TODO: Handle RETURN by its own gen_associated_ops.
-        OpcodeId::RETURN => Stop::gen_associated_ops,
+        // TODO: Fully implement RETURN.
+        OpcodeId::RETURN => Return::gen_associated_ops,
         // OpcodeId::DELEGATECALL => {},
         // OpcodeId::CREATE2 => {},
         // OpcodeId::STATICCALL => {},
         // TODO: Handle REVERT by its own gen_associated_ops.
-        OpcodeId::REVERT => Stop::gen_associated_ops,
+        OpcodeId::REVERT => Return::gen_associated_ops,
         // OpcodeId::SELFDESTRUCT => {},
         OpcodeId::CALLCODE | OpcodeId::DELEGATECALL | OpcodeId::STATICCALL => {
             warn!("Using dummy gen_call_ops for opcode {:?}", opcode_id);

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

@@ -246,7 +246,7 @@ impl Opcode for Call {
                     ),
                     (CallContextField::MemorySize, next_memory_word_size.into()),
                     (
-                        CallContextField::StateWriteCounter,
+                        CallContextField::ReversibleWriteCounter,
                         (exec_step.reversible_write_counter + 1).into(),
                     ),
                 ] {

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

@@ -0,0 +1,20 @@
+use super::Opcode;
+use crate::circuit_input_builder::{CircuitInputStateRef, ExecStep};
+use crate::Error;
+use eth_types::GethExecStep;
+
+/// Placeholder structure used to implement [`Opcode`] trait over it
+/// corresponding to the [`OpcodeId::RETURN`](crate::evm::OpcodeId::RETURN).
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct Return;
+
+impl Opcode for Return {
+    fn gen_associated_ops(
+        state: &mut CircuitInputStateRef,
+        geth_steps: &[GethExecStep],
+    ) -> Result<Vec<ExecStep>, Error> {
+        let exec_step = state.new_step(&geth_steps[0])?;
+        state.handle_return()?;
+        Ok(vec![exec_step])
+    }
+}

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

@@ -1,7 +1,10 @@
 use super::Opcode;
-use crate::circuit_input_builder::{CircuitInputStateRef, ExecStep};
-use crate::Error;
-use eth_types::GethExecStep;
+use crate::{
+    circuit_input_builder::{CircuitInputStateRef, ExecStep},
+    operation::{CallContextField, CallContextOp, RW},
+    Error,
+};
+use eth_types::{GethExecStep, ToWord};
 
 /// Placeholder structure used to implement [`Opcode`] trait over it
 /// corresponding to the [`OpcodeId::STOP`](crate::evm::OpcodeId::STOP)
@@ -17,8 +20,97 @@ impl Opcode for Stop {
         state: &mut CircuitInputStateRef,
         geth_steps: &[GethExecStep],
     ) -> Result<Vec<ExecStep>, Error> {
-        let exec_step = state.new_step(&geth_steps[0])?;
+        let geth_step = &geth_steps[0];
+        let mut exec_step = state.new_step(geth_step)?;
+
+        let call = state.call()?.clone();
+
+        state.push_op(
+            &mut exec_step,
+            RW::READ,
+            CallContextOp {
+                call_id: call.call_id,
+                field: CallContextField::IsSuccess,
+                value: 1.into(),
+            },
+        );
+
+        if call.is_root {
+            state.push_op(
+                &mut exec_step,
+                RW::READ,
+                CallContextOp {
+                    call_id: call.call_id,
+                    field: CallContextField::IsPersistent,
+                    value: 1.into(),
+                },
+            );
+        } else {
+            let caller = state.caller()?.clone();
+            state.push_op(
+                &mut exec_step,
+                RW::READ,
+                CallContextOp {
+                    call_id: call.call_id,
+                    field: CallContextField::CallerId,
+                    value: caller.call_id.into(),
+                },
+            );
+
+            let geth_step_next = &geth_steps[1];
+            let caller_gas_left = geth_step_next.gas.0 - geth_step.gas.0;
+            for (field, value) in [
+                (CallContextField::IsRoot, (caller.is_root as u64).into()),
+                (
+                    CallContextField::IsCreate,
+                    (caller.is_create() as u64).into(),
+                ),
+                (CallContextField::CodeSource, caller.code_hash.to_word()),
+                (CallContextField::ProgramCounter, geth_step_next.pc.0.into()),
+                (
+                    CallContextField::StackPointer,
+                    geth_step_next.stack.stack_pointer().0.into(),
+                ),
+                (CallContextField::GasLeft, caller_gas_left.into()),
+                (
+                    CallContextField::MemorySize,
+                    geth_step_next.memory.word_size().into(),
+                ),
+                (
+                    CallContextField::ReversibleWriteCounter,
+                    state.caller_ctx()?.reversible_write_counter.into(),
+                ),
+            ] {
+                state.push_op(
+                    &mut exec_step,
+                    RW::READ,
+                    CallContextOp {
+                        call_id: caller.call_id,
+                        field,
+                        value,
+                    },
+                );
+            }
+
+            for (field, value) in [
+                (CallContextField::LastCalleeId, call.call_id.into()),
+                (CallContextField::LastCalleeReturnDataOffset, 0.into()),
+                (CallContextField::LastCalleeReturnDataLength, 0.into()),
+            ] {
+                state.push_op(
+                    &mut exec_step,
+                    RW::WRITE,
+                    CallContextOp {
+                        call_id: caller.call_id,
+                        field,
+                        value,
+                    },
+                );
+            }
+        }
+
         state.handle_return()?;
+
         Ok(vec![exec_step])
     }
 }

bus-mapping/src/operation.rs

@@ -688,8 +688,8 @@ pub enum CallContextField {
     GasLeft,
     /// MemorySize
     MemorySize,
-    /// StateWriteCounter
-    StateWriteCounter,
+    /// ReversibleWriteCounter
+    ReversibleWriteCounter,
 }
 
 /// Represents an CallContext read/write operation.

circuit-benchmarks/build.rs

@@ -7,7 +7,7 @@ use std::io::Write;
 
 fn main() {
     let degree: usize = var("DEGREE")
-        .unwrap_or_else(|_| "11".to_string())
+        .unwrap_or_else(|_| "17".to_string())
         .parse()
         .expect("Cannot parse DEGREE env var as usize");
 

integration-tests/src/bin/gen_blockchain_data.rs

@@ -7,6 +7,7 @@ use ethers::{
     },
     core::utils::WEI_IN_ETHER,
     middleware::SignerMiddleware,
+    prelude::NonceManagerMiddleware,
     providers::{Middleware, PendingTransaction},
     signers::Signer,
     solc::Solc,
@@ -54,7 +55,7 @@ where
         .method::<_, bool>("transfer", (to, amount))
         .expect("cannot construct ERC20 transfer call");
     // Set gas to avoid `eth_estimateGas` call
-    let call = call.legacy();
+    //let call = call.legacy();
     let call = call.gas(100_000);
     call.tx
 }
@@ -172,7 +173,10 @@ async fn main() {
     //
 
     let mut deployments = HashMap::new();
-    let prov_wallet0 = Arc::new(SignerMiddleware::new(get_provider(), wallet0));
+    let prov_wallet0 = Arc::new(NonceManagerMiddleware::new(
+        SignerMiddleware::new(get_provider(), wallet0.clone()),
+        wallet0.address(),
+    ));
 
     // Greeter
     let contract = deploy(
@@ -194,7 +198,7 @@ async fn main() {
         contracts
             .get("OpenZeppelinERC20TestToken")
             .expect("contract not found"),
-        prov_wallet0.address(),
+        wallet0.address(),
     )
     .await;
     let block_num = prov.get_block_number().await.expect("cannot get block_num");
@@ -325,14 +329,17 @@ async fn main() {
     for (i, (from_i, to_i)) in [(0, 1), (2, 3), (1, 0), (3, 2)].iter().enumerate() {
         let amount = U256::from(0x800000000000000 / (i + 1));
         let prov_wallet = &wallets[*from_i];
-        let tx = erc20_transfer(
+        let mut tx = erc20_transfer(
             prov_wallet.clone(),
             contract_address,
             contract_abi,
             wallets[*to_i].address(),
             amount,
         );
 
+        prov_wallet.fill_transaction(&mut tx, None).await.unwrap();
+        tx.set_gas(100_000u64);
+
         let pending_tx = prov_wallet
             .send_transaction(tx, None)
             .await
@@ -345,7 +352,13 @@ async fn main() {
         let pending_tx = PendingTransaction::new(*tx_hash, wallets[i].inner());
         let receipt = pending_tx.confirmations(0usize).await.unwrap().unwrap();
         let expected_status = if i % 2 == 0 { 1u64 } else { 0u64 };
-        assert_eq!(receipt.status, Some(U64::from(expected_status)));
+        assert_eq!(
+            receipt.status,
+            Some(U64::from(expected_status)),
+            "failed tx hash: {:?}, receipt: {:#?}",
+            tx_hash,
+            receipt
+        );
     }
     let block_num = prov.get_block_number().await.expect("cannot get block_num");
     blocks.insert(