eth/tracer,rpc: use build-in flatCallTracer (#1)

* eth/tracer,rpc: use build-in flatCallTracer

.github/workflows/lint.yml

@@ -35,10 +35,10 @@ jobs:
         run: |
           git config --global url."https://${{ steps.generate-token.outputs.token }}:x-oauth-basic@github.com/DeBankDeFi".insteadOf "https://github.com/DeBankDeFi"
 
-      - name: Golangci-lint
+      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.46.2
+          version: v1.53
           only-new-issues: true
           skip-pkg-cache: true
           skip-build-cache: true

core/blockchain.go

@@ -49,8 +49,6 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/ethereum/go-ethereum/txtrace"
-
-	txtracelib "github.com/DeBankDeFi/etherlib/pkg/txtracev2"
 )
 
 var (
@@ -175,9 +173,8 @@ var defaultCacheConfig = &CacheConfig{
 type BlockChain struct {
 	chainConfig   *params.ChainConfig // Chain & network configuration
 	cacheConfig   *CacheConfig        // Cache configuration for pruning
-	txTraceConfig *txtrace.Config
+	txTraceConfig *txtrace.Config     // Config for transaction tracing
-	// txtraceStore
+	txTraceDb     ethdb.Database      // Db for transaction tracing
-	txTraceStore txtracelib.Store
 
 	db            ethdb.Database                   // Low level persistent database to store final content in
 	snaps         *snapshot.Tree                   // Snapshot tree for fast trie leaf access
@@ -239,13 +236,13 @@ type BlockChain struct {
 // NewBlockChainV2 returns a fully initialised blockchain using information
 // available in the database. It initialises the default Ethereum Validator and
 // Processor. The different between NewBlockChainV2 and NewBlockchain are additional txtrace.Config and txtracelib.Store parameter will passed.
-func NewBlockChainV2(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(block *types.Header) bool, txLookupLimit *uint64, txTraceConfig *txtrace.Config, txStore txtracelib.Store) (*BlockChain, error) {
+func NewBlockChainV2(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis, overrides *ChainOverrides, engine consensus.Engine, vmConfig vm.Config, shouldPreserve func(block *types.Header) bool, txLookupLimit *uint64, txTraceConfig *txtrace.Config, txStore ethdb.Database) (*BlockChain, error) {
 	bc, err := NewBlockChain(db, cacheConfig, genesis, overrides, engine, vmConfig, shouldPreserve, txLookupLimit)
 	if err != nil {
 		return nil, err
 	}
 	bc.txTraceConfig = txTraceConfig
-	bc.txTraceStore = txStore
+	bc.txTraceDb = txStore
 	return bc, nil
 }
 
@@ -481,10 +478,6 @@ func (bc *BlockChain) empty() bool {
 	return true
 }
 
-func (bc *BlockChain) tracingTx() bool {
-	return bc.txTraceConfig != nil && bc.txTraceConfig.Enabled
-}
-
 // loadLastState loads the last known chain state from the database. This method
 // assumes that the chain manager mutex is held.
 func (bc *BlockChain) loadLastState() error {
@@ -1792,7 +1785,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals, setHead bool)
 
 		// Process block using the parent state as reference point
 		pstart := time.Now()
-		receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig, bc.tracingTx())
+		receipts, logs, usedGas, err := bc.processor.Process(block, statedb, bc.vmConfig)
 		if err != nil {
 			bc.reportBlock(block, receipts, err)
 			followupInterrupt.Store(true)
@@ -2524,8 +2517,8 @@ func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (i
 	return 0, err
 }
 
-// TxTraceStore retrieves the blockchain's tx-trace store.
+// TxTraceDB retrieves the blockchain's tx-trace db.
-func (bc *BlockChain) TxTraceStore() txtracelib.Store { return bc.txTraceStore }
+func (bc *BlockChain) TxTraceDB() ethdb.Database { return bc.txTraceDb }
 
 // SetBlockValidatorAndProcessorForTesting sets the current validator and processor.
 // This method can be used to force an invalid blockchain to be verified for tests.

core/blockchain_test.go

@@ -162,7 +162,7 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
 		if err != nil {
 			return err
 		}
-		receipts, _, usedGas, err := blockchain.processor.Process(block, statedb, vm.Config{}, false)
+		receipts, _, usedGas, err := blockchain.processor.Process(block, statedb, vm.Config{})
 		if err != nil {
 			blockchain.reportBlock(block, receipts, err)
 			return err
@@ -792,7 +792,7 @@ func TestFastVsFullChains(t *testing.T) {
 		t.Fatalf("failed to insert receipt %d: %v", n, err)
 	}
 	// Freezer style fast import the chain.
-	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -881,7 +881,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 
 	// makeDb creates a db instance for testing.
 	makeDb := func() ethdb.Database {
-		db, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+		db, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 		if err != nil {
 			t.Fatalf("failed to create temp freezer db: %v", err)
 		}
@@ -1770,7 +1770,7 @@ func TestBlockchainRecovery(t *testing.T) {
 	_, blocks, receipts := GenerateChainWithGenesis(gspec, ethash.NewFaker(), int(height), nil)
 
 	// Import the chain as a ancient-first node and ensure all pointers are updated
-	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -1836,7 +1836,7 @@ func TestInsertReceiptChainRollback(t *testing.T) {
 	}
 
 	// Set up a BlockChain that uses the ancient store.
-	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -2106,7 +2106,7 @@ func testInsertKnownChainData(t *testing.T, typ string) {
 		b.OffsetTime(-9) // A higher difficulty
 	})
 	// Import the shared chain and the original canonical one
-	chaindb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	chaindb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -2277,7 +2277,7 @@ func testInsertKnownChainDataWithMerging(t *testing.T, typ string, mergeHeight i
 		}
 	})
 	// Import the shared chain and the original canonical one
-	chaindb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	chaindb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -2581,7 +2581,7 @@ func TestTransactionIndices(t *testing.T) {
 	limit := []uint64{0, 32, 64, 128}
 	for _, l := range limit {
 		frdir := t.TempDir()
-		ancientDb, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), frdir, "", false)
+		ancientDb, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), frdir, "", false, false)
 		rawdb.WriteAncientBlocks(ancientDb, append([]*types.Block{gspec.ToBlock()}, blocks...), append([]types.Receipts{{}}, receipts...), big.NewInt(0))
 
 		l := l
@@ -2602,7 +2602,7 @@ func TestTransactionIndices(t *testing.T) {
 	}
 
 	// Reconstruct a block chain which only reserves HEAD-64 tx indices
-	ancientDb, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	ancientDb, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	defer ancientDb.Close()
 
 	rawdb.WriteAncientBlocks(ancientDb, append([]*types.Block{gspec.ToBlock()}, blocks...), append([]types.Receipts{{}}, receipts...), big.NewInt(0))
@@ -2674,7 +2674,7 @@ func TestSkipStaleTxIndicesInSnapSync(t *testing.T) {
 		}
 	}
 
-	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false)
+	ancientDb, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), t.TempDir(), "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create temp freezer db: %v", err)
 	}
@@ -4017,7 +4017,7 @@ func TestTxIndexer(t *testing.T) {
 	}
 	for _, c := range cases {
 		frdir := t.TempDir()
-		db, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), frdir, "", false)
+		db, _ := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), frdir, "", false, false)
 		rawdb.WriteAncientBlocks(db, append([]*types.Block{gspec.ToBlock()}, blocks...), append([]types.Receipts{{}}, receipts...), big.NewInt(0))
 
 		// Index the initial blocks from ancient store

core/rawdb/accessors_chain_test.go

@@ -436,7 +436,7 @@ func TestAncientStorage(t *testing.T) {
 	// Freezer style fast import the chain.
 	frdir := t.TempDir()
 
-	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false)
+	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create database with ancient backend")
 	}
@@ -573,7 +573,7 @@ func TestHashesInRange(t *testing.T) {
 func BenchmarkWriteAncientBlocks(b *testing.B) {
 	// Open freezer database.
 	frdir := b.TempDir()
-	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false)
+	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false, false)
 	if err != nil {
 		b.Fatalf("failed to create database with ancient backend")
 	}
@@ -876,7 +876,7 @@ func TestHeadersRLPStorage(t *testing.T) {
 	// Have N headers in the freezer
 	frdir := t.TempDir()
 
-	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false)
+	db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "", false, false)
 	if err != nil {
 		t.Fatalf("failed to create database with ancient backend")
 	}

core/state_processor.go

@@ -24,14 +24,13 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
-
-	txtracelib "github.com/DeBankDeFi/etherlib/pkg/txtracev2"
 )
 
 // StateProcessor is a basic Processor, which takes care of transitioning
@@ -60,7 +59,7 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen
 // Process returns the receipts and logs accumulated during the process and
 // returns the amount of gas that was used in the process. If any of the
 // transactions failed to execute due to insufficient gas it will return an error.
-func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config, tracing bool) (types.Receipts, []*types.Log, uint64, error) {
+func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
 	var (
 		receipts    types.Receipts
 		usedGas     = new(uint64)
@@ -79,8 +78,18 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	// Iterate over and process the individual transactions
 	start := time.Now()
 	for i, tx := range block.Transactions() {
-		if tracing {
+		if cfg.TxTracerName != "" {
-			cfg.Tracer = txtracelib.NewOeTracer(p.bc.TxTraceStore(), header.Hash(), header.Number, tx.Hash(), uint64(statedb.TxIndex()))
+			txctx := &vm.TraceContext{
+				BlockHash:   blockHash,
+				BlockNumber: blockNumber,
+				TxIndex:     i,
+				TxHash:      tx.Hash(),
+			}
+			tracer, err := cfg.TxTracerCreateFn(&cfg.TxTracerName, txctx, cfg.TxTracerConfig)
+			if err != nil {
+				return nil, nil, 0, fmt.Errorf("could not create txtracer: %w", err)
+			}
+			cfg.Tracer = tracer
 		}
 		vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
 		msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee)
@@ -96,17 +105,24 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		allLogs = append(allLogs, receipt.Logs...)
 
 		// Finalize trace logger result and save to underlying database if necessary.
-		switch t := cfg.Tracer.(type) {
+		if cfg.TxTracerName != "" {
-		case *txtracelib.OeTracer:
+			tracer := (cfg.Tracer).(vm.EVMLoggerWithResult)
-			log.Debug("Persist oe-style trace result to database", "blockNumber", header.Number.Int64(), "txHash", tx.Hash())
+			if tracer != nil {
-			t.PersistTrace()
+				res, err := tracer.GetResult()
-		default:
+				if err != nil {
+					log.Error("could not get result from tracer", "err", err)
+				} else {
+					if res != nil {
+						rawdb.WriteTxTrace(p.bc.txTraceDb, tx.Hash(), res)
+					}
+				}
+			}
 		}
 
 	}
 
-	if tracing {
+	if cfg.TxTracerName != "" {
-		log.Info("Apply all transaction messages finished", "elapsed", common.PrettyDuration(time.Since(start)), "blockNumber", block.NumberU64(), "txs", len(block.Transactions()))
+		log.Debug("store all transaction trace messages finished", "elapsed", common.PrettyDuration(time.Since(start)), "blockNumber", block.NumberU64(), "txs", len(block.Transactions()))
 	}
 
 	// Fail if Shanghai not enabled and len(withdrawals) is non-zero.
@@ -183,24 +199,5 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
 		return nil, err
 	}
 
-	// Finalize trace logger result and save to underlying database if necessary.
-	switch t := cfg.Tracer.(type) {
-	case *txtracelib.OeTracer:
-		log.Debug("Persist oe-style trace result to database", "blockNumber", header.Number.Int64(), "txHash", tx.Hash())
-		t.PersistTrace()
-	default:
-	}
-
 	return receipt, nil
 }
-
-func ApplyTransactionForPreExec(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) {
-	msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number), header.BaseFee)
-	if err != nil {
-		return nil, err
-	}
-	blockContext := NewEVMBlockContext(header, bc, author)
-	blockContext.BaseFee = big.NewInt(0)
-	vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, config, cfg)
-	return applyTransaction(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)
-}

core/types.go

@@ -49,5 +49,5 @@ type Processor interface {
 	// Process processes the state changes according to the Ethereum rules by running
 	// the transaction messages using the statedb and applying any rewards to both
 	// the processor (coinbase) and any included uncles.
-	Process(block *types.Block, statedb *state.StateDB, cfg vm.Config, tracing bool) (types.Receipts, []*types.Log, uint64, error)
+	Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error)
 }

core/vm/interpreter.go

@@ -17,9 +17,12 @@
 package vm
 
 import (
+	"encoding/json"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -30,6 +33,11 @@ type Config struct {
 	NoBaseFee               bool      // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls)
 	EnablePreimageRecording bool      // Enables recording of SHA3/keccak preimages
 	ExtraEips               []int     // Additional EIPS that are to be enabled
+
+	TxTraceDB        ethdb.Database                                                             // TxTraceStore for tx tracing
+	TxTracerName     string                                                                     // Name of the tracer
+	TxTracerConfig   json.RawMessage                                                            // Json config of the tracer
+	TxTracerCreateFn func(*string, *TraceContext, json.RawMessage) (EVMLoggerWithResult, error) // fn for create tracer
 }
 
 // ScopeContext contains the things that are per-call, such as stack and memory,

core/vm/logger.go

@@ -17,6 +17,8 @@
 package vm
 
 import (
+	"context"
+	"encoding/json"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -41,3 +43,27 @@ type EVMLogger interface {
 	CaptureState(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, rData []byte, depth int, err error)
 	CaptureFault(pc uint64, op OpCode, gas, cost uint64, scope *ScopeContext, depth int, err error)
 }
+
+// TraceContext contains some contextual infos for a transaction execution that is not
+// available from within the EVM object.
+type TraceContext struct {
+	BlockHash   common.Hash // Hash of the block the tx is contained within (zero if dangling tx or call)
+	BlockNumber *big.Int    // Number of the block the tx is contained within (zero if dangling tx or call)
+	TxIndex     int         // Index of the transaction within a block (zero if dangling tx or call)
+	TxHash      common.Hash // Hash of the transaction being traced (zero if dangling call)
+}
+
+// EVMLoggerWithResult interface extends vm.EVMLogger and additionally
+// allows collecting the tracing result.
+type EVMLoggerWithResult interface {
+	EVMLogger
+	GetResult() (json.RawMessage, error)
+}
+
+// Store contains all the methods for tx-trace to interact with the underlying database.
+type TxTraceStore interface {
+	// ReadTxTrace retrieve tracing result from underlying database.
+	ReadTxTrace(ctx context.Context, txHash common.Hash) ([]byte, error)
+	// WriteTxTrace write tracing result to underlying database.
+	WriteTxTrace(ctx context.Context, txHash common.Hash, trace []byte) error
+}

eth/api_pre_exec.go

@@ -2,19 +2,20 @@ package eth
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"math"
 	"math/big"
 	"math/rand"
 	"strings"
 
-	txtrace2 "github.com/DeBankDeFi/etherlib/pkg/txtracev2"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/rpc"
 )
@@ -85,11 +86,11 @@ func toPreError(err error, result *core.ExecutionResult) PreError {
 }
 
 type PreResult struct {
-	Trace     txtrace2.ActionTraceList `json:"trace"`
+	Trace     interface{}  `json:"trace"`
-	Logs      []*types.Log             `json:"logs"`
+	Logs      []*types.Log `json:"logs"`
-	StateDiff txtrace2.StateDiff       `json:"stateDiff"`
+	StateDiff interface{}  `json:"stateDiff,omitempty"`
-	Error     PreError                 `json:"error,omitempty"`
+	Error     PreError     `json:"error,omitempty"`
-	GasUsed   uint64                   `json:"gasUsed"`
+	GasUsed   uint64       `json:"gasUsed"`
 }
 
 func (api *PreExecAPI) TraceMany(ctx context.Context, origins []PreArgs) ([]PreResult, error) {
@@ -142,7 +143,15 @@ func (api *PreExecAPI) TraceMany(ctx context.Context, origins []PreArgs) ([]PreR
 			continue
 		}
 		txHash := common.BigToHash(big.NewInt(int64(i)))
-		tracer := txtrace2.NewOeTracer(nil, header.Hash(), header.Number, txHash, uint64(i))
+		tracer, err := tracers.DefaultDirectory.New("flatCallTracer", &tracers.Context{
+			BlockHash:   header.Hash(),
+			BlockNumber: big.NewInt(0).Set(header.Number),
+			TxIndex:     0,
+			TxHash:      txHash,
+		}, nil)
+		if err != nil {
+			return nil, err
+		}
 		evm, vmError, err := api.e.APIBackend.GetEVM(ctx, msg, state, header, &vm.Config{NoBaseFee: true, Tracer: tracer, PreExec: true})
 		evm.Context.BaseFee = big.NewInt(0)
 		evm.Context.BlockNumber.Add(evm.Context.BlockNumber, big.NewInt(rand.Int63n(6)+6))
@@ -180,10 +189,31 @@ func (api *PreExecAPI) TraceMany(ctx context.Context, origins []PreArgs) ([]PreR
 			preResList = append(preResList, preRes)
 			continue
 		}
+		rawRes, err := tracer.GetResult()
+		if err != nil {
+			preRes := PreResult{
+				Error: toPreError(err, result),
+			}
+			if result != nil {
+				preRes.GasUsed = result.UsedGas
+			}
+			preResList = append(preResList, preRes)
+			continue
+		}
+		var res []map[string]interface{}
+		if err := json.Unmarshal(rawRes, &res); err != nil {
+			preRes := PreResult{
+				Error: toPreError(err, result),
+			}
+			if result != nil {
+				preRes.GasUsed = result.UsedGas
+			}
+			preResList = append(preResList, preRes)
+			continue
+		}
 		preRes := PreResult{
-			Trace:     tracer.GetTraces(),
+			Trace: res,
-			Logs:      state.GetLogs(txHash, header.Number.Uint64(), header.Hash()),
+			Logs:  state.GetLogs(txHash, header.Number.Uint64(), header.Hash()),
-			StateDiff: tracer.GetStateDiff(),
 		}
 		if result != nil {
 			preRes.GasUsed = result.UsedGas
@@ -192,10 +222,10 @@ func (api *PreExecAPI) TraceMany(ctx context.Context, origins []PreArgs) ([]PreR
 			}
 		}
 
-		if preRes.Error.Msg == "" && len(preRes.Trace) > 0 && (preRes.Trace)[0].Error != "" {
+		if preRes.Error.Msg == "" && len(res) > 0 && (res)[0]["error"] != nil {
 			preRes.Error = PreError{
 				Code: Reverted,
-				Msg:  (preRes.Trace)[0].Error,
+				Msg:  fmt.Sprintf("%s", (res)[0]["error"]),
 			}
 		}
 		preResList = append(preResList, preRes)

eth/api_tx_trace.go

@@ -21,12 +21,11 @@ package eth
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/core/rawdb"
-
-	txtracelib "github.com/DeBankDeFi/etherlib/pkg/txtracev2"
 )
 
 // PublicTxTraceAPI provides an API to tracing transaction or block information.
@@ -45,21 +44,15 @@ func (api *PublicTxTraceAPI) Transaction(ctx context.Context, txHash common.Hash
 	if api.e.blockchain == nil {
 		return []byte{}, fmt.Errorf("blockchain corruput")
 	}
-
+	traceDb := api.e.blockchain.TxTraceDB()
-	raw, err := api.e.blockchain.TxTraceStore().ReadTxTrace(ctx, txHash)
+	raw := rawdb.ReadTxTrace(traceDb, txHash)
-	if err != nil {
-		return []byte{}, err
-	}
-
 	if bytes.Equal(raw, []byte{}) { // empty response
 		return nil, fmt.Errorf("trace result of tx {%#v} not found in tracedb", txHash)
 	}
-
+	var res interface{}
-	flatten := new(txtracelib.ActionTraceList)
+	err := json.Unmarshal(raw, &res)
-	err = rlp.DecodeBytes(raw, flatten)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decode rlp flatten traces: %v", err)
+		return nil, err
 	}
-
+	return res, nil
-	return *flatten, nil
 }

eth/backend.go

@@ -18,6 +18,7 @@
 package eth
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
@@ -44,6 +45,7 @@ import (
 	"github.com/ethereum/go-ethereum/eth/gasprice"
 	"github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/eth/protocols/snap"
+	"github.com/ethereum/go-ethereum/eth/tracers"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
@@ -57,7 +59,6 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/txtrace"
 )
 
 // Config contains the configuration options of the ETH protocol.
@@ -133,15 +134,6 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	if err != nil {
 		return nil, err
 	}
-	// Init tx-trace underlying database and storage layer
-	var traceDb ethdb.Database
-	if config.TxTrace.Enabled {
-		traceDb, err = stack.OpenDatabaseWithTrace(config.DatabaseCache, config.DatabaseHandles, config.TxTrace.StoreDir, "eth/db/tracedb", false)
-		if err != nil {
-			return nil, err
-		}
-	}
-	txStore := txtrace.NewTraceStore(traceDb)
 
 	if err := pruner.RecoverPruning(stack.ResolvePath(""), chainDb, stack.ResolvePath(config.TrieCleanCacheJournal)); err != nil {
 		log.Error("Failed to recover state", "error", err)
@@ -207,12 +199,35 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 			AncientPrune:        config.AncientPrune,
 		}
 	)
+	var traceDB ethdb.Database
+	if config.TxTrace.Enabled {
+		traceDB, err = stack.OpenDatabaseWithTrace(config.DatabaseCache, config.DatabaseHandles, config.TxTrace.StoreDir, "eth/db/tracedb", false)
+		if err != nil {
+			return nil, err
+		}
+		vmConfig.TxTraceDB = traceDB
+		vmConfig.TxTracerName = "flatCallTracer"
+		tracerConfigdata, _ := json.Marshal(map[string]interface{}{
+			"convertParityErrors": true,
+			"includePrecompiles":  true,
+		})
+		vmConfig.TxTracerConfig = tracerConfigdata
+		vmConfig.TxTracerCreateFn = func(name *string, tc *vm.TraceContext, config json.RawMessage) (vm.EVMLoggerWithResult, error) {
+			return tracers.DefaultDirectory.New(*name, &tracers.Context{
+				BlockHash:   tc.BlockHash,
+				BlockNumber: tc.BlockNumber,
+				TxIndex:     tc.TxIndex,
+				TxHash:      tc.TxHash,
+			}, config)
+		}
+	}
+
 	// Override the chain config with provided settings.
 	var overrides core.ChainOverrides
 	if config.OverrideShanghai != nil {
 		overrides.OverrideShanghai = config.OverrideShanghai
 	}
-	eth.blockchain, err = core.NewBlockChainV2(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, &config.TxTrace, txStore)
+	eth.blockchain, err = core.NewBlockChainV2(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, &config.TxTrace, traceDB)
 	if err != nil {
 		return nil, err
 	}

eth/downloader/downloader_test.go

@@ -61,7 +61,7 @@ func newTester(t *testing.T) *downloadTester {
 // newTester creates a new downloader test mocker.
 func newTesterWithNotification(t *testing.T, success func()) *downloadTester {
 	freezer := t.TempDir()
-	db, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), freezer, "", false)
+	db, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), freezer, "", false, false)
 	if err != nil {
 		panic(err)
 	}

eth/state_accessor.go

@@ -159,7 +159,7 @@ func (eth *Ethereum) StateAtBlock(ctx context.Context, block *types.Block, reexe
 		if current = eth.blockchain.GetBlockByNumber(next); current == nil {
 			return nil, nil, fmt.Errorf("block #%d not found", next)
 		}
-		_, _, _, err := eth.blockchain.Processor().Process(current, statedb, vm.Config{}, false)
+		_, _, _, err := eth.blockchain.Processor().Process(current, statedb, vm.Config{})
 		if err != nil {
 			return nil, nil, fmt.Errorf("processing block %d failed: %v", current.NumberU64(), err)
 		}

go.mod

@@ -4,7 +4,6 @@ go 1.19
 
 require (
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.3.0
-	github.com/DeBankDeFi/etherlib v0.2.7
 	github.com/VictoriaMetrics/fastcache v1.6.0
 	github.com/aws/aws-sdk-go-v2 v1.2.0
 	github.com/aws/aws-sdk-go-v2/config v1.1.1

go.sum

@@ -12,8 +12,6 @@ github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3
 github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo=
 github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8=
 github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
-github.com/DeBankDeFi/etherlib v0.2.7 h1:Yk3v2VlT22ifM/ARLT3HNtxMhIoKSWON47TzhYVkQkc=
-github.com/DeBankDeFi/etherlib v0.2.7/go.mod h1:Q/pkoKm4oZu9UOhLm07Zg7sxXvnLI3GdOoK4bE2t+xI=
 github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
 github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8=

internal/ethapi/transaction_args_test.go

@@ -343,3 +343,10 @@ func (b *backendMock) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent)
 }
 
 func (b *backendMock) Engine() consensus.Engine { return nil }
+
+func (b *backendMock) GetCallCache(key string) (interface{}, bool) {
+	return nil, false
+}
+
+func (b *backendMock) SetCallCache(key string, value interface{}, weight int64) {
+}

txtrace/store.go

@@ -1,92 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package txtrace
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/metrics"
-
-	txtrace "github.com/DeBankDeFi/etherlib/pkg/txtracev2"
-)
-
-var (
-	txTraceWriteSuccessCounter = metrics.NewRegisteredCounter("chain/txtraces/write/success", nil)
-	txTraceWriteFailCounter    = metrics.NewRegisteredCounter("chain/txtraces/write/fail", nil)
-)
-
-var (
-	once              sync.Once
-	defaultTraceStore *traceStore
-)
-
-var _ txtrace.Store = (*traceStore)(nil)
-
-type traceStore struct {
-	db ethdb.Database
-}
-
-// NewTraceStore creates a new trace store.
-func NewTraceStore(db ethdb.Database) txtrace.Store {
-	if defaultTraceStore != nil {
-		return defaultTraceStore
-	}
-	once.Do(func() {
-		defaultTraceStore = &traceStore{db: db}
-	})
-	return defaultTraceStore
-}
-
-// GetTraceStore get singleton traceStore.
-func GetTraceStore() *traceStore {
-	return defaultTraceStore
-}
-
-func (t *traceStore) guard() error {
-	if t.db == nil {
-		return fmt.Errorf("txtrace mode not enabled")
-	}
-	return nil
-}
-
-// ReadTxTrace retrieves the result of tx by evm-tracing which stores in db.
-func (t *traceStore) ReadTxTrace(ctx context.Context, txHash common.Hash) ([]byte, error) {
-	if err := t.guard(); err != nil {
-		return []byte{}, err
-	}
-	data := rawdb.ReadTxTrace(t.db, txHash)
-	return data, nil
-}
-
-// WriteTxTrace write the result of tx tracing by evm-tracing to db.
-func (t *traceStore) WriteTxTrace(ctx context.Context, txHash common.Hash, trace []byte) error {
-	if err := t.guard(); err != nil {
-		return err
-	}
-	err := rawdb.WriteTxTrace(t.db, txHash, trace)
-	if err == nil {
-		txTraceWriteSuccessCounter.Inc(1)
-		return nil
-	}
-	txTraceWriteFailCounter.Inc(1)
-	return err
-}