Rongjian Lan
4 years ago
committed by
GitHub
commit
94d3431cdd
@ -0,0 +1,743 @@ |
|||||||
|
// 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 hmy |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"context" |
||||||
|
"fmt" |
||||||
|
"io/ioutil" |
||||||
|
"os" |
||||||
|
"runtime" |
||||||
|
"sync" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/common" |
||||||
|
"github.com/ethereum/go-ethereum/common/hexutil" |
||||||
|
"github.com/ethereum/go-ethereum/common/math" |
||||||
|
"github.com/ethereum/go-ethereum/rpc" |
||||||
|
"github.com/ethereum/go-ethereum/trie" |
||||||
|
"github.com/harmony-one/harmony/core" |
||||||
|
"github.com/harmony-one/harmony/core/state" |
||||||
|
"github.com/harmony-one/harmony/core/types" |
||||||
|
"github.com/harmony-one/harmony/core/vm" |
||||||
|
"github.com/harmony-one/harmony/internal/utils" |
||||||
|
) |
||||||
|
|
||||||
|
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 re-execute to produce missing historical state necessary to run a specific
|
||||||
|
// trace.
|
||||||
|
defaultTraceReexec = uint64(128) |
||||||
|
|
||||||
|
err |
||||||
|
) |
||||||
|
|
||||||
|
// TraceConfig holds extra parameters to trace functions.
|
||||||
|
type TraceConfig struct { |
||||||
|
*vm.LogConfig |
||||||
|
Tracer *string |
||||||
|
Timeout *string |
||||||
|
Reexec *uint64 |
||||||
|
} |
||||||
|
|
||||||
|
// StdTraceConfig holds extra parameters to standard-json trace functions.
|
||||||
|
type StdTraceConfig struct { |
||||||
|
*vm.LogConfig |
||||||
|
Reexec *uint64 |
||||||
|
TxHash common.Hash |
||||||
|
} |
||||||
|
|
||||||
|
// 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.DB // 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 produced 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.DB // Intermediate state prepped for tracing
|
||||||
|
index int // Transaction offset in the block
|
||||||
|
} |
||||||
|
|
||||||
|
// 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 requested tracer.
|
||||||
|
func (hmy *Harmony) 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 nil, rpc.ErrNotificationsUnsupported |
||||||
|
} |
||||||
|
sub := notifier.CreateSubscription() |
||||||
|
|
||||||
|
// Ensure we have a valid starting state before doing any work
|
||||||
|
origin := start.NumberU64() |
||||||
|
database := state.NewDatabaseWithCache(hmy.ChainDb(), 16) |
||||||
|
|
||||||
|
if origin > 0 { |
||||||
|
start = hmy.BlockChain.GetBlock(start.ParentHash(), origin-1) |
||||||
|
if start == nil { |
||||||
|
return nil, fmt.Errorf("parent block #%d not found", origin-1) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
statedb, err := state.New(start.Root(), database) |
||||||
|
if err != nil { |
||||||
|
// If the starting state is missing, allow some number of blocks to be executed
|
||||||
|
reexec := defaultTraceReexec |
||||||
|
if config != nil && config.Reexec != nil { |
||||||
|
reexec = *config.Reexec |
||||||
|
} |
||||||
|
// Find the most recent block that has state available
|
||||||
|
for i := uint64(0); i < reexec; i++ { |
||||||
|
start = hmy.BlockChain.GetBlock(start.ParentHash(), start.NumberU64()-1) |
||||||
|
if start == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
if statedb, err = state.New(start.Root(), database); err == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
// If we still don't have the state available, bail
|
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Execute all the transactions contained within the chain concurrently for each block
|
||||||
|
blocks := int(end.NumberU64() - origin) |
||||||
|
|
||||||
|
threads := runtime.NumCPU() |
||||||
|
if threads > blocks { |
||||||
|
threads = blocks |
||||||
|
} |
||||||
|
var ( |
||||||
|
pending = new(sync.WaitGroup) |
||||||
|
tasks = make(chan *blockTraceTask, threads) |
||||||
|
results = make(chan *blockTraceTask, threads) |
||||||
|
) |
||||||
|
for th := 0; th < threads; th++ { |
||||||
|
pending.Add(1) |
||||||
|
go func() { |
||||||
|
defer pending.Done() |
||||||
|
|
||||||
|
// Fetch and execute the next block trace tasks
|
||||||
|
for task := range tasks { |
||||||
|
signer := types.MakeSigner(hmy.BlockChain.Config(), task.block.Number()) |
||||||
|
|
||||||
|
// Trace all the transactions contained within
|
||||||
|
for i, tx := range task.block.Transactions() { |
||||||
|
msg, _ := tx.AsMessage(signer) |
||||||
|
vmCtx := core.NewEVMContext(msg, task.block.Header(), hmy.BlockChain, nil) |
||||||
|
|
||||||
|
res, err := hmy.TraceTx(ctx, msg, vmCtx, task.statedb, config) |
||||||
|
if err != nil { |
||||||
|
task.results[i] = &TxTraceResult{Error: err.Error()} |
||||||
|
utils.Logger().Warn().Msg("Tracing failed") |
||||||
|
break |
||||||
|
} |
||||||
|
// EIP 158/161 (Spurious Dragon) does not apply to Harmony
|
||||||
|
task.statedb.Finalise(true) |
||||||
|
task.results[i] = &TxTraceResult{Result: res} |
||||||
|
} |
||||||
|
// Stream the result back to the user or abort on teardown
|
||||||
|
select { |
||||||
|
case results <- task: |
||||||
|
case <-notifier.Closed(): |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
}() |
||||||
|
} |
||||||
|
// Start a goroutine that feeds 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) |
||||||
|
pending.Wait() |
||||||
|
|
||||||
|
switch { |
||||||
|
case failed != nil: |
||||||
|
utils.Logger().Warn(). |
||||||
|
Uint64("start", start.NumberU64()). |
||||||
|
Uint64("end", end.NumberU64()). |
||||||
|
Uint64("transactions", traced). |
||||||
|
Float64("elapsed", time.Since(begin).Seconds()). |
||||||
|
Err(failed). |
||||||
|
Msg("Chain tracing failed") |
||||||
|
case number < end.NumberU64(): |
||||||
|
utils.Logger().Warn(). |
||||||
|
Uint64("start", start.NumberU64()). |
||||||
|
Uint64("end", end.NumberU64()). |
||||||
|
Uint64("abort", number). |
||||||
|
Uint64("transactions", traced). |
||||||
|
Float64("elapsed", time.Since(begin).Seconds()). |
||||||
|
Msg("Chain tracing aborted") |
||||||
|
default: |
||||||
|
utils.Logger().Info(). |
||||||
|
Uint64("start", start.NumberU64()). |
||||||
|
Uint64("end", end.NumberU64()). |
||||||
|
Uint64("transactions", traced). |
||||||
|
Float64("elapsed", time.Since(begin).Seconds()). |
||||||
|
Msg("Chain tracing finished") |
||||||
|
} |
||||||
|
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++ { |
||||||
|
// Stop tracing if interrupt was requested
|
||||||
|
select { |
||||||
|
case <-notifier.Closed(): |
||||||
|
return |
||||||
|
default: |
||||||
|
} |
||||||
|
|
||||||
|
// Print progress logs if long enough time elapsed
|
||||||
|
if time.Since(logged) > 8*time.Second { |
||||||
|
if number > origin { |
||||||
|
nodes, imgs := database.TrieDB().Size() |
||||||
|
utils.Logger().Info(). |
||||||
|
Uint64("start", origin). |
||||||
|
Uint64("end", end.NumberU64()). |
||||||
|
Uint64("current", number). |
||||||
|
Uint64("transactions", traced). |
||||||
|
Float64("elapsed", time.Since(begin).Seconds()). |
||||||
|
Float64("memory", float64(nodes)+float64(imgs)). |
||||||
|
Msg("Tracing chain segment") |
||||||
|
} else { |
||||||
|
utils.Logger().Info().Msg("Preparing state for chain trace") |
||||||
|
} |
||||||
|
logged = time.Now() |
||||||
|
} |
||||||
|
// Retrieve the next block to trace
|
||||||
|
block := hmy.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() |
||||||
|
|
||||||
|
select { |
||||||
|
case tasks <- &blockTraceTask{statedb: statedb.Copy(), block: block, rootRef: proot, results: make([]*TxTraceResult, len(txs))}: |
||||||
|
case <-notifier.Closed(): |
||||||
|
return |
||||||
|
} |
||||||
|
traced += uint64(len(txs)) |
||||||
|
} |
||||||
|
// Generate the next state snapshot fast without tracing
|
||||||
|
_, _, _, _, _, err := hmy.BlockChain.Processor().Process(block, statedb, vm.Config{}) |
||||||
|
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 tracer
|
||||||
|
database.TrieDB().Reference(root, common.Hash{}) |
||||||
|
if number >= origin { |
||||||
|
database.TrieDB().Reference(root, common.Hash{}) |
||||||
|
} |
||||||
|
// Deference all past tries we ourselves are done working with
|
||||||
|
if proot != (common.Hash{}) { |
||||||
|
database.TrieDB().Dereference(proot) |
||||||
|
} |
||||||
|
proot = root |
||||||
|
|
||||||
|
// TODO(karalabe): Do we need the preimages? Won't they accumulate too much?
|
||||||
|
} |
||||||
|
}() |
||||||
|
|
||||||
|
// Keep reading the trace results and stream them 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 parent 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 |
||||||
|
} |
||||||
|
|
||||||
|
// 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 requested tracer.
|
||||||
|
func (hmy *Harmony) TraceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*TxTraceResult, error) { |
||||||
|
// Create the parent state database
|
||||||
|
if err := hmy.BlockChain.Engine().VerifyHeader(hmy.BlockChain, block.Header(), true); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
parent := hmy.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, err := hmy.ComputeStateDB(parent, reexec) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
// Execute all the transaction contained within the block concurrently
|
||||||
|
var ( |
||||||
|
signer = types.MakeSigner(hmy.BlockChain.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) |
||||||
|
} |
||||||
|
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 { |
||||||
|
msg, _ := txs[task.index].AsMessage(signer) |
||||||
|
vmctx := core.NewEVMContext(msg, block.Header(), hmy.BlockChain, nil) |
||||||
|
|
||||||
|
res, err := hmy.TraceTx(ctx, msg, vmctx, 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
|
||||||
|
var failed error |
||||||
|
for i, tx := range txs { |
||||||
|
// Send the trace task over for execution
|
||||||
|
jobs <- &txTraceTask{statedb: statedb.Copy(), index: i} |
||||||
|
|
||||||
|
// Generate the next state snapshot fast without tracing
|
||||||
|
msg, _ := tx.AsMessage(signer) |
||||||
|
vmctx := core.NewEVMContext(msg, block.Header(), hmy.BlockChain, nil) |
||||||
|
|
||||||
|
vmenv := vm.NewEVM(vmctx, statedb, hmy.BlockChain.Config(), vm.Config{}) |
||||||
|
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); 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 |
||||||
|
} |
||||||
|
|
||||||
|
// standardTraceBlockToFile configures a new tracer which uses standard JSON output,
|
||||||
|
// and traces either a full block or an individual transaction. The return value will
|
||||||
|
// be one filename per transaction traced.
|
||||||
|
func (hmy *Harmony) standardTraceBlockToFile(ctx context.Context, block *types.Block, config *StdTraceConfig) ([]string, error) { |
||||||
|
// If we're tracing a single transaction, make sure it's present
|
||||||
|
if config != nil && config.TxHash != (common.Hash{}) { |
||||||
|
if !containsTx(block, config.TxHash) { |
||||||
|
return nil, fmt.Errorf("transaction %#x not found in block", config.TxHash) |
||||||
|
} |
||||||
|
} |
||||||
|
// Create the parent state database
|
||||||
|
if err := hmy.BlockChain.Engine().VerifyHeader(hmy.BlockChain, block.Header(), true); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
parent := hmy.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, err := hmy.ComputeStateDB(parent, reexec) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
// Retrieve the tracing configurations, or use default values
|
||||||
|
var ( |
||||||
|
logConfig vm.LogConfig |
||||||
|
txHash common.Hash |
||||||
|
) |
||||||
|
if config != nil { |
||||||
|
if config.LogConfig != nil { |
||||||
|
logConfig = *config.LogConfig |
||||||
|
} |
||||||
|
txHash = config.TxHash |
||||||
|
} |
||||||
|
logConfig.Debug = true |
||||||
|
|
||||||
|
// Execute transaction, either tracing all or just the requested one
|
||||||
|
var ( |
||||||
|
signer = types.MakeSigner(hmy.BlockChain.Config(), block.Number()) |
||||||
|
dumps []string |
||||||
|
) |
||||||
|
for i, tx := range block.Transactions() { |
||||||
|
// Prepare the transaction for un-traced execution
|
||||||
|
var ( |
||||||
|
msg, _ = tx.AsMessage(signer) |
||||||
|
vmctx = core.NewEVMContext(msg, block.Header(), hmy.BlockChain, nil) |
||||||
|
|
||||||
|
vmConf vm.Config |
||||||
|
dump *os.File |
||||||
|
writer *bufio.Writer |
||||||
|
err error |
||||||
|
) |
||||||
|
// If the transaction needs tracing, swap out the configs
|
||||||
|
if tx.Hash() == txHash || txHash == (common.Hash{}) { |
||||||
|
// Generate a unique temporary file to dump it into
|
||||||
|
prefix := fmt.Sprintf("block_%#x-%d-%#x-", block.Hash().Bytes()[:4], i, tx.Hash().Bytes()[:4]) |
||||||
|
|
||||||
|
dump, err = ioutil.TempFile(os.TempDir(), prefix) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
dumps = append(dumps, dump.Name()) |
||||||
|
|
||||||
|
// Swap out the noop logger to the standard tracer
|
||||||
|
writer = bufio.NewWriter(dump) |
||||||
|
vmConf = vm.Config{ |
||||||
|
Debug: true, |
||||||
|
Tracer: vm.NewJSONLogger(&logConfig, writer), |
||||||
|
EnablePreimageRecording: true, |
||||||
|
} |
||||||
|
} |
||||||
|
// Execute the transaction and flush any traces to disk
|
||||||
|
vmenv := vm.NewEVM(vmctx, statedb, hmy.BlockChain.Config(), vmConf) |
||||||
|
_, err = core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())) |
||||||
|
if writer != nil { |
||||||
|
writer.Flush() |
||||||
|
} |
||||||
|
if dump != nil { |
||||||
|
dump.Close() |
||||||
|
utils.Logger().Info().Msg(fmt.Sprintf("Wrote standard trace file %s", dump.Name())) |
||||||
|
} |
||||||
|
if err != nil { |
||||||
|
return dumps, err |
||||||
|
} |
||||||
|
// Finalize the state so any modifications are written to the trie
|
||||||
|
statedb.Finalise(true) |
||||||
|
|
||||||
|
// If we've traced the transaction we were looking for, abort
|
||||||
|
if tx.Hash() == txHash { |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
return dumps, nil |
||||||
|
} |
||||||
|
|
||||||
|
// containsTx reports whether the transaction with a certain hash
|
||||||
|
// is contained within the specified block.
|
||||||
|
func containsTx(block *types.Block, hash common.Hash) bool { |
||||||
|
for _, tx := range block.Transactions() { |
||||||
|
if tx.Hash() == hash { |
||||||
|
return true |
||||||
|
} |
||||||
|
} |
||||||
|
return false |
||||||
|
} |
||||||
|
|
||||||
|
// 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 (hmy *Harmony) ComputeStateDB(block *types.Block, reexec uint64) (*state.DB, error) { |
||||||
|
// If we have the state fully available, use that
|
||||||
|
statedb, err := hmy.BlockChain.StateAt(block.Root()) |
||||||
|
if err == nil { |
||||||
|
return statedb, nil |
||||||
|
} |
||||||
|
// Otherwise try to reexec blocks until we find a state or reach our limit
|
||||||
|
origin := block.NumberU64() |
||||||
|
database := state.NewDatabaseWithCache(hmy.BlockChain.ChainDb(), 16) |
||||||
|
|
||||||
|
for i := uint64(0); i < reexec; i++ { |
||||||
|
block = hmy.BlockChain.GetBlock(block.ParentHash(), block.NumberU64()-1) |
||||||
|
if block == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
if statedb, err = state.New(block.Root(), database); err == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
if err != nil { |
||||||
|
switch err.(type) { |
||||||
|
case *trie.MissingNodeError: |
||||||
|
return nil, fmt.Errorf("required historical state unavailable (reexec=%d)", reexec) |
||||||
|
default: |
||||||
|
return 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 { |
||||||
|
utils.Logger().Info(). |
||||||
|
Uint64("block", block.NumberU64()). |
||||||
|
Uint64("target", origin). |
||||||
|
Uint64("remaining", origin-block.NumberU64()). |
||||||
|
Float64("elasped", time.Since(start).Seconds()). |
||||||
|
Msg(fmt.Sprintf("Regenerating historical state")) |
||||||
|
logged = time.Now() |
||||||
|
} |
||||||
|
// Retrieve the next block to regenerate and process it
|
||||||
|
if block = hmy.BlockChain.GetBlockByNumber(block.NumberU64() + 1); block == nil { |
||||||
|
return nil, fmt.Errorf("block #%d not found", block.NumberU64()+1) |
||||||
|
} |
||||||
|
_, _, _, _, _, err := hmy.BlockChain.Processor().Process(block, statedb, vm.Config{}) |
||||||
|
if err != nil { |
||||||
|
return nil, fmt.Errorf("processing block %d failed: %v", block.NumberU64(), err) |
||||||
|
} |
||||||
|
// Finalize the state so any modifications are written to the trie
|
||||||
|
root, err := statedb.Commit(true) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
if err := statedb.Reset(root); err != nil { |
||||||
|
return nil, fmt.Errorf("state reset after block %d failed: %v", block.NumberU64(), err) |
||||||
|
} |
||||||
|
database.TrieDB().Reference(root, common.Hash{}) |
||||||
|
if proot != (common.Hash{}) { |
||||||
|
database.TrieDB().Dereference(proot) |
||||||
|
} |
||||||
|
proot = root |
||||||
|
} |
||||||
|
nodes, imgs := database.TrieDB().Size() |
||||||
|
utils.Logger().Info(). |
||||||
|
Uint64("block", block.NumberU64()). |
||||||
|
Float64("elasped", time.Since(start).Seconds()). |
||||||
|
Float64("nodes", float64(nodes)). |
||||||
|
Float64("preimages", float64(imgs)). |
||||||
|
Msg("Historical state regenerated") |
||||||
|
return statedb, nil |
||||||
|
} |
||||||
|
|
||||||
|
// 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.
|
||||||
|
// NOTE: Only support default StructLogger tracer
|
||||||
|
func (hmy *Harmony) TraceTx(ctx context.Context, message core.Message, vmctx vm.Context, statedb *state.DB, config *TraceConfig) (interface{}, error) { |
||||||
|
// Assemble the structured logger or the JavaScript tracer
|
||||||
|
var ( |
||||||
|
tracer vm.Tracer |
||||||
|
err error |
||||||
|
) |
||||||
|
|
||||||
|
if config == nil { |
||||||
|
tracer = vm.NewStructLogger(nil) |
||||||
|
} else { |
||||||
|
tracer = vm.NewStructLogger(config.LogConfig) |
||||||
|
} |
||||||
|
|
||||||
|
// Run the transaction with tracing enabled.
|
||||||
|
vmenv := vm.NewEVM(vmctx, statedb, hmy.BlockChain.Config(), vm.Config{Debug: true, Tracer: tracer}) |
||||||
|
|
||||||
|
result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas())) |
||||||
|
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 &ExecutionResult{ |
||||||
|
Gas: result.UsedGas, |
||||||
|
Failed: result.VMErr != nil, |
||||||
|
ReturnValue: fmt.Sprintf("%x", result.ReturnData), |
||||||
|
StructLogs: FormatLogs(tracer.StructLogs()), |
||||||
|
}, nil |
||||||
|
|
||||||
|
default: |
||||||
|
panic(fmt.Sprintf("bad tracer type %T", tracer)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// ComputeTxEnv returns the execution environment of a certain transaction.
|
||||||
|
func (hmy *Harmony) ComputeTxEnv(block *types.Block, txIndex int, reexec uint64) (core.Message, vm.Context, *state.DB, error) { |
||||||
|
// Create the parent state database
|
||||||
|
parent := hmy.BlockChain.GetBlock(block.ParentHash(), block.NumberU64()-1) |
||||||
|
if parent == nil { |
||||||
|
return nil, vm.Context{}, nil, fmt.Errorf("parent %#x not found", block.ParentHash()) |
||||||
|
} |
||||||
|
statedb, err := hmy.ComputeStateDB(parent, reexec) |
||||||
|
if err != nil { |
||||||
|
return nil, vm.Context{}, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if txIndex == 0 && len(block.Transactions()) == 0 { |
||||||
|
return nil, vm.Context{}, statedb, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Recompute transactions up to the target index.
|
||||||
|
signer := types.MakeSigner(hmy.BlockChain.Config(), block.Number()) |
||||||
|
|
||||||
|
for idx, tx := range block.Transactions() { |
||||||
|
// Assemble the transaction call message and return if the requested offset
|
||||||
|
msg, _ := tx.AsMessage(signer) |
||||||
|
context := core.NewEVMContext(msg, block.Header(), hmy.BlockChain, nil) |
||||||
|
if idx == txIndex { |
||||||
|
return msg, context, statedb, nil |
||||||
|
} |
||||||
|
// Not yet the searched for transaction, execute on top of the current state
|
||||||
|
vmenv := vm.NewEVM(context, statedb, hmy.BlockChain.Config(), vm.Config{}) |
||||||
|
if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil { |
||||||
|
return nil, vm.Context{}, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err) |
||||||
|
} |
||||||
|
// Ensure any modifications are committed to the state
|
||||||
|
statedb.Finalise(true) |
||||||
|
} |
||||||
|
return nil, vm.Context{}, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash()) |
||||||
|
} |
||||||
|
|
||||||
|
// ExecutionResult groups all structured logs emitted by the EVM
|
||||||
|
// while replaying a transaction in debug mode as well as transaction
|
||||||
|
// execution status, the amount of gas used and the return value
|
||||||
|
// Taken from go-ethereum/internal/ethapi/api.go
|
||||||
|
type ExecutionResult struct { |
||||||
|
Gas uint64 `json:"gas"` |
||||||
|
Failed bool `json:"failed"` |
||||||
|
ReturnValue string `json:"returnValue"` |
||||||
|
StructLogs []StructLogRes `json:"structLogs"` |
||||||
|
} |
||||||
|
|
||||||
|
// StructLogRes stores a structured log emitted by the EVM while replaying a
|
||||||
|
// transaction in debug mode
|
||||||
|
type StructLogRes struct { |
||||||
|
Pc uint64 `json:"pc"` |
||||||
|
Op string `json:"op"` |
||||||
|
Gas uint64 `json:"gas"` |
||||||
|
GasCost uint64 `json:"gasCost"` |
||||||
|
Depth int `json:"depth"` |
||||||
|
Error error `json:"error,omitempty"` |
||||||
|
Stack *[]string `json:"stack,omitempty"` |
||||||
|
Memory *[]string `jsogun:"memory,omitempty"` |
||||||
|
Storage *map[string]string `json:"storage,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// FormatLogs formats EVM returned structured logs for json output
|
||||||
|
func FormatLogs(logs []vm.StructLog) []StructLogRes { |
||||||
|
formatted := make([]StructLogRes, len(logs)) |
||||||
|
for index, trace := range logs { |
||||||
|
formatted[index] = StructLogRes{ |
||||||
|
Pc: trace.Pc, |
||||||
|
Op: trace.Op.String(), |
||||||
|
Gas: trace.Gas, |
||||||
|
GasCost: trace.GasCost, |
||||||
|
Depth: trace.Depth, |
||||||
|
Error: trace.Err, |
||||||
|
} |
||||||
|
if trace.Stack != nil { |
||||||
|
stack := make([]string, len(trace.Stack)) |
||||||
|
for i, stackValue := range trace.Stack { |
||||||
|
stack[i] = fmt.Sprintf("%x", math.PaddedBigBytes(stackValue, 32)) |
||||||
|
} |
||||||
|
formatted[index].Stack = &stack |
||||||
|
} |
||||||
|
if trace.Memory != nil { |
||||||
|
memory := make([]string, 0, (len(trace.Memory)+31)/32) |
||||||
|
for i := 0; i+32 <= len(trace.Memory); i += 32 { |
||||||
|
memory = append(memory, fmt.Sprintf("%x", trace.Memory[i:i+32])) |
||||||
|
} |
||||||
|
formatted[index].Memory = &memory |
||||||
|
} |
||||||
|
if trace.Storage != nil { |
||||||
|
storage := make(map[string]string) |
||||||
|
for i, storageValue := range trace.Storage { |
||||||
|
storage[fmt.Sprintf("%x", i)] = fmt.Sprintf("%x", storageValue) |
||||||
|
} |
||||||
|
formatted[index].Storage = &storage |
||||||
|
} |
||||||
|
} |
||||||
|
return formatted |
||||||
|
} |
||||||
@ -0,0 +1,177 @@ |
|||||||
|
// 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 rpc |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"errors" |
||||||
|
"fmt" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/common" |
||||||
|
"github.com/ethereum/go-ethereum/rlp" |
||||||
|
"github.com/ethereum/go-ethereum/rpc" |
||||||
|
"github.com/harmony-one/harmony/core" |
||||||
|
"github.com/harmony-one/harmony/core/rawdb" |
||||||
|
"github.com/harmony-one/harmony/core/types" |
||||||
|
"github.com/harmony-one/harmony/hmy" |
||||||
|
) |
||||||
|
|
||||||
|
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 re-execute to produce missing historical state necessary to run a specific
|
||||||
|
// trace.
|
||||||
|
defaultTraceReexec = uint64(128) |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
// ErrNotAvailable to indicate the RPC is not ready for public use
|
||||||
|
ErrNotAvailable = errors.New("RPC not available yet") |
||||||
|
) |
||||||
|
|
||||||
|
// PublicTracerService provides an API to access Harmony's staking services.
|
||||||
|
// It offers only methods that operate on public data that is freely available to anyone.
|
||||||
|
type PublicTracerService struct { |
||||||
|
hmy *hmy.Harmony |
||||||
|
version Version |
||||||
|
} |
||||||
|
|
||||||
|
// NewPublicTracerAPI creates a new API for the RPC interface
|
||||||
|
func NewPublicTracerAPI(hmy *hmy.Harmony, version Version) rpc.API { |
||||||
|
return rpc.API{ |
||||||
|
Namespace: version.Namespace(), |
||||||
|
Version: APIVersion, |
||||||
|
Service: &PublicTracerService{hmy, version}, |
||||||
|
Public: true, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TraceChain returns the structured logs created during the execution of EVM
|
||||||
|
// between two blocks (excluding start) and returns them as a JSON object.
|
||||||
|
func (s *PublicTracerService) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *hmy.TraceConfig) (*rpc.Subscription, error) { |
||||||
|
// TODO (JL): Make API available after DoS testing
|
||||||
|
return nil, ErrNotAvailable |
||||||
|
if uint64(start) >= uint64(end) { |
||||||
|
return nil, fmt.Errorf("start block can not be equal or greater than the end block") |
||||||
|
} |
||||||
|
|
||||||
|
currentBlock := s.hmy.BlockChain.CurrentBlock().NumberU64() |
||||||
|
if uint64(start) > currentBlock || uint64(end) > currentBlock { |
||||||
|
return nil, ErrRequestedBlockTooHigh |
||||||
|
} |
||||||
|
|
||||||
|
from := s.hmy.BlockChain.GetBlockByNumber(uint64(start)) |
||||||
|
if from == nil { |
||||||
|
return nil, fmt.Errorf("start block #%d not found", start) |
||||||
|
} |
||||||
|
to := s.hmy.BlockChain.GetBlockByNumber(uint64(end)) |
||||||
|
if to == nil { |
||||||
|
return nil, fmt.Errorf("end block #%d not found", end) |
||||||
|
} |
||||||
|
|
||||||
|
return s.hmy.TraceChain(ctx, from, to, config) |
||||||
|
} |
||||||
|
|
||||||
|
// TraceBlockByNumber returns the structured logs created during the execution of
|
||||||
|
// EVM and returns them as a JSON object.
|
||||||
|
func (s *PublicTracerService) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *hmy.TraceConfig) ([]*hmy.TxTraceResult, error) { |
||||||
|
// Fetch the block that we want to trace
|
||||||
|
block := s.hmy.BlockChain.GetBlockByNumber(uint64(number)) |
||||||
|
|
||||||
|
return s.hmy.TraceBlock(ctx, block, config) |
||||||
|
} |
||||||
|
|
||||||
|
// TraceBlockByHash returns the structured logs created during the execution of
|
||||||
|
// EVM and returns them as a JSON object.
|
||||||
|
func (s *PublicTracerService) TraceBlockByHash(ctx context.Context, hash common.Hash, config *hmy.TraceConfig) ([]*hmy.TxTraceResult, error) { |
||||||
|
block := s.hmy.BlockChain.GetBlockByHash(hash) |
||||||
|
if block == nil { |
||||||
|
return nil, fmt.Errorf("block %#x not found", hash) |
||||||
|
} |
||||||
|
return s.hmy.TraceBlock(ctx, block, config) |
||||||
|
} |
||||||
|
|
||||||
|
// TraceBlock returns the structured logs created during the execution of EVM
|
||||||
|
// and returns them as a JSON object.
|
||||||
|
func (s *PublicTracerService) TraceBlock(ctx context.Context, blob []byte, config *hmy.TraceConfig) ([]*hmy.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 s.hmy.TraceBlock(ctx, block, config) |
||||||
|
} |
||||||
|
|
||||||
|
// TraceTransaction returns the structured logs created during the execution of EVM
|
||||||
|
// and returns them as a JSON object.
|
||||||
|
func (s *PublicTracerService) TraceTransaction(ctx context.Context, hash common.Hash, config *hmy.TraceConfig) (interface{}, error) { |
||||||
|
// Retrieve the transaction and assemble its EVM context
|
||||||
|
tx, blockHash, _, index := rawdb.ReadTransaction(s.hmy.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 |
||||||
|
} |
||||||
|
// Retrieve the block
|
||||||
|
block := s.hmy.BlockChain.GetBlockByHash(blockHash) |
||||||
|
if block == nil { |
||||||
|
return nil, fmt.Errorf("block %#x not found", blockHash) |
||||||
|
} |
||||||
|
msg, vmctx, statedb, err := s.hmy.ComputeTxEnv(block, int(index), reexec) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
// Trace the transaction and return
|
||||||
|
return s.hmy.TraceTx(ctx, msg, 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.
|
||||||
|
// NOTE: Our version only supports block number as an input
|
||||||
|
func (s *PublicTracerService) TraceCall(ctx context.Context, args CallArgs, blockNr rpc.BlockNumber, config *hmy.TraceConfig) (interface{}, error) { |
||||||
|
// First try to retrieve the state
|
||||||
|
statedb, header, err := s.hmy.StateAndHeaderByNumber(ctx, blockNr) |
||||||
|
if err != nil { |
||||||
|
// Try to retrieve the specified block
|
||||||
|
block := s.hmy.BlockChain.GetBlockByNumber(uint64(blockNr)) |
||||||
|
if block == nil { |
||||||
|
return nil, fmt.Errorf("block %v not found: %v", blockNr, err) |
||||||
|
} |
||||||
|
// try to recompute the state
|
||||||
|
reexec := defaultTraceReexec |
||||||
|
if config != nil && config.Reexec != nil { |
||||||
|
reexec = *config.Reexec |
||||||
|
} |
||||||
|
_, _, statedb, err = s.hmy.ComputeTxEnv(block, 0, reexec) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Execute the trace
|
||||||
|
msg := args.ToMessage(s.hmy.RPCGasCap) |
||||||
|
vmctx := core.NewEVMContext(msg, header, s.hmy.BlockChain, nil) |
||||||
|
// Trace the transaction and return
|
||||||
|
return s.hmy.TraceTx(ctx, msg, vmctx, statedb, config) |
||||||
|
} |
||||||
Loading…
Reference in new issue