forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-19 11:20:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

revert changes to generic trace methods

Browse source
This commit is contained in:
Sina Mahmoodi 2026-02-10 12:04:46 +00:00
parent 0b0a032b60
commit 5f966a4359
1 changed files with 14 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
ethclient/gethclient/gethclient.go
View file

@ -20,7 +20,6 @@ package gethclient
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors"
"fmt" "fmt"
"math/big" "math/big"
"runtime" "runtime"
@ -210,64 +209,26 @@ func (ec *Client) SubscribePendingTransactions(ctx context.Context, ch chan<- co
return ec.c.EthSubscribe(ctx, ch, "newPendingTransactions") return ec.c.EthSubscribe(ctx, ch, "newPendingTransactions")
} }
// TxTraceResult is the result of a single transaction trace.
type TxTraceResult struct {
TxHash common.Hash `json:"txHash"` // Transaction hash
Result interface{} `json:"result,omitempty"` // Trace results produced by the tracer
Error string `json:"error,omitempty"` // Trace failure produced by the tracer
}
// BlockTraceResult represents the results of tracing a single block.
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
}
// TraceTransaction returns the structured logs created during the execution of EVM // TraceTransaction returns the structured logs created during the execution of EVM
// and returns them as a JSON object. // and returns them as a JSON object.
func (ec *Client) TraceTransaction(ctx context.Context, txHash common.Hash, config *tracers.TraceConfig) (interface{}, error) { func (ec *Client) TraceTransaction(ctx context.Context, hash common.Hash, config *tracers.TraceConfig) (any, error) {
var result interface{} var result any
err := ec.c.CallContext(ctx, &result, "debug_traceTransaction", txHash, config) err := ec.c.CallContext(ctx, &result, "debug_traceTransaction", hash, config)
return result, err if err != nil {
} return nil, err
}
// TraceCall lets you trace a given eth_call. It collects the structured logs return result, nil
// 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.
func (ec *Client) TraceCall(ctx context.Context, msg ethereum.CallMsg, blockNrOrHash rpc.BlockNumberOrHash, config *tracers.TraceCallConfig) (interface{}, error) {
var result interface{}
err := ec.c.CallContext(ctx, &result, "debug_traceCall", toCallArg(msg), blockNrOrHash, config)
return result, err
} }
// TraceBlock returns the structured logs created during the execution of EVM // TraceBlock returns the structured logs created during the execution of EVM
// for a specific block. This can be by block number, hash, or the latest/pending block. // and returns them as a JSON object.
func (ec *Client) TraceBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash, config *tracers.TraceConfig) ([]*TxTraceResult, error) { func (ec *Client) TraceBlock(ctx context.Context, hash common.Hash, config *tracers.TraceConfig) (any, error) {
var result []*TxTraceResult var result any
err := ec.c.CallContext(ctx, &result, "debug_traceBlockByHash", hash, config)
// Determine the method to call based on the type of blockNrOrHash if err != nil {
var method string return nil, err
var arg interface{}
if hash, ok := blockNrOrHash.Hash(); ok {
method = "debug_traceBlockByHash"
arg = hash
} else if number, ok := blockNrOrHash.Number(); ok {
method = "debug_traceBlockByNumber"
arg = number
} else {
return nil, errors.New("invalid arguments; neither block nor hash specified")
} }
return result, nil
err := ec.c.CallContext(ctx, &result, method, arg, config)
return result, err
}
// TraceChain returns the structured logs created during the execution of EVM between
// two blocks (inclusive) and returns them as an array of JSON objects.
func (ec *Client) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *tracers.TraceConfig) (*rpc.ClientSubscription, error) {
return ec.c.EthSubscribe(ctx, make(chan *BlockTraceResult), "debug_traceChain", start, end, config)
} }
// CallTracerConfig configures the call tracer for // CallTracerConfig configures the call tracer for