tmp

Author: lightsing

bus-mapping/src/circuit_input_builder.rs

@@ -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,
@@ -946,29 +945,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<Vec<Access>, 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(block_access_trace)
-}
-
 /// Build a partial StateDB from step 3
 pub fn build_state_code_db(
     proofs: Vec<eth_types::EIP1186ProofResponse>,
@@ -1251,22 +1227,14 @@ impl<P: JsonRpcClient> BuilderClient<P> {
 
         eth_block.transactions = vec![tx.clone()];
 
-        let mut block_access_trace = vec![Access::new(
-            None,
-            RW::WRITE,
-            AccessValue::Account {
-                address: eth_block.author.unwrap(),
-            },
-        )];
-        let geth_trace = &geth_traces[0];
-        let tx_access_trace = gen_state_access_trace(
-            &eth_types::Block::<eth_types::Transaction>::default(),
-            &tx,
-            geth_trace,
-        )?;
-        block_access_trace.extend(tx_access_trace);
-
-        let access_set = AccessSet::from(block_access_trace);
+        let mut access_set = AccessSet::default();
+        access_set.add_account(
+            eth_block
+                .author
+                .ok_or(Error::EthTypeError(eth_types::Error::IncompleteBlock))?,
+        );
+        let tx_access_trace = self.cli.trace_tx_prestate(tx_hash).await?;
+        access_set.extend_from_traces(&tx_access_trace);
 
         let (proofs, codes) = self
             .get_state(tx.block_number.unwrap().as_u64(), access_set)

bus-mapping/src/circuit_input_builder/access.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, GethExecStep, 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 {
@@ -119,6 +113,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 +172,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.nth_last(0)?;
-                    accs.push(Access::new(i, WRITE, Storage { address, key }));
-                }
-                OpcodeId::SLOAD => {
-                    let address = contract_address;
-                    let key = step.stack.nth_last(0)?;
-                    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.nth_last(0)?.to_address();
-                    accs.push(Access::new(i, READ, Account { address }));
-                }
-                OpcodeId::EXTCODEHASH => {
-                    let address = step.stack.nth_last(0)?.to_address();
-                    accs.push(Access::new(i, READ, Account { address }));
-                }
-                OpcodeId::EXTCODESIZE => {
-                    let address = step.stack.nth_last(0)?.to_address();
-                    accs.push(Access::new(i, READ, Code { address }));
-                }
-                OpcodeId::EXTCODECOPY => {
-                    let address = step.stack.nth_last(0)?.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.nth_last(0)?.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)
-}