tracers

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

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) (bool, *types.Transaction, common.Hash, uint64, uint64, error)
	RPCGasCap() uint64
	ChainConfig() ctypes.ChainConfigurator
	Engine() consensus.Engine
	ChainDb() ethdb.Database
	StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error)
	StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, StateReleaseFunc, error)
}

type Context struct {
	BlockHash   common.Hash // Hash of the block the tx is contained within (zero if dangling tx or call)
	BlockNumber *big.Int    // Number of the block the tx is contained within (zero if dangling tx or call)
	TxIndex     int         // Index of the transaction within a block (zero if dangling tx or call)
	TxHash      common.Hash // Hash of the transaction being traced (zero if dangling call)
}

type ParityTrace struct {
	Action              TraceRewardAction `json:"action"`
	BlockHash           common.Hash       `json:"blockHash"`
	BlockNumber         uint64            `json:"blockNumber"`
	Error               string            `json:"error,omitempty"`
	Result              interface{}       `json:"result"`
	Subtraces           int               `json:"subtraces"`
	TraceAddress        []int             `json:"traceAddress"`
	TransactionHash     *common.Hash      `json:"transactionHash"`
	TransactionPosition *uint64           `json:"transactionPosition"`
	Type                string            `json:"type"`
}

type StateReleaseFunc func()

type StdTraceConfig struct {
	logger.Config
	Reexec *uint64
	TxHash common.Hash
}

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

type TraceCallConfig struct {
	TraceConfig
	StateOverrides    *ethapi.StateOverride
	BlockOverrides    *ethapi.BlockOverrides
	NestedTraceOutput bool // Returns the trace output JSON nested under the trace name key. This allows full Parity compatibility to be achieved.
	TxIndex           *hexutil.Uint
}

type TraceConfig struct {
	*logger.Config
	Tracer            *string
	Timeout           *string
	Reexec            *uint64
	NestedTraceOutput bool // Returns the trace output JSON nested under the trace name key. This allows full Parity compatibility to be achieved.
	// Config specific to given tracer. Note struct logger
	// config are historically embedded in main object.
	TracerConfig json.RawMessage
}

type TraceFilterArgs struct {
	FromBlock   hexutil.Uint64  `json:"fromBlock,omitempty"`   // Trace from this starting block
	ToBlock     hexutil.Uint64  `json:"toBlock,omitempty"`     // Trace utill this end block
	FromAddress *common.Address `json:"fromAddress,omitempty"` // Sent from these addresses
	ToAddress   *common.Address `json:"toAddress,omitempty"`   // Sent to these addresses
	After       uint64          `json:"after,omitempty"`       // The offset trace number
	Count       uint64          `json:"count,omitempty"`       // Integer number of traces to display in a batch
}

type TraceRewardAction struct {
	Value      *hexutil.Big    `json:"value,omitempty"`
	Author     *common.Address `json:"author,omitempty"`
	RewardType string          `json:"rewardType,omitempty"`
}

type Tracer interface {
	vm.EVMLogger
	GetResult() (json.RawMessage, error)
	// Stop terminates execution of the tracer at the first opportune moment.
	Stop(err error)
}