mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-19 21:31:37 +00:00
823 lines
29 KiB
Go
823 lines
29 KiB
Go
// Copyright 2017 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 eth
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"os"
|
|
"runtime"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/XinFinOrg/XDPoSChain/XDCx/tradingstate"
|
|
"github.com/XinFinOrg/XDPoSChain/common"
|
|
"github.com/XinFinOrg/XDPoSChain/common/hexutil"
|
|
"github.com/XinFinOrg/XDPoSChain/core"
|
|
"github.com/XinFinOrg/XDPoSChain/core/rawdb"
|
|
"github.com/XinFinOrg/XDPoSChain/core/state"
|
|
"github.com/XinFinOrg/XDPoSChain/core/types"
|
|
"github.com/XinFinOrg/XDPoSChain/core/vm"
|
|
"github.com/XinFinOrg/XDPoSChain/eth/tracers"
|
|
"github.com/XinFinOrg/XDPoSChain/internal/ethapi"
|
|
"github.com/XinFinOrg/XDPoSChain/log"
|
|
"github.com/XinFinOrg/XDPoSChain/rlp"
|
|
"github.com/XinFinOrg/XDPoSChain/rpc"
|
|
"github.com/XinFinOrg/XDPoSChain/trie"
|
|
)
|
|
|
|
const (
|
|
// defaultTraceTimeout is the amount of time a single transaction can execute
|
|
// by default before being forcefully aborted.
|
|
defaultTraceTimeout = 5 * time.Second
|
|
|
|
// defaultTraceReexec is the number of blocks the tracer is willing to go back
|
|
// and reexecute to produce missing historical state necessary to run a specific
|
|
// trace.
|
|
defaultTraceReexec = uint64(128)
|
|
)
|
|
|
|
// TraceConfig holds extra parameters to trace functions.
|
|
type TraceConfig struct {
|
|
*vm.LogConfig
|
|
Tracer *string
|
|
Timeout *string
|
|
Reexec *uint64
|
|
// Config specific to given tracer. Note struct logger
|
|
// config are historically embedded in main object.
|
|
TracerConfig json.RawMessage
|
|
}
|
|
|
|
// TraceCallConfig is the config for traceCall API. It holds one more
|
|
// field to override the state for tracing.
|
|
type TraceCallConfig struct {
|
|
TraceConfig
|
|
StateOverrides *ethapi.StateOverride
|
|
}
|
|
|
|
// txTraceResult is the result of a single transaction trace.
|
|
type txTraceResult struct {
|
|
Result interface{} `json:"result,omitempty"` // Trace results produced by the tracer
|
|
Error string `json:"error,omitempty"` // Trace failure produced by the tracer
|
|
}
|
|
|
|
// blockTraceTask represents a single block trace task when an entire chain is
|
|
// being traced.
|
|
type blockTraceTask struct {
|
|
statedb *state.StateDB // Intermediate state prepped for tracing
|
|
block *types.Block // Block to trace the transactions from
|
|
rootref common.Hash // Trie root reference held for this task
|
|
results []*txTraceResult // Trace results procudes by the task
|
|
}
|
|
|
|
// blockTraceResult represets the results of tracing a single block when an entire
|
|
// chain is being traced.
|
|
type blockTraceResult struct {
|
|
Block hexutil.Uint64 `json:"block"` // Block number corresponding to this trace
|
|
Hash common.Hash `json:"hash"` // Block hash corresponding to this trace
|
|
Traces []*txTraceResult `json:"traces"` // Trace results produced by the task
|
|
}
|
|
|
|
// txTraceTask represents a single transaction trace task when an entire block
|
|
// is being traced.
|
|
type txTraceTask struct {
|
|
statedb *state.StateDB // Intermediate state prepped for tracing
|
|
index int // Transaction offset in the block
|
|
}
|
|
|
|
// blockByNumber is the wrapper of the chain access function offered by the backend.
|
|
// It will return an error if the block is not found.
|
|
func (api *DebugAPI) blockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
|
|
block, err := api.eth.ApiBackend.BlockByNumber(ctx, number)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if block == nil {
|
|
return nil, fmt.Errorf("block #%d not found", number)
|
|
}
|
|
return block, nil
|
|
}
|
|
|
|
// blockByHash is the wrapper of the chain access function offered by the backend.
|
|
// It will return an error if the block is not found.
|
|
func (api *DebugAPI) blockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
|
|
block, err := api.eth.ApiBackend.BlockByHash(ctx, hash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if block == nil {
|
|
return nil, fmt.Errorf("block %s not found", hash.Hex())
|
|
}
|
|
return block, nil
|
|
}
|
|
|
|
// TraceChain returns the structured logs created during the execution of EVM
|
|
// between two blocks (excluding start) and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error) {
|
|
// Fetch the block interval that we want to trace
|
|
var from, to *types.Block
|
|
|
|
switch start {
|
|
case rpc.PendingBlockNumber:
|
|
from = api.eth.blockchain.CurrentBlock()
|
|
case rpc.LatestBlockNumber:
|
|
from = api.eth.blockchain.CurrentBlock()
|
|
default:
|
|
from = api.eth.blockchain.GetBlockByNumber(uint64(start))
|
|
}
|
|
switch end {
|
|
case rpc.PendingBlockNumber:
|
|
to = api.eth.blockchain.CurrentBlock()
|
|
case rpc.LatestBlockNumber:
|
|
to = api.eth.blockchain.CurrentBlock()
|
|
default:
|
|
to = api.eth.blockchain.GetBlockByNumber(uint64(end))
|
|
}
|
|
// Trace the chain if we've found all our blocks
|
|
if from == nil {
|
|
return nil, fmt.Errorf("starting block #%d not found", start)
|
|
}
|
|
if to == nil {
|
|
return nil, fmt.Errorf("end block #%d not found", end)
|
|
}
|
|
if from.Number().Cmp(to.Number()) >= 0 {
|
|
return nil, fmt.Errorf("end block (#%d) needs to come after start block (#%d)", end, start)
|
|
}
|
|
return api.traceChain(ctx, from, to, config)
|
|
}
|
|
|
|
// traceChain configures a new tracer according to the provided configuration, and
|
|
// executes all the transactions contained within. The return value will be one item
|
|
// per transaction, dependent on the requestd tracer.
|
|
func (api *DebugAPI) traceChain(ctx context.Context, start, end *types.Block, config *TraceConfig) (*rpc.Subscription, error) {
|
|
// Tracing a chain is a **long** operation, only do with subscriptions
|
|
notifier, supported := rpc.NotifierFromContext(ctx)
|
|
if !supported {
|
|
return &rpc.Subscription{}, rpc.ErrNotificationsUnsupported
|
|
}
|
|
sub := notifier.CreateSubscription()
|
|
|
|
// Ensure we have a valid starting state before doing any work
|
|
origin := start.NumberU64()
|
|
database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16, Preimages: true})
|
|
|
|
if number := start.NumberU64(); number > 0 {
|
|
start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1)
|
|
if start == nil {
|
|
return nil, fmt.Errorf("parent block #%d not found", number-1)
|
|
}
|
|
}
|
|
statedb, err := state.New(start.Root(), database)
|
|
var XDCxState *tradingstate.TradingStateDB
|
|
if err != nil {
|
|
// If the starting state is missing, allow some number of blocks to be reexecuted
|
|
reexec := defaultTraceReexec
|
|
if config != nil && config.Reexec != nil {
|
|
reexec = *config.Reexec
|
|
}
|
|
// Find the most recent block that has the state available
|
|
for i := uint64(0); i < reexec; i++ {
|
|
start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1)
|
|
if start == nil {
|
|
break
|
|
}
|
|
if statedb, err = state.New(start.Root(), database); err == nil {
|
|
XDCxState, err = tradingstate.New(start.Root(), tradingstate.NewDatabase(api.eth.XDCX.GetLevelDB()))
|
|
if err == nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
// If we still don't have the state available, bail out
|
|
if err != nil {
|
|
switch err.(type) {
|
|
case *trie.MissingNodeError:
|
|
return nil, errors.New("required historical state unavailable")
|
|
default:
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
// Execute all the transaction contained within the chain concurrently for each block
|
|
blocks := int(end.NumberU64() - origin)
|
|
|
|
threads := runtime.NumCPU()
|
|
if threads > blocks {
|
|
threads = blocks
|
|
}
|
|
var (
|
|
pend = new(sync.WaitGroup)
|
|
tasks = make(chan *blockTraceTask, threads)
|
|
results = make(chan *blockTraceTask, threads)
|
|
)
|
|
for th := 0; th < threads; th++ {
|
|
pend.Add(1)
|
|
go func() {
|
|
defer pend.Done()
|
|
|
|
// Fetch and execute the next block trace tasks
|
|
for task := range tasks {
|
|
signer := types.MakeSigner(api.config, task.block.Number())
|
|
blockCtx := core.NewEVMBlockContext(task.block.Header(), api.eth.blockchain, nil)
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(task.statedb)
|
|
// Trace all the transactions contained within
|
|
for i, tx := range task.block.Transactions() {
|
|
var balance *big.Int
|
|
if tx.To() != nil {
|
|
if value, ok := feeCapacity[*tx.To()]; ok {
|
|
balance = value
|
|
}
|
|
}
|
|
header := task.block.Header()
|
|
msg, _ := tx.AsMessage(signer, balance, header.Number, header.BaseFee)
|
|
txctx := &tracers.Context{
|
|
BlockHash: task.block.Hash(),
|
|
TxIndex: i,
|
|
TxHash: tx.Hash(),
|
|
}
|
|
res, err := api.traceTx(ctx, msg, txctx, blockCtx, task.statedb, config)
|
|
if err != nil {
|
|
task.results[i] = &txTraceResult{Error: err.Error()}
|
|
log.Warn("Tracing failed", "hash", tx.Hash(), "block", task.block.NumberU64(), "err", err)
|
|
break
|
|
}
|
|
task.statedb.DeleteSuicides()
|
|
task.results[i] = &txTraceResult{Result: res}
|
|
}
|
|
// Stream the result back to the user or abort on teardown
|
|
results <- task
|
|
}
|
|
}()
|
|
}
|
|
// Start a goroutine to feed all the blocks into the tracers
|
|
begin := time.Now()
|
|
|
|
go func() {
|
|
var (
|
|
logged time.Time
|
|
number uint64
|
|
traced uint64
|
|
failed error
|
|
proot common.Hash
|
|
)
|
|
// Ensure everything is properly cleaned up on any exit path
|
|
defer func() {
|
|
close(tasks)
|
|
pend.Wait()
|
|
|
|
switch {
|
|
case failed != nil:
|
|
log.Warn("Chain tracing failed", "start", start.NumberU64(), "end", end.NumberU64(), "transactions", traced, "elapsed", time.Since(begin), "err", failed)
|
|
case number < end.NumberU64():
|
|
log.Warn("Chain tracing aborted", "start", start.NumberU64(), "end", end.NumberU64(), "abort", number, "transactions", traced, "elapsed", time.Since(begin))
|
|
default:
|
|
log.Info("Chain tracing finished", "start", start.NumberU64(), "end", end.NumberU64(), "transactions", traced, "elapsed", time.Since(begin))
|
|
}
|
|
close(results)
|
|
}()
|
|
// Feed all the blocks both into the tracer, as well as fast process concurrently
|
|
for number = start.NumberU64() + 1; number <= end.NumberU64(); number++ {
|
|
// Print progress logs if long enough time elapsed
|
|
if time.Since(logged) > 8*time.Second {
|
|
if number > origin {
|
|
memory, _ := database.TrieDB().Size()
|
|
log.Info("Tracing chain segment", "start", origin, "end", end.NumberU64(), "current", number, "transactions", traced, "elapsed", time.Since(begin), "memory", memory)
|
|
} else {
|
|
log.Info("Preparing state for chain trace", "block", number, "start", origin, "elapsed", time.Since(begin))
|
|
}
|
|
logged = time.Now()
|
|
}
|
|
// Retrieve the next block to trace
|
|
block := api.eth.blockchain.GetBlockByNumber(number)
|
|
if block == nil {
|
|
failed = fmt.Errorf("block #%d not found", number)
|
|
break
|
|
}
|
|
// Send the block over to the concurrent tracers (if not in the fast-forward phase)
|
|
if number > origin {
|
|
txs := block.Transactions()
|
|
|
|
tasks <- &blockTraceTask{statedb: statedb.Copy(), block: block, rootref: proot, results: make([]*txTraceResult, len(txs))}
|
|
traced += uint64(len(txs))
|
|
}
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(statedb)
|
|
// Generate the next state snapshot fast without tracing
|
|
_, _, _, err := api.eth.blockchain.Processor().Process(block, statedb, XDCxState, vm.Config{}, feeCapacity)
|
|
if err != nil {
|
|
failed = err
|
|
break
|
|
}
|
|
// Finalize the state so any modifications are written to the trie
|
|
root, err := statedb.Commit(true)
|
|
if err != nil {
|
|
failed = err
|
|
break
|
|
}
|
|
if err := statedb.Reset(root); err != nil {
|
|
failed = err
|
|
break
|
|
}
|
|
// Reference the trie twice, once for us, once for the trancer
|
|
database.TrieDB().Reference(root, common.Hash{})
|
|
if number >= origin {
|
|
database.TrieDB().Reference(root, common.Hash{})
|
|
}
|
|
// Dereference all past tries we ourselves are done working with
|
|
database.TrieDB().Dereference(proot)
|
|
proot = root
|
|
}
|
|
}()
|
|
|
|
// Keep reading the trace results and stream the to the user
|
|
go func() {
|
|
var (
|
|
done = make(map[uint64]*blockTraceResult)
|
|
next = origin + 1
|
|
)
|
|
for res := range results {
|
|
// Queue up next received result
|
|
result := &blockTraceResult{
|
|
Block: hexutil.Uint64(res.block.NumberU64()),
|
|
Hash: res.block.Hash(),
|
|
Traces: res.results,
|
|
}
|
|
done[uint64(result.Block)] = result
|
|
|
|
// Dereference any paret tries held in memory by this task
|
|
database.TrieDB().Dereference(res.rootref)
|
|
|
|
// Stream completed traces to the user, aborting on the first error
|
|
for result, ok := done[next]; ok; result, ok = done[next] {
|
|
if len(result.Traces) > 0 || next == end.NumberU64() {
|
|
notifier.Notify(sub.ID, result)
|
|
}
|
|
delete(done, next)
|
|
next++
|
|
}
|
|
}
|
|
}()
|
|
return sub, nil
|
|
}
|
|
|
|
// TraceBlockByNumber returns the structured logs created during the execution of
|
|
// EVM and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
|
|
// Fetch the block that we want to trace
|
|
var block *types.Block
|
|
|
|
switch number {
|
|
case rpc.PendingBlockNumber:
|
|
block = api.eth.blockchain.CurrentBlock()
|
|
case rpc.LatestBlockNumber:
|
|
block = api.eth.blockchain.CurrentBlock()
|
|
default:
|
|
block = api.eth.blockchain.GetBlockByNumber(uint64(number))
|
|
}
|
|
// Trace the block if it was found
|
|
if block == nil {
|
|
return nil, fmt.Errorf("block #%d not found", number)
|
|
}
|
|
return api.traceBlock(ctx, block, config)
|
|
}
|
|
|
|
// TraceBlockByHash returns the structured logs created during the execution of
|
|
// EVM and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceBlockByHash(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error) {
|
|
block := api.eth.blockchain.GetBlockByHash(hash)
|
|
if block == nil {
|
|
return nil, fmt.Errorf("block #%x not found", hash)
|
|
}
|
|
return api.traceBlock(ctx, block, config)
|
|
}
|
|
|
|
// TraceBlock returns the structured logs created during the execution of EVM
|
|
// and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error) {
|
|
block := new(types.Block)
|
|
if err := rlp.Decode(bytes.NewReader(blob), block); err != nil {
|
|
return nil, fmt.Errorf("could not decode block: %v", err)
|
|
}
|
|
return api.traceBlock(ctx, block, config)
|
|
}
|
|
|
|
// TraceBlockFromFile returns the structured logs created during the execution of
|
|
// EVM and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceBlockFromFile(ctx context.Context, file string, config *TraceConfig) ([]*txTraceResult, error) {
|
|
blob, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not read file: %v", err)
|
|
}
|
|
return api.TraceBlock(ctx, blob, config)
|
|
}
|
|
|
|
// traceBlock configures a new tracer according to the provided configuration, and
|
|
// executes all the transactions contained within. The return value will be one item
|
|
// per transaction, dependent on the requestd tracer.
|
|
func (api *DebugAPI) traceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*txTraceResult, error) {
|
|
// Create the parent state database
|
|
if err := api.eth.engine.VerifyHeader(api.eth.blockchain, block.Header(), true); err != nil {
|
|
return nil, err
|
|
}
|
|
parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
|
|
if parent == nil {
|
|
return nil, fmt.Errorf("parent %x not found", block.ParentHash())
|
|
}
|
|
reexec := defaultTraceReexec
|
|
if config != nil && config.Reexec != nil {
|
|
reexec = *config.Reexec
|
|
}
|
|
statedb, XDCxState, err := api.computeStateDB(parent, reexec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Execute all the transaction contained within the block concurrently
|
|
var (
|
|
signer = types.MakeSigner(api.config, block.Number())
|
|
|
|
txs = block.Transactions()
|
|
results = make([]*txTraceResult, len(txs))
|
|
|
|
pend = new(sync.WaitGroup)
|
|
jobs = make(chan *txTraceTask, len(txs))
|
|
)
|
|
threads := runtime.NumCPU()
|
|
if threads > len(txs) {
|
|
threads = len(txs)
|
|
}
|
|
blockHash := block.Hash()
|
|
blockCtx := core.NewEVMBlockContext(block.Header(), api.eth.blockchain, nil)
|
|
for th := 0; th < threads; th++ {
|
|
pend.Add(1)
|
|
go func() {
|
|
defer pend.Done()
|
|
// Fetch and execute the next transaction trace tasks
|
|
for task := range jobs {
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(task.statedb)
|
|
var balance *big.Int
|
|
if txs[task.index].To() != nil {
|
|
if value, ok := feeCapacity[*txs[task.index].To()]; ok {
|
|
balance = value
|
|
}
|
|
}
|
|
header := block.Header()
|
|
msg, _ := txs[task.index].AsMessage(signer, balance, header.Number, header.BaseFee)
|
|
txctx := &tracers.Context{
|
|
BlockHash: blockHash,
|
|
TxIndex: task.index,
|
|
TxHash: txs[task.index].Hash(),
|
|
}
|
|
res, err := api.traceTx(ctx, msg, txctx, blockCtx, task.statedb, config)
|
|
if err != nil {
|
|
results[task.index] = &txTraceResult{Error: err.Error()}
|
|
continue
|
|
}
|
|
results[task.index] = &txTraceResult{Result: res}
|
|
}
|
|
}()
|
|
}
|
|
// Feed the transactions into the tracers and return
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(statedb)
|
|
var failed error
|
|
for i, tx := range txs {
|
|
// Send the trace task over for execution
|
|
jobs <- &txTraceTask{statedb: statedb.Copy(), index: i}
|
|
var balance *big.Int
|
|
if tx.To() != nil {
|
|
// Bypass the validation for trading and lending transactions as their nonce are not incremented
|
|
if tx.IsSkipNonceTransaction() {
|
|
continue
|
|
}
|
|
if value, ok := feeCapacity[*tx.To()]; ok {
|
|
balance = value
|
|
}
|
|
}
|
|
// Generate the next state snapshot fast without tracing
|
|
header := block.Header()
|
|
msg, _ := tx.AsMessage(signer, balance, header.Number, header.BaseFee)
|
|
txContext := core.NewEVMTxContext(msg)
|
|
statedb.SetTxContext(tx.Hash(), i)
|
|
|
|
vmenv := vm.NewEVM(blockCtx, txContext, statedb, XDCxState, api.config, vm.Config{})
|
|
owner := common.Address{}
|
|
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas()), owner); err != nil {
|
|
failed = err
|
|
break
|
|
}
|
|
// Finalize the state so any modifications are written to the trie
|
|
statedb.Finalise(true)
|
|
}
|
|
close(jobs)
|
|
pend.Wait()
|
|
|
|
// If execution failed in between, abort
|
|
if failed != nil {
|
|
return nil, failed
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
// computeStateDB retrieves the state database associated with a certain block.
|
|
// If no state is locally available for the given block, a number of blocks are
|
|
// attempted to be reexecuted to generate the desired state.
|
|
func (api *DebugAPI) computeStateDB(block *types.Block, reexec uint64) (*state.StateDB, *tradingstate.TradingStateDB, error) {
|
|
// If we have the state fully available, use that
|
|
statedb, err := api.eth.blockchain.StateAt(block.Root())
|
|
XDCxState := &tradingstate.TradingStateDB{}
|
|
if err == nil {
|
|
XDCxState, err = api.eth.blockchain.OrderStateAt(block)
|
|
if err == nil {
|
|
return statedb, XDCxState, nil
|
|
}
|
|
}
|
|
// Otherwise try to reexec blocks until we find a state or reach our limit
|
|
origin := block.NumberU64()
|
|
database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16, Preimages: true})
|
|
|
|
for i := uint64(0); i < reexec; i++ {
|
|
block = api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
|
|
if block == nil {
|
|
break
|
|
}
|
|
if statedb, err = state.New(block.Root(), database); err == nil {
|
|
XDCxState, err = api.eth.blockchain.OrderStateAt(block)
|
|
if err == nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if err != nil {
|
|
switch err.(type) {
|
|
case *trie.MissingNodeError:
|
|
return nil, nil, errors.New("required historical state unavailable")
|
|
default:
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
// State was available at historical point, regenerate
|
|
var (
|
|
start = time.Now()
|
|
logged time.Time
|
|
proot common.Hash
|
|
)
|
|
for block.NumberU64() < origin {
|
|
// Print progress logs if long enough time elapsed
|
|
if time.Since(logged) > 8*time.Second {
|
|
log.Info("Regenerating historical state", "block", block.NumberU64()+1, "target", origin, "elapsed", time.Since(start))
|
|
logged = time.Now()
|
|
}
|
|
// Retrieve the next block to regenerate and process it
|
|
if block = api.eth.blockchain.GetBlockByNumber(block.NumberU64() + 1); block == nil {
|
|
return nil, nil, fmt.Errorf("block #%d not found", block.NumberU64()+1)
|
|
}
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(statedb)
|
|
_, _, _, err := api.eth.blockchain.Processor().Process(block, statedb, XDCxState, vm.Config{}, feeCapacity)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
root := statedb.IntermediateRoot(true)
|
|
if root != block.Root() {
|
|
return nil, nil, fmt.Errorf("invalid merkle root (number %d : got : %x expect: %x)", block.NumberU64(), root.Hex(), block.Root())
|
|
}
|
|
// Finalize the state so any modifications are written to the trie
|
|
root, err = statedb.Commit(true)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if err := statedb.Reset(root); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
database.TrieDB().Reference(root, common.Hash{})
|
|
database.TrieDB().Dereference(proot)
|
|
proot = root
|
|
}
|
|
size, _ := database.TrieDB().Size()
|
|
log.Info("Historical state regenerated", "block", block.NumberU64(), "elapsed", time.Since(start), "size", size)
|
|
return statedb, XDCxState, nil
|
|
}
|
|
|
|
// TraceTransaction returns the structured logs created during the execution of EVM
|
|
// and returns them as a JSON object.
|
|
func (api *DebugAPI) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
|
|
// Retrieve the transaction and assemble its EVM context
|
|
tx, blockHash, _, index := rawdb.ReadTransaction(api.eth.ChainDb(), hash)
|
|
if tx == nil {
|
|
return nil, fmt.Errorf("transaction %x not found", hash)
|
|
}
|
|
reexec := defaultTraceReexec
|
|
if config != nil && config.Reexec != nil {
|
|
reexec = *config.Reexec
|
|
}
|
|
msg, vmctx, statedb, err := api.computeTxEnv(blockHash, int(index), reexec)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
txctx := &tracers.Context{
|
|
BlockHash: blockHash,
|
|
TxIndex: int(index),
|
|
TxHash: hash,
|
|
}
|
|
return api.traceTx(ctx, msg, txctx, vmctx, statedb, config)
|
|
}
|
|
|
|
// TraceCall lets you trace a given eth_call. It collects the structured logs
|
|
// created during the execution of EVM if the given transaction was added on
|
|
// top of the provided block and returns them as a JSON object.
|
|
// You can provide -2 as a block number to trace on top of the pending block.
|
|
func (api *DebugAPI) TraceCall(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, config *TraceCallConfig) (interface{}, error) {
|
|
// Try to retrieve the specified block
|
|
var (
|
|
err error
|
|
block *types.Block
|
|
)
|
|
if hash, ok := blockNrOrHash.Hash(); ok {
|
|
block, err = api.blockByHash(ctx, hash)
|
|
} else if number, ok := blockNrOrHash.Number(); ok {
|
|
if number == rpc.PendingBlockNumber {
|
|
// We don't have access to the miner here. For tracing 'future' transactions,
|
|
// it can be done with block- and state-overrides instead, which offers
|
|
// more flexibility and stability than trying to trace on 'pending', since
|
|
// the contents of 'pending' is unstable and probably not a true representation
|
|
// of what the next actual block is likely to contain.
|
|
return nil, errors.New("tracing on top of pending is not supported")
|
|
}
|
|
block, err = api.blockByNumber(ctx, number)
|
|
} else {
|
|
return nil, errors.New("invalid arguments; neither block nor hash specified")
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// try to recompute the state
|
|
reexec := defaultTraceReexec
|
|
if config != nil && config.Reexec != nil {
|
|
reexec = *config.Reexec
|
|
}
|
|
statedb, err := api.eth.ApiBackend.StateAtBlock(ctx, block, reexec, nil, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Apply the customized state rules if required.
|
|
if config != nil {
|
|
if err := config.StateOverrides.Apply(statedb); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
// Execute the trace
|
|
// TODO: replace block.BaseFee() with vmctx.BaseFee
|
|
// reference: https://github.com/ethereum/go-ethereum/pull/29051
|
|
msg, err := args.ToMessage(api.eth.ApiBackend, block.Number(), api.eth.ApiBackend.RPCGasCap(), block.BaseFee())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
vmctx := core.NewEVMBlockContext(block.Header(), api.eth.blockchain, nil)
|
|
var traceConfig *TraceConfig
|
|
if config != nil {
|
|
traceConfig = &config.TraceConfig
|
|
}
|
|
return api.traceTx(ctx, msg, new(tracers.Context), vmctx, statedb, traceConfig)
|
|
}
|
|
|
|
// traceTx configures a new tracer according to the provided configuration, and
|
|
// executes the given message in the provided environment. The return value will
|
|
// be tracer dependent.
|
|
func (api *DebugAPI) traceTx(ctx context.Context, message core.Message, txctx *tracers.Context, vmctx vm.BlockContext, statedb *state.StateDB, config *TraceConfig) (interface{}, error) {
|
|
// Assemble the structured logger or the JavaScript tracer
|
|
var (
|
|
tracer vm.EVMLogger
|
|
err error
|
|
txContext = core.NewEVMTxContext(message)
|
|
)
|
|
switch {
|
|
case config == nil:
|
|
tracer = vm.NewStructLogger(nil)
|
|
case config.Tracer != nil:
|
|
// Define a meaningful timeout of a single transaction trace
|
|
timeout := defaultTraceTimeout
|
|
if config.Timeout != nil {
|
|
if timeout, err = time.ParseDuration(*config.Timeout); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if t, err := tracers.New(*config.Tracer, txctx, config.TracerConfig); err != nil {
|
|
return nil, err
|
|
} else {
|
|
deadlineCtx, cancel := context.WithTimeout(ctx, timeout)
|
|
go func() {
|
|
<-deadlineCtx.Done()
|
|
if errors.Is(deadlineCtx.Err(), context.DeadlineExceeded) {
|
|
t.Stop(errors.New("execution timeout"))
|
|
}
|
|
}()
|
|
defer cancel()
|
|
tracer = t
|
|
}
|
|
|
|
default:
|
|
tracer = vm.NewStructLogger(config.LogConfig)
|
|
}
|
|
// Run the transaction with tracing enabled.
|
|
vmenv := vm.NewEVM(vmctx, txContext, statedb, nil, api.config, vm.Config{Tracer: tracer, NoBaseFee: true})
|
|
|
|
// Call SetTxContext to clear out the statedb access list
|
|
statedb.SetTxContext(txctx.TxHash, txctx.TxIndex)
|
|
|
|
owner := common.Address{}
|
|
result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()), owner)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("tracing failed: %v", err)
|
|
}
|
|
// Depending on the tracer type, format and return the output
|
|
switch tracer := tracer.(type) {
|
|
case *vm.StructLogger:
|
|
return ðapi.ExecutionResult{
|
|
Gas: result.UsedGas,
|
|
Failed: result.Failed(),
|
|
ReturnValue: fmt.Sprintf("%x", result.Return()),
|
|
StructLogs: ethapi.FormatLogs(tracer.StructLogs()),
|
|
}, nil
|
|
|
|
case tracers.Tracer:
|
|
return tracer.GetResult()
|
|
|
|
default:
|
|
panic(fmt.Sprintf("bad tracer type %T", tracer))
|
|
}
|
|
}
|
|
|
|
// computeTxEnv returns the execution environment of a certain transaction.
|
|
func (api *DebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, error) {
|
|
// Create the parent state database
|
|
block := api.eth.blockchain.GetBlockByHash(blockHash)
|
|
if block == nil {
|
|
return nil, vm.BlockContext{}, nil, fmt.Errorf("block %x not found", blockHash)
|
|
}
|
|
parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
|
|
if parent == nil {
|
|
return nil, vm.BlockContext{}, nil, fmt.Errorf("parent %x not found", block.ParentHash())
|
|
}
|
|
statedb, XDCxState, err := api.computeStateDB(parent, reexec)
|
|
if err != nil {
|
|
return nil, vm.BlockContext{}, nil, err
|
|
}
|
|
// Recompute transactions up to the target index.
|
|
feeCapacity := state.GetTRC21FeeCapacityFromState(statedb)
|
|
if common.TIPSigning.Cmp(block.Header().Number) == 0 {
|
|
statedb.DeleteAddress(common.BlockSignersBinary)
|
|
}
|
|
core.InitSignerInTransactions(api.config, block.Header(), block.Transactions())
|
|
balanceUpdated := map[common.Address]*big.Int{}
|
|
totalFeeUsed := big.NewInt(0)
|
|
gp := new(core.GasPool).AddGas(block.GasLimit())
|
|
usedGas := new(uint64)
|
|
// Iterate over and process the individual transactions
|
|
for idx, tx := range block.Transactions() {
|
|
statedb.SetTxContext(tx.Hash(), idx)
|
|
if idx == txIndex {
|
|
var balanceFee *big.Int
|
|
if tx.To() != nil {
|
|
if value, ok := feeCapacity[*tx.To()]; ok {
|
|
balanceFee = value
|
|
}
|
|
}
|
|
header := block.Header()
|
|
msg, err := tx.AsMessage(types.MakeSigner(api.config, header.Number), balanceFee, header.Number, header.BaseFee)
|
|
if err != nil {
|
|
return nil, vm.BlockContext{}, nil, fmt.Errorf("tx %x failed: %v", tx.Hash(), err)
|
|
}
|
|
context := core.NewEVMBlockContext(block.Header(), api.eth.blockchain, nil)
|
|
return msg, context, statedb, nil
|
|
}
|
|
_, gas, err, tokenFeeUsed := core.ApplyTransaction(api.config, feeCapacity, api.eth.blockchain, nil, gp, statedb, XDCxState, block.Header(), tx, usedGas, vm.Config{})
|
|
if err != nil {
|
|
return nil, vm.BlockContext{}, nil, fmt.Errorf("tx %x failed: %v", tx.Hash(), err)
|
|
}
|
|
|
|
if tokenFeeUsed {
|
|
fee := common.GetGasFee(block.Header().Number.Uint64(), gas)
|
|
feeCapacity[*tx.To()] = new(big.Int).Sub(feeCapacity[*tx.To()], fee)
|
|
balanceUpdated[*tx.To()] = feeCapacity[*tx.To()]
|
|
totalFeeUsed = totalFeeUsed.Add(totalFeeUsed, fee)
|
|
}
|
|
}
|
|
statedb.DeleteSuicides()
|
|
return nil, vm.BlockContext{}, nil, fmt.Errorf("tx index %d out of range for block %x", txIndex, blockHash)
|
|
}
|