logger

package
v0.0.0-...-92d349b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 15, 2023 License: GPL-3.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrTraceLimitReached = errors.New("the number of logs reached the specified limit")

Functions

func NewMarkdownLogger 

func NewMarkdownLogger(cfg *LogConfig, writer io.Writer) *mdLogger

NewMarkdownLogger creates a logger which outputs information in a format adapted for human readability, and is also a valid markdown table

func WriteLogs 

func WriteLogs(writer io.Writer, logs []*types.Log)

WriteLogs writes vm logs in a readable format to the given writer

func WriteTrace 

func WriteTrace(writer io.Writer, logs []StructLog)

WriteTrace writes a formatted trace to the given writer

Types

type AccessListTracer 

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

AccessListTracer is a tracer that accumulates touched accounts and storage slots into an internal set.

func NewAccessListTracer 

func NewAccessListTracer(acl types2.AccessList, from, to libcommon.Address, precompiles []libcommon.Address) *AccessListTracer

NewAccessListTracer creates a new tracer that can generate AccessLists. An optional AccessList can be specified to occupy slots and addresses in the resulting accesslist.

func (*AccessListTracer) AccessList 

func (a *AccessListTracer) AccessList() types2.AccessList

AccessList returns the current accesslist maintained by the tracer.

func (*AccessListTracer) CaptureEnd 

func (*AccessListTracer) CaptureEnd(output []byte, usedGas uint64, err error)

func (*AccessListTracer) CaptureEnter 

func (a *AccessListTracer) CaptureEnter(typ vm.OpCode, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*AccessListTracer) CaptureExit 

func (*AccessListTracer) CaptureExit(output []byte, usedGas uint64, err error)

func (*AccessListTracer) CaptureFault 

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

func (*AccessListTracer) CaptureStart 

func (a *AccessListTracer) CaptureStart(env vm.VMInterface, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*AccessListTracer) CaptureState 

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

CaptureState captures all opcodes that touch storage or addresses and adds them to the accesslist.

func (*AccessListTracer) CaptureTxEnd 

func (a *AccessListTracer) CaptureTxEnd(restGas uint64)

func (*AccessListTracer) CaptureTxStart 

func (a *AccessListTracer) CaptureTxStart(gasLimit uint64)

func (*AccessListTracer) Equal 

func (a *AccessListTracer) Equal(other *AccessListTracer) bool

Equal returns if the content of two access list traces are equal.

type JSONFileLogger 

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

func NewJSONFileLogger 

func NewJSONFileLogger(cfg *LogConfig, txHash string) *JSONFileLogger

NewJSONFileLogger creates a new EVM tracer that prints execution steps as JSON objects into the provided stream.

func (*JSONFileLogger) CaptureEnd 

func (l *JSONFileLogger) CaptureEnd(output []byte, usedGas uint64, err error)

CaptureEnd is triggered at end of execution.

func (*JSONFileLogger) CaptureEnter 

func (l *JSONFileLogger) CaptureEnter(typ vm.OpCode, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*JSONFileLogger) CaptureExit 

func (l *JSONFileLogger) CaptureExit(output []byte, usedGas uint64, err error)

func (*JSONFileLogger) CaptureFault 

func (l *JSONFileLogger) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error)

CaptureFault outputs state information on the logger.

func (*JSONFileLogger) CaptureStart 

func (l *JSONFileLogger) CaptureStart(env vm.VMInterface, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*JSONFileLogger) CaptureState 

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

CaptureState outputs state information on the logger.

func (*JSONFileLogger) CaptureTxEnd 

func (l *JSONFileLogger) CaptureTxEnd(restGas uint64)

func (*JSONFileLogger) CaptureTxStart 

func (l *JSONFileLogger) CaptureTxStart(gasLimit uint64)

type JSONLogger 

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

func NewJSONLogger 

func NewJSONLogger(cfg *LogConfig, writer io.Writer) *JSONLogger

NewJSONLogger creates a new EVM tracer that prints execution steps as JSON objects into the provided stream.

func (*JSONLogger) CaptureEnd 

func (l *JSONLogger) CaptureEnd(output []byte, usedGas uint64, err error)

CaptureEnd is triggered at end of execution.

func (*JSONLogger) CaptureEnter 

func (l *JSONLogger) CaptureEnter(typ vm.OpCode, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*JSONLogger) CaptureExit 

func (l *JSONLogger) CaptureExit(output []byte, usedGas uint64, err error)

func (*JSONLogger) CaptureFault 

func (l *JSONLogger) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error)

CaptureFault outputs state information on the logger.

func (*JSONLogger) CaptureStart 

func (l *JSONLogger) CaptureStart(env vm.VMInterface, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*JSONLogger) CaptureState 

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

CaptureState outputs state information on the logger.

func (*JSONLogger) CaptureTxEnd 

func (l *JSONLogger) CaptureTxEnd(restGas uint64)

func (*JSONLogger) CaptureTxStart 

func (l *JSONLogger) CaptureTxStart(gasLimit uint64)

type JsonStreamLogger 

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

JsonStreamLogger is an EVM state logger and implements Tracer.

JsonStreamLogger can capture state based on the given Log configuration and also keeps a track record of modified storage which is used in reporting snapshots of the contract their storage.

func NewJsonStreamLogger 

func NewJsonStreamLogger(cfg *LogConfig, ctx context.Context, stream *jsoniter.Stream) *JsonStreamLogger

NewStructLogger returns a new logger

func (*JsonStreamLogger) CaptureEnd 

func (l *JsonStreamLogger) CaptureEnd(output []byte, usedGas uint64, err error)

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

func (*JsonStreamLogger) CaptureEnter 

func (l *JsonStreamLogger) CaptureEnter(typ vm.OpCode, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

func (*JsonStreamLogger) CaptureExit 

func (l *JsonStreamLogger) CaptureExit(output []byte, usedGas uint64, err error)

func (*JsonStreamLogger) CaptureFault 

func (l *JsonStreamLogger) CaptureFault(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 while running an opcode.

func (*JsonStreamLogger) CaptureStart 

func (l *JsonStreamLogger) CaptureStart(env vm.VMInterface, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

CaptureStart implements the Tracer interface to initialize the tracing operation.

func (*JsonStreamLogger) CaptureState 

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

CaptureState logs a new structured log message and pushes it out to the environment

CaptureState also tracks SLOAD/SSTORE ops to track storage change.

func (*JsonStreamLogger) CaptureTxEnd 

func (l *JsonStreamLogger) CaptureTxEnd(restGas uint64)

func (*JsonStreamLogger) CaptureTxStart 

func (l *JsonStreamLogger) CaptureTxStart(gasLimit uint64)

type LogConfig 

type LogConfig struct {
	DisableMemory     bool // disable memory capture
	DisableStack      bool // disable stack capture
	DisableStorage    bool // disable storage capture
	DisableReturnData bool // disable return data capture
	Debug             bool // print output during capture end
	Limit             int  // maximum length of output, but zero means unlimited
	// Chain overrides, can be used to execute a trace using future fork rules
	Overrides *chain.Config `json:"overrides,omitempty"`
}

LogConfig are the configuration options for structured logger the EVM

type OpContext 

type OpContext struct {
	Pc      uint64   `json:"pc"`
	Op      string   `json:"op"`
	Gas     uint64   `json:"gas"`
	GasCost uint64   `json:"gasCost"`
	Depth   int      `json:"depth"`
	Stack   []string `json:"stack"`
	Memory  string   `json:"memory"`
	Refund  uint64   `json:"refund"`
}

func (*OpContext) Cmp 

func (l *OpContext) Cmp(b OpContext) bool

type Storage 

type Storage map[libcommon.Hash]libcommon.Hash

Storage represents a contract's storage.

func (Storage) Copy 

func (s Storage) Copy() Storage

Copy duplicates the current storage.

type StructLog 

type StructLog struct {
	Pc            uint64                            `json:"pc"`
	Op            vm.OpCode                         `json:"op"`
	Gas           uint64                            `json:"gas"`
	GasCost       uint64                            `json:"gasCost"`
	Memory        []byte                            `json:"memory"`
	MemorySize    int                               `json:"memSize"`
	Stack         []*big.Int                        `json:"stack"`
	ReturnData    []byte                            `json:"returnData"`
	Storage       map[libcommon.Hash]libcommon.Hash `json:"-"`
	Depth         int                               `json:"depth"`
	RefundCounter uint64                            `json:"refund"`
	Err           error                             `json:"-"`
}

StructLog is emitted to the EVM each cycle and lists information about the current internal state prior to the execution of the statement.

func (*StructLog) ErrorString 

func (s *StructLog) ErrorString() string

ErrorString formats the log's error as a string.

func (StructLog) MarshalJSON 

func (s StructLog) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*StructLog) OpName 

func (s *StructLog) OpName() string

OpName formats the operand name in a human-readable format.

func (*StructLog) UnmarshalJSON 

func (s *StructLog) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type StructLogRes 

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          `json:"memory,omitempty"`
	Storage *map[string]string `json:"storage,omitempty"`
}

StructLogRes stores a structured log emitted by the EVM while replaying a transaction in debug mode

func FormatLogs 

func FormatLogs(logs []StructLog) []StructLogRes

FormatLogs formats EVM returned structured logs for json output

type StructLogger 

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

StructLogger is an EVM state logger and implements Tracer.

StructLogger can capture state based on the given Log configuration and also keeps a track record of modified storage which is used in reporting snapshots of the contract their storage.

func NewStructLogger 

func NewStructLogger(cfg *LogConfig) *StructLogger

NewStructLogger returns a new logger

func (*StructLogger) CaptureEnd 

func (l *StructLogger) CaptureEnd(output []byte, usedGas uint64, err error)

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

func (*StructLogger) CaptureEnter 

func (l *StructLogger) CaptureEnter(typ vm.OpCode, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

CaptureEnter implements the Tracer interface to initialize the tracing operation for an internal call.

func (*StructLogger) CaptureExit 

func (l *StructLogger) CaptureExit(output []byte, usedGas uint64, err error)

CaptureExit is called after the internal call finishes to finalize the tracing.

func (*StructLogger) CaptureFault 

func (l *StructLogger) CaptureFault(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 while running an opcode.

func (*StructLogger) CaptureStart 

func (l *StructLogger) CaptureStart(env vm.VMInterface, from libcommon.Address, to libcommon.Address, precompile bool, create bool, input []byte, gas uint64, value *uint256.Int, code []byte)

CaptureStart implements the Tracer interface to initialize the tracing operation.

func (*StructLogger) CaptureState 

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

CaptureState logs a new structured log message and pushes it out to the environment

CaptureState also tracks SLOAD/SSTORE ops to track storage change.

func (*StructLogger) CaptureTxEnd 

func (l *StructLogger) CaptureTxEnd(restGas uint64)

func (*StructLogger) CaptureTxStart 

func (l *StructLogger) CaptureTxStart(gasLimit uint64)

func (*StructLogger) Error 

func (l *StructLogger) Error() error

Error returns the VM error captured by the trace.

func (*StructLogger) Flush 

func (l *StructLogger) Flush(tx types.Transaction)

func (*StructLogger) Output 

func (l *StructLogger) Output() []byte

Output returns the VM return value captured by the trace.

func (*StructLogger) StructLogs 

func (l *StructLogger) StructLogs() []StructLog

StructLogs returns the captured log entries.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.