tmp

Author: lightsing

bus-mapping/src/circuit_input_builder.rs

@@ -947,6 +947,7 @@ pub struct BuilderClient<P: JsonRpcClient> {
 }
 
 /// Get State Accesses from TxExecTraces
+#[deprecated]
 pub fn get_state_accesses(
     eth_block: &EthBlock,
     geth_traces: &[eth_types::GethExecTrace],

bus-mapping/src/circuit_input_builder/access.rs

@@ -5,6 +5,7 @@ use eth_types::{
 use ethers_core::utils::get_contract_address;
 use std::collections::{hash_map::Entry, HashMap, HashSet};
 
+use eth_types::geth_types::GethData;
 use AccessValue::{Account, Code, Storage};
 use RW::{READ, WRITE};
 
@@ -119,6 +120,30 @@ impl AccessSet {
         self.state.extend(other.state.drain());
         self.code.extend(other.code.drain());
     }
+
+    pub(crate) fn from_l1_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
+    }
+
+    pub(crate) fn from_l2_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);
+            }
+        }
+        access_set
+    }
 }
 
 impl From<Vec<Access>> for AccessSet {
@@ -149,6 +174,7 @@ impl Default for CodeSource {
 /// Generate the State Access trace from the given trace.  All state read/write
 /// accesses are reported, without distinguishing those that happen in revert
 /// sections.
+#[deprecated]
 pub fn gen_state_access_trace<TX>(
     _block: &eth_types::Block<TX>,
     tx: &eth_types::Transaction,

bus-mapping/src/circuit_input_builder/tracer_tests.rs

@@ -52,6 +52,7 @@ impl CircuitInputBuilderTx {
                 return_value: "".to_owned(),
                 struct_logs: vec![geth_step.clone()],
                 account_after: vec![],
+                prestate: None,
             },
             false,
         )

bus-mapping/src/mock.rs

@@ -57,10 +57,50 @@ impl BlockData {
         let mut sdb = StateDB::new();
         let mut code_db = CodeDB::new();
 
-        let access_set: AccessSet =
-            get_state_accesses(&geth_data.eth_block, &geth_data.geth_traces)
-                .expect("state accesses")
-                .into();
+        let access_set = {
+            // let old_access_set: AccessSet =
+            //     get_state_accesses(&geth_data.eth_block, &geth_data.geth_traces)
+            //         .expect("state accesses")
+            //         .into();
+            let access_set = AccessSet::from_l2_geth_data(&geth_data);
+            // for addr in old_access_set.code.iter() {
+            //     assert!(
+            //         access_set.code.contains(addr),
+            //         "code {:?} is not in access_set",
+            //         addr
+            //     );
+            // }
+            // for (addr, states) in old_access_set.state.iter() {
+            //     assert!(
+            //         access_set.state.contains_key(addr),
+            //         "state {:?} is not in access_set",
+            //         addr
+            //     );
+            //     for state in states {
+            //         assert!(
+            //             access_set.state.get(addr).unwrap().contains(state),
+            //             "state {:?} is not in access_set",
+            //             state
+            //         );
+            //     }
+            // }
+            // for addr in access_set.code.iter() {
+            //     if !old_access_set.code.contains(addr) {
+            //         log::error!("code {:?} is not in old_access_set", addr);
+            //     }
+            // }
+            // for (addr, states) in access_set.state.iter() {
+            //     if !old_access_set.state.contains_key(addr) {
+            //         log::error!("state {:?} is not in old_access_set", addr);
+            //     }
+            //     for state in states {
+            //         if !old_access_set.state.get(addr).unwrap().contains(state) {
+            //             log::error!("state {:?} is not in old_access_set", state);
+            //         }
+            //     }
+            // }
+            access_set
+        };
         // Initialize all accesses accounts to zero
         for addr in access_set.state.keys() {
             sdb.set_account(addr, state_db::Account::zero());

eth-types/src/geth_types.rs

@@ -1,6 +1,7 @@
 //! Types needed for generating Ethereum traces
 
 use crate::{
+    l2_types::BlockTrace,
     sign_types::{biguint_to_32bytes_le, ct_option_ok_or, recover_pk, SignData, SECP256K1_Q},
     AccessList, Address, Block, Bytes, Error, GethExecTrace, Hash, ToBigEndian, ToLittleEndian,
     Word, U64,
@@ -385,6 +386,9 @@ pub struct GethData {
     pub geth_traces: Vec<GethExecTrace>,
     /// Accounts
     pub accounts: Vec<Account>,
+    /// block trace
+    #[cfg(feature = "scroll")]
+    pub block_trace: BlockTrace,
 }
 /*
 impl GethData {

eth-types/src/l2_types.rs

@@ -209,6 +209,7 @@ impl From<ExecutionResult> for GethExecTrace {
             return_value: e.return_value,
             struct_logs,
             account_after: e.account_after,
+            prestate: None,
         }
     }
 }

eth-types/src/lib.rs

@@ -471,6 +471,7 @@ pub struct ResultGethExecTrace {
 /// the memory size before the expansion, so that it corresponds to the memory
 /// before the step is executed.
 #[derive(Deserialize, Serialize, Clone, Debug, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
 pub struct GethExecTrace {
     /// L1 fee
     #[serde(default)]
@@ -489,6 +490,8 @@ pub struct GethExecTrace {
     /// List of accounts' (coinbase etc) status AFTER execution
     /// Only viable for scroll mode
     pub account_after: Vec<crate::l2_types::AccountProofWrapper>,
+    /// prestate trace
+    pub prestate: Option<HashMap<Address, GethPrestateTrace>>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
@@ -700,6 +703,7 @@ mod tests {
                         ]),
                     }
                 ],
+                prestate: None,
             }
         );
     }

geth-utils/l1geth/trace.go

@@ -1,7 +1,9 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
+	"github.com/ethereum/go-ethereum/eth/tracers"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -12,6 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/eth/tracers/logger"
+	_ "github.com/ethereum/go-ethereum/eth/tracers/native"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/imdario/mergo"
 )
@@ -21,10 +24,11 @@ import (
 // while replaying a transaction in debug mode as well as transaction
 // execution status, the amount of gas used and the return value
 type ExecutionResult struct {
-	Gas         uint64         `json:"gas"`
-	Failed      bool           `json:"failed"`
-	ReturnValue string         `json:"returnValue"`
-	StructLogs  []StructLogRes `json:"structLogs"`
+	Gas         uint64          `json:"gas"`
+	Failed      bool            `json:"failed"`
+	ReturnValue string          `json:"returnValue"`
+	StructLogs  []StructLogRes  `json:"structLogs"`
+	Prestate    json.RawMessage `json:"prestate"`
 }
 
 // StructLogRes stores a structured log emitted by the EVM while replaying a
@@ -236,22 +240,92 @@ func Trace(config TraceConfig) ([]*ExecutionResult, error) {
 	// Run the transactions with tracing enabled.
 	executionResults := make([]*ExecutionResult, len(config.Transactions))
 	for i, message := range messages {
-		tracer := logger.NewStructLogger(config.LoggerConfig)
-		evm := vm.NewEVM(blockCtx, core.NewEVMTxContext(&message), stateDB, &chainConfig, vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true})
+		txContext := core.NewEVMTxContext(&message)
+		prestateTracer, err := tracers.DefaultDirectory.New("prestateTracer", new(tracers.Context), nil)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to create prestateTracer: %w", err)
+		}
+		structLogger := logger.NewStructLogger(config.LoggerConfig)
+		tracer := NewMuxTracer(
+			structLogger,
+			prestateTracer,
+		)
+		evm := vm.NewEVM(blockCtx, txContext, stateDB, &chainConfig, vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true})
 
 		result, err := core.ApplyMessage(evm, &message, new(core.GasPool).AddGas(message.GasLimit))
 		if err != nil {
 			return nil, fmt.Errorf("Failed to apply config.Transactions[%d]: %w", i, err)
 		}
 		stateDB.Finalise(true)
 
+		prestate, err := prestateTracer.GetResult()
+		if err != nil {
+			return nil, fmt.Errorf("Failed to get prestateTracer result: %w", err)
+		}
 		executionResults[i] = &ExecutionResult{
 			Gas:         result.UsedGas,
 			Failed:      result.Failed(),
 			ReturnValue: fmt.Sprintf("%x", result.ReturnData),
-			StructLogs:  FormatLogs(tracer.StructLogs()),
+			StructLogs:  FormatLogs(structLogger.StructLogs()),
+			Prestate:    prestate,
 		}
 	}
 
 	return executionResults, nil
 }
+
+type MuxTracer struct {
+	tracers []vm.EVMLogger
+}
+
+func NewMuxTracer(tracers ...vm.EVMLogger) *MuxTracer {
+	return &MuxTracer{tracers}
+}
+
+func (t *MuxTracer) CaptureTxStart(gasLimit uint64) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureTxStart(gasLimit)
+	}
+}
+
+func (t *MuxTracer) CaptureTxEnd(restGas uint64) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureTxEnd(restGas)
+	}
+}
+
+func (t *MuxTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureStart(env, from, to, create, input, gas, value)
+	}
+}
+
+func (t *MuxTracer) CaptureEnd(output []byte, gasUsed uint64, err error) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureEnd(output, gasUsed, err)
+	}
+}
+
+func (t *MuxTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureEnter(typ, from, to, input, gas, value)
+	}
+}
+
+func (t *MuxTracer) CaptureExit(output []byte, gasUsed uint64, err error) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureExit(output, gasUsed, err)
+	}
+}
+
+func (t *MuxTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureState(pc, op, gas, cost, scope, rData, depth, err)
+	}
+}
+
+func (t *MuxTracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) {
+	for _, tracer := range t.tracers {
+		tracer.CaptureFault(pc, op, gas, cost, scope, depth, err)
+	}
+}

integration-tests/tests/circuit_input_builder.rs

@@ -37,12 +37,12 @@ async fn test_circuit_input_builder_block(block_num: u64) {
     let (eth_block, geth_trace, history_hashes, prev_state_root) =
         cli.get_block(block_num).await.unwrap();
 
-    // 2. Get State Accesses from TxExecTraces
-    let access_set = get_state_accesses(&eth_block, &geth_trace).unwrap();
+    // 2. Query State Accesses
+    let access_set = cli.get_state_accesses(&eth_block).await.unwrap();
     trace!("AccessSet: {:#?}", access_set);
 
     // 3. Query geth for all accounts, storage keys, and codes from Accesses
-    let (proofs, codes) = cli.get_state(block_num, access_set.into()).await.unwrap();
+    let (proofs, codes) = cli.get_state(block_num, access_set).await.unwrap();
 
     // 4. Build a partial StateDB from step 3
     let (state_db, code_db) = build_state_code_db(proofs, codes);

mock/src/test_ctx.rs

@@ -95,7 +95,6 @@ pub struct TestContext<const NACC: usize, const NTX: usize> {
     pub eth_block: eth_types::Block<eth_types::Transaction>,
     /// Execution Trace from geth
     pub geth_traces: Vec<eth_types::GethExecTrace>,
-
     #[cfg(feature = "scroll")]
     block_trace: BlockTrace,
 }
@@ -108,6 +107,7 @@ impl<const NACC: usize, const NTX: usize> From<TestContext<NACC, NTX>> for GethD
             eth_block: ctx.eth_block,
             geth_traces: ctx.geth_traces.to_vec(),
             accounts: ctx.accounts.into(),
+            block_trace: ctx.block_trace,
         }
     }
 }