add call tracer and prestate tracer

Author: lightsing

Cargo.lock

@@ -50,6 +50,7 @@ rayon = "1.5"
 regex = "1.5"
 serde = {version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+serde_stacker = "0.1"
 sha3 = "0.10"
 snark-verifier = { git = "https://github.com/scroll-tech/snark-verifier", tag = "v0.1.5" }
 snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", tag = "v0.1.5", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }

Cargo.toml

@@ -12,7 +12,6 @@ mod l2;
 mod tracer_tests;
 mod transaction;
 
-use self::access::gen_state_access_trace;
 pub use self::block::BlockHead;
 use crate::{
     error::Error,
@@ -964,29 +963,6 @@ pub struct BuilderClient<P: JsonRpcClient> {
     circuits_params: CircuitsParams,
 }
 
-/// Get State Accesses from TxExecTraces
-pub fn get_state_accesses(
-    eth_block: &EthBlock,
-    geth_traces: &[eth_types::GethExecTrace],
-) -> Result<AccessSet, Error> {
-    let mut block_access_trace = vec![Access::new(
-        None,
-        RW::WRITE,
-        AccessValue::Account {
-            address: eth_block
-                .author
-                .ok_or(Error::EthTypeError(eth_types::Error::IncompleteBlock))?,
-        },
-    )];
-    for (tx_index, tx) in eth_block.transactions.iter().enumerate() {
-        let geth_trace = &geth_traces[tx_index];
-        let tx_access_trace = gen_state_access_trace(eth_block, tx, geth_trace)?;
-        block_access_trace.extend(tx_access_trace);
-    }
-
-    Ok(AccessSet::from(block_access_trace))
-}
-
 /// Build a partial StateDB from step 3
 pub fn build_state_code_db(
     proofs: Vec<eth_types::EIP1186ProofResponse>,
@@ -1078,11 +1054,26 @@ impl<P: JsonRpcClient> BuilderClient<P> {
     }
 
     /// Step 2. Get State Accesses from TxExecTraces
-    pub fn get_state_accesses(
-        eth_block: &EthBlock,
-        geth_traces: &[eth_types::GethExecTrace],
-    ) -> Result<AccessSet, Error> {
-        get_state_accesses(eth_block, geth_traces)
+    pub async fn get_state_accesses(&self, eth_block: &EthBlock) -> Result<AccessSet, Error> {
+        let mut access_set = AccessSet::default();
+        access_set.add_account(
+            eth_block
+                .author
+                .ok_or(Error::EthTypeError(eth_types::Error::IncompleteBlock))?,
+        );
+        let traces = self
+            .cli
+            .trace_block_prestate_by_hash(
+                eth_block
+                    .hash
+                    .ok_or(Error::EthTypeError(eth_types::Error::IncompleteBlock))?,
+            )
+            .await?;
+        for trace in traces.into_iter() {
+            access_set.extend_from_traces(&trace);
+        }
+
+        Ok(access_set)
     }
 
     /// Step 3. Query geth for all accounts, storage keys, and codes from
@@ -1334,7 +1325,7 @@ impl<P: JsonRpcClient> BuilderClient<P> {
         let mut access_set = AccessSet::default();
         for block_num in block_num_begin..block_num_end {
             let (eth_block, geth_traces, _, _) = self.get_block(block_num).await?;
-            let mut access_list = Self::get_state_accesses(&eth_block, &geth_traces)?;
+            let mut access_list = self.get_state_accesses(&eth_block).await?;
             access_set.extend(&mut access_list);
             blocks_and_traces.push((eth_block, geth_traces));
         }

bus-mapping/src/circuit_input_builder.rs

@@ -1,13 +1,7 @@
-use crate::{operation::RW, Error};
-use eth_types::{
-    evm_types::OpcodeId, Address, GethExecStep, GethExecTrace, GethPrestateTrace, ToAddress, Word,
-};
-use ethers_core::utils::get_contract_address;
+use crate::operation::RW;
+use eth_types::{geth_types::GethData, Address, GethPrestateTrace, Word};
 use std::collections::{hash_map::Entry, HashMap, HashSet};
 
-use AccessValue::{Account, Code, Storage};
-use RW::{READ, WRITE};
-
 /// State and Code Access with "keys/index" used in the access operation.
 #[derive(Debug, PartialEq, Eq)]
 pub enum AccessValue {
@@ -48,16 +42,6 @@ impl Access {
     }
 }
 
-/// Given a trace and assuming that the first step is a *CALL*/CREATE* kind
-/// opcode, return the result if found.
-fn get_call_result(trace: &[GethExecStep]) -> Option<Word> {
-    let depth = trace[0].depth;
-    trace[1..]
-        .iter()
-        .find(|s| s.depth == depth)
-        .and_then(|s| s.stack.last().ok())
-}
-
 /// State and Code Access set.
 #[derive(Debug, PartialEq, Eq, Default)]
 pub struct AccessSet {
@@ -119,6 +103,39 @@ impl AccessSet {
         self.state.extend(other.state.drain());
         self.code.extend(other.code.drain());
     }
+
+    #[cfg(not(feature = "scroll"))]
+    pub(crate) fn from_geth_data(geth_data: &GethData) -> Self {
+        let mut access_set = AccessSet::default();
+        access_set.add_account(geth_data.eth_block.author.unwrap());
+        for trace in geth_data.geth_traces.iter() {
+            access_set.extend_from_traces(trace.prestate.as_ref().unwrap());
+        }
+        access_set
+    }
+
+    #[cfg(feature = "scroll")]
+    pub(crate) fn from_geth_data(geth_data: &GethData) -> Self {
+        let mut access_set = AccessSet::default();
+        access_set.add_account(geth_data.eth_block.author.unwrap());
+        for (addr, storage) in geth_data.block_trace.storage_trace.storage_proofs.iter() {
+            log::info!("add addr {:?} to access_set", addr);
+            access_set.add_account(*addr);
+            access_set.add_code(*addr);
+            for key in storage.keys() {
+                log::info!("add addr {:?} key {:?} to access_set", addr, key);
+                access_set.add_storage(*addr, *key);
+            }
+        }
+        if let Some(ref proofs) = geth_data.block_trace.storage_trace.proofs {
+            for addr in proofs.keys() {
+                log::info!("add addr {:?} to access_set", addr);
+                access_set.add_account(*addr);
+                access_set.add_code(*addr);
+            }
+        }
+        access_set
+    }
 }
 
 impl From<Vec<Access>> for AccessSet {
@@ -145,168 +162,3 @@ impl Default for CodeSource {
         Self::Tx
     }
 }
-
-/// Generate the State Access trace from the given trace.  All state read/write
-/// accesses are reported, without distinguishing those that happen in revert
-/// sections.
-pub fn gen_state_access_trace<TX>(
-    _block: &eth_types::Block<TX>,
-    tx: &eth_types::Transaction,
-    geth_trace: &GethExecTrace,
-) -> Result<Vec<Access>, Error> {
-    let mut call_stack: Vec<(Address, CodeSource)> = Vec::new();
-    let mut accs = vec![Access::new(None, WRITE, Account { address: tx.from })];
-    if let Some(to) = tx.to {
-        call_stack.push((to, CodeSource::Address(to)));
-        accs.push(Access::new(None, WRITE, Account { address: to }));
-        // Code may be null if the account is not a contract
-        accs.push(Access::new(None, READ, Code { address: to }));
-    } else {
-        let address = get_contract_address(tx.from, tx.nonce);
-        call_stack.push((address, CodeSource::Tx));
-        accs.push(Access::new(None, WRITE, Account { address }));
-        accs.push(Access::new(None, WRITE, Code { address }));
-    }
-
-    for (index, step) in geth_trace.struct_logs.iter().enumerate() {
-        let next_step = geth_trace.struct_logs.get(index + 1);
-        let i = Some(index);
-        let (contract_address, code_source) = &call_stack[call_stack.len() - 1];
-        let (contract_address, code_source) = (*contract_address, *code_source);
-
-        let (mut push_call_stack, mut pop_call_stack) = (false, false);
-        if let Some(next_step) = next_step {
-            push_call_stack = step.depth + 1 == next_step.depth;
-            pop_call_stack = step.depth - 1 == next_step.depth;
-        }
-
-        let result: Result<(), Error> = (|| {
-            match step.op {
-                OpcodeId::SSTORE => {
-                    let address = contract_address;
-                    let key = step.stack.last()?;
-                    accs.push(Access::new(i, WRITE, Storage { address, key }));
-                }
-                OpcodeId::SLOAD => {
-                    let address = contract_address;
-                    let key = step.stack.last()?;
-                    accs.push(Access::new(i, READ, Storage { address, key }));
-                }
-                OpcodeId::SELFBALANCE => {
-                    let address = contract_address;
-                    accs.push(Access::new(i, READ, Account { address }));
-                }
-                OpcodeId::CODESIZE => {
-                    if let CodeSource::Address(address) = code_source {
-                        accs.push(Access::new(i, READ, Code { address }));
-                    }
-                }
-                OpcodeId::CODECOPY => {
-                    if let CodeSource::Address(address) = code_source {
-                        accs.push(Access::new(i, READ, Code { address }));
-                    }
-                }
-                OpcodeId::BALANCE => {
-                    let address = step.stack.last()?.to_address();
-                    accs.push(Access::new(i, READ, Account { address }));
-                }
-                OpcodeId::EXTCODEHASH => {
-                    let address = step.stack.last()?.to_address();
-                    accs.push(Access::new(i, READ, Account { address }));
-                }
-                OpcodeId::EXTCODESIZE => {
-                    let address = step.stack.last()?.to_address();
-                    accs.push(Access::new(i, READ, Code { address }));
-                }
-                OpcodeId::EXTCODECOPY => {
-                    let address = step.stack.last()?.to_address();
-                    accs.push(Access::new(i, READ, Code { address }));
-                }
-                OpcodeId::SELFDESTRUCT => {
-                    let address = contract_address;
-                    accs.push(Access::new(i, WRITE, Account { address }));
-                    let address = step.stack.last()?.to_address();
-                    accs.push(Access::new(i, WRITE, Account { address }));
-                }
-                OpcodeId::CREATE => {
-                    if push_call_stack {
-                        // Find CREATE result
-                        let address = get_call_result(&geth_trace.struct_logs[index..])
-                            .unwrap_or_else(Word::zero)
-                            .to_address();
-                        if !address.is_zero() {
-                            accs.push(Access::new(i, WRITE, Account { address }));
-                            accs.push(Access::new(i, WRITE, Code { address }));
-                        }
-                        call_stack.push((address, CodeSource::Address(address)));
-                    }
-                }
-                OpcodeId::CREATE2 => {
-                    if push_call_stack {
-                        // Find CREATE2 result
-                        let address = get_call_result(&geth_trace.struct_logs[index..])
-                            .unwrap_or_else(Word::zero)
-                            .to_address();
-                        if !address.is_zero() {
-                            accs.push(Access::new(i, WRITE, Account { address }));
-                            accs.push(Access::new(i, WRITE, Code { address }));
-                        }
-                        call_stack.push((address, CodeSource::Address(address)));
-                    }
-                }
-                OpcodeId::CALL => {
-                    let address = contract_address;
-                    accs.push(Access::new(i, WRITE, Account { address }));
-
-                    let address = step.stack.nth_last(1)?.to_address();
-                    accs.push(Access::new(i, WRITE, Account { address }));
-                    accs.push(Access::new(i, READ, Code { address }));
-                    if push_call_stack {
-                        call_stack.push((address, CodeSource::Address(address)));
-                    }
-                }
-                OpcodeId::CALLCODE => {
-                    let address = contract_address;
-                    accs.push(Access::new(i, WRITE, Account { address }));
-
-                    let address = step.stack.nth_last(1)?.to_address();
-                    accs.push(Access::new(i, WRITE, Account { address }));
-                    accs.push(Access::new(i, READ, Code { address }));
-                    if push_call_stack {
-                        call_stack.push((address, CodeSource::Address(address)));
-                    }
-                }
-                OpcodeId::DELEGATECALL => {
-                    let address = step.stack.nth_last(1)?.to_address();
-                    accs.push(Access::new(i, READ, Code { address }));
-                    if push_call_stack {
-                        call_stack.push((contract_address, CodeSource::Address(address)));
-                    }
-                }
-                OpcodeId::STATICCALL => {
-                    let address = step.stack.nth_last(1)?.to_address();
-                    accs.push(Access::new(i, READ, Code { address }));
-                    if push_call_stack {
-                        call_stack.push((address, CodeSource::Address(address)));
-                    }
-                }
-                _ => {}
-            }
-            Ok(())
-        })();
-        if let Err(e) = result {
-            log::warn!("err when parsing access: {:?}, step {:?}", e, step);
-        }
-
-        if pop_call_stack {
-            if call_stack.len() == 1 {
-                return Err(Error::InvalidGethExecStep(
-                    "gen_state_access_trace: call stack will be empty",
-                    Box::new(step.clone()),
-                ));
-            }
-            call_stack.pop().expect("call stack is empty");
-        }
-    }
-    Ok(accs)
-}

bus-mapping/src/circuit_input_builder/access.rs

@@ -878,7 +878,8 @@ impl<'a> CircuitInputStateRef<'a> {
         let call_id = call.call_id;
         let call_idx = self.tx.calls().len();
 
-        self.tx_ctx.push_call_ctx(call_idx, call_data);
+        self.tx_ctx
+            .push_call_ctx(call_idx, call_data, call.is_success);
         self.tx.push_call(call);
 
         self.block_ctx
@@ -966,7 +967,7 @@ impl<'a> CircuitInputStateRef<'a> {
         let is_success = *self
             .tx_ctx
             .call_is_success
-            .get(self.tx.calls().len())
+            .get(self.tx.calls().len() - self.tx_ctx.call_is_success_offset)
             .unwrap();
         let kind = CallKind::try_from(step.op)?;
         let caller = self.call()?;