Documentation

Overview

    Package tracers is a collection of JavaScript transaction tracers.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func APIs

    func APIs(backend Backend) []rpc.API

      APIs return the collection of RPC services the tracer package offers.

      Types

      type API

      type API struct {
      	// contains filtered or unexported fields
      }

        API is the collection of tracing APIs exposed over the private debugging endpoint.

        func NewAPI

        func NewAPI(backend Backend) *API

          NewAPI creates a new API definition for the tracing methods of the Ethereum service.

          func (*API) StandardTraceBadBlockToFile

          func (api *API) StandardTraceBadBlockToFile(ctx context.Context, hash common.Hash, config *StdTraceConfig) ([]string, error)

            StandardTraceBadBlockToFile dumps the structured logs created during the execution of EVM against a block pulled from the pool of bad ones to the local file system and returns a list of files to the caller.

            func (*API) StandardTraceBlockToFile

            func (api *API) StandardTraceBlockToFile(ctx context.Context, hash common.Hash, config *StdTraceConfig) ([]string, error)

              StandardTraceBlockToFile dumps the structured logs created during the execution of EVM to the local file system and returns a list of files to the caller.

              func (*API) TraceBadBlock

              func (api *API) TraceBadBlock(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error)

                TraceBadBlock returns the structured logs created during the execution of EVM against a block pulled from the pool of bad ones and returns them as a JSON object.

                func (*API) TraceBlock

                func (api *API) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error)

                  TraceBlock returns the structured logs created during the execution of EVM and returns them as a JSON object.

                  func (*API) TraceBlockByHash

                  func (api *API) TraceBlockByHash(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error)

                    TraceBlockByHash returns the structured logs created during the execution of EVM and returns them as a JSON object.

                    func (*API) TraceBlockByNumber

                    func (api *API) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error)

                      TraceBlockByNumber returns the structured logs created during the execution of EVM and returns them as a JSON object.

                      func (*API) TraceBlockFromFile

                      func (api *API) TraceBlockFromFile(ctx context.Context, file string, config *TraceConfig) ([]*txTraceResult, error)

                        TraceBlockFromFile returns the structured logs created during the execution of EVM and returns them as a JSON object.

                        func (*API) TraceCall

                        func (api *API) TraceCall(ctx context.Context, args ethapi.CallArgs, blockNrOrHash rpc.BlockNumberOrHash, config *TraceConfig) (interface{}, error)

                          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) TraceChain

                          func (api *API) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error)

                            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) TraceTransaction

                            func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error)

                              TraceTransaction returns the structured logs created during the execution of EVM and returns them as a JSON object.

                              type Backend

                              type Backend interface {
                              	HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)
                              	HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
                              	BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)
                              	BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error)
                              	GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error)
                              	RPCGasCap() uint64
                              	ChainConfig() *params.ChainConfig
                              	Engine() consensus.Engine
                              	ChainDb() ethdb.Database
                              	StateAtBlock(ctx context.Context, block *types.Block, reexec uint64) (*state.StateDB, func(), error)
                              	StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, func(), error)
                              	StatesInRange(ctx context.Context, fromBlock *types.Block, toBlock *types.Block, reexec uint64) ([]*state.StateDB, func(), error)
                              }

                                Backend interface provides the common API services (that are provided by both full and light clients) with access to necessary functions.

                                type StdTraceConfig

                                type StdTraceConfig struct {
                                	vm.LogConfig
                                	Reexec *uint64
                                	TxHash common.Hash
                                }

                                  StdTraceConfig holds extra parameters to standard-json trace functions.

                                  type TraceConfig

                                  type TraceConfig struct {
                                  	*vm.LogConfig
                                  	Tracer  *string
                                  	Timeout *string
                                  	Reexec  *uint64
                                  }

                                    TraceConfig holds extra parameters to trace functions.

                                    type Tracer

                                    type Tracer struct {
                                    	// contains filtered or unexported fields
                                    }

                                      Tracer provides an implementation of Tracer that evaluates a Javascript function for each VM execution step.

                                      func New

                                      func New(code string, txCtx vm.TxContext) (*Tracer, error)

                                        New instantiates a new tracer instance. code specifies a Javascript snippet, which must evaluate to an expression returning an object with 'step', 'fault' and 'result' functions.

                                        func (*Tracer) CaptureEnd

                                        func (jst *Tracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error)

                                          CaptureEnd is called after the call finishes to finalize the tracing.

                                          func (*Tracer) CaptureFault

                                          func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error)

                                            CaptureFault implements the Tracer interface to trace an execution fault

                                            func (*Tracer) CaptureStart

                                            func (jst *Tracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int)

                                              CaptureStart implements the Tracer interface to initialize the tracing operation.

                                              func (*Tracer) CaptureState

                                              func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error)

                                                CaptureState implements the Tracer interface to trace a single step of VM execution.

                                                func (*Tracer) GetResult

                                                func (jst *Tracer) GetResult() (json.RawMessage, error)

                                                  GetResult calls the Javascript 'result' function and returns its value, or any accumulated error

                                                  func (*Tracer) Stop

                                                  func (jst *Tracer) Stop(err error)

                                                    Stop terminates execution of the tracer at the first opportune moment.

                                                    Directories

                                                    Path Synopsis
                                                    internal
                                                    tracers
                                                    Package tracers contains the actual JavaScript tracer assets.
                                                    Package tracers contains the actual JavaScript tracer assets.