diff --git a/eth/tracers/live/tenderly_simple_hooks.go b/eth/tracers/live/tenderly_simple_hooks.go new file mode 100644 index 0000000000..40ac93d34d --- /dev/null +++ b/eth/tracers/live/tenderly_simple_hooks.go @@ -0,0 +1,46 @@ +package live + +import ( + "encoding/json" + gethtracing "github.com/ethereum/go-ethereum/core/tracing" + gethtracers "github.com/ethereum/go-ethereum/eth/tracers" +) + +// init registers the tenderly tracer hooks with the gethtracers.LiveDirectory +func init() { + gethtracers.LiveDirectory.Register("tenderly_simple_tracer_hooks", NewTenderlySimpleTracerHooks) +} + +// NewTenderlySimpleTracerHooks creates a new set of tracer hooks for the tenderly tracer. +func NewTenderlySimpleTracerHooks(jsonConfig json.RawMessage) (*gethtracing.Hooks, error) { + // tracer + tracer := NewTenderlySimpleTracer() + + // hook the tracer + return &gethtracing.Hooks{ + OnTxStart: tracer.OnTxStart, + OnTxEnd: tracer.OnTxEnd, + OnEnter: tracer.OnEnter, + OnExit: tracer.OnExit, + OnOpcode: tracer.OnOpcode, + + OnClose: tracer.OnClose, + OnBlockStart: tracer.OnBlockStart, + OnBlockEnd: tracer.OnBlockEnd, + OnSystemCallStart: tracer.OnSystemCallStart, + OnSystemCallEnd: tracer.OnSystemCallEnd, + //OnSystemCallStartV2: tracer.OnSystemCallStartV2, + + OnBalanceChange: tracer.OnBalanceChange, + OnNonceChange: tracer.OnNonceChange, + OnCodeChange: tracer.OnCodeChange, + OnStorageChange: tracer.OnStorageChange, + + //OnBalanceRead: inner.OnBalanceRead, + //OnNonceRead: inner.OnNonceRead, + //OnCodeRead: inner.OnCodeRead, + //OnCodeSizeRead: inner.OnCodeSizeRead, + //OnCodeHashRead: inner.OnCodeHashRead, + //OnStorageRead: inner.OnStorageRead, + }, nil +} diff --git a/eth/tracers/live/tenderly_simple_tracer.go b/eth/tracers/live/tenderly_simple_tracer.go new file mode 100644 index 0000000000..b63f580d27 --- /dev/null +++ b/eth/tracers/live/tenderly_simple_tracer.go @@ -0,0 +1,137 @@ +package live + +import ( + gethcommon "github.com/ethereum/go-ethereum/common" + gethtracing "github.com/ethereum/go-ethereum/core/tracing" + gethtypes "github.com/ethereum/go-ethereum/core/types" + "math/big" +) + +// TenderlySimpleTracer is an interface that is used to trace the execution of a block. +type TenderlySimpleTracer interface { + OnBlockStart(event gethtracing.BlockEvent) + OnBlockEnd(err error) + OnClose() + OnSystemCallStart() + OnSystemCallStartV2(ctx *gethtracing.VMContext) + OnSystemCallEnd() + OnTxStart(ctx *gethtracing.VMContext, tx *gethtypes.Transaction, from gethcommon.Address) + OnTxEnd(receipt *gethtypes.Receipt, err error) + OnEnter(_ int, typ byte, from gethcommon.Address, to gethcommon.Address, input []byte, gas uint64, value *big.Int) + OnExit(_ int, output []byte, used uint64, err error, reverted bool) + OnOpcode(pc uint64, typ byte, gas, cost uint64, scope gethtracing.OpContext, rData []byte, depth int, err error) + OnBalanceChange(addr gethcommon.Address, prev *big.Int, n *big.Int, reason gethtracing.BalanceChangeReason) + OnNonceChange(addr gethcommon.Address, prev, new uint64) + OnCodeChange(addr gethcommon.Address, prevCodeHash gethcommon.Hash, prevCode []byte, codeHash gethcommon.Hash, code []byte) + OnStorageChange(addr gethcommon.Address, slot gethcommon.Hash, prev, new gethcommon.Hash) + OnBalanceRead(addr gethcommon.Address, bal *big.Int) + OnNonceRead(addr gethcommon.Address, nonce uint64) + OnCodeRead(addr gethcommon.Address, code []byte) + OnCodeSizeRead(addr gethcommon.Address, size int) + OnCodeHashRead(addr gethcommon.Address, hash gethcommon.Hash) + OnStorageRead(addr gethcommon.Address, slot gethcommon.Hash, value gethcommon.Hash) +} + +// Ensure that simpleTracer implements the TenderlySimpleTracer interface. +var _ TenderlySimpleTracer = (*simpleTracer)(nil) + +// simpleTracer is a simple implementation of the TenderlySimpleTracer interface. +// It just represents the tenderly tracing flow. +// We hook to the gethtracing.Hooks to get the tracing events. +// We build the block and transaction data from the tracing events. +// OnBlockEnd, we send the block data to the tenderly pipeline for further processing. +type simpleTracer struct { + block *gethtypes.Block + tx *gethtypes.Transaction +} + +// NewTenderlySimpleTracer creates a new instance of the simpleTracer. +func NewTenderlySimpleTracer() TenderlySimpleTracer { + return &simpleTracer{} +} + +func (t *simpleTracer) OnBlockStart(event gethtracing.BlockEvent) { + //log.Info("tenderly::OnBlockStart", "event", event) + t.block = event.Block +} + +func (t *simpleTracer) OnBlockEnd(err error) { + //log.Info("tenderly::OnBlockEnd", "err", err) +} + +func (t *simpleTracer) OnClose() { + //log.Info("tenderly::OnClose") +} + +func (t *simpleTracer) OnSystemCallStart() { + //log.Info("tenderly::OnSystemCallStart") +} + +func (t *simpleTracer) OnSystemCallStartV2(ctx *gethtracing.VMContext) { + //log.Info("tenderly::OnSystemCallStartV2", "ctx", ctx) +} + +func (t *simpleTracer) OnSystemCallEnd() { + //log.Info("tenderly::OnSystemCallEnd") +} + +func (t *simpleTracer) OnTxStart(ctx *gethtracing.VMContext, tx *gethtypes.Transaction, from gethcommon.Address) { + //log.Info("tenderly::OnTxStart", "ctx", ctx, "tx", tx, "from", from) + t.tx = tx +} + +func (t *simpleTracer) OnTxEnd(receipt *gethtypes.Receipt, err error) { + //log.Info("tenderly::OnTxEnd", "receipt", receipt, "err", err) +} + +func (t *simpleTracer) OnEnter(_ int, typ byte, from gethcommon.Address, to gethcommon.Address, input []byte, gas uint64, value *big.Int) { + //log.Info("tenderly::OnEnter", "typ", typ, "from", from, "to", to, "input", input, "gas", gas, "value", value) +} + +func (t *simpleTracer) OnExit(_ int, output []byte, used uint64, err error, reverted bool) { + //log.Info("tenderly::OnExit", "output", output, "used", used, "err", err, "reverted", reverted) +} + +func (t *simpleTracer) OnOpcode(pc uint64, typ byte, gas, cost uint64, scope gethtracing.OpContext, rData []byte, depth int, err error) { + //log.Info("tenderly::OnOpcode", "pc", pc, "typ", typ, "gas", gas, "cost", cost, "scope", scope, "rData", rData, "depth", depth, "err", err) +} + +func (t *simpleTracer) OnBalanceChange(addr gethcommon.Address, prev *big.Int, n *big.Int, reason gethtracing.BalanceChangeReason) { + //log.Info("tenderly::OnBalanceChange", "addr", addr, "prev", prev, "n", n, "reason", reason) +} + +func (t *simpleTracer) OnNonceChange(addr gethcommon.Address, prev, new uint64) { + //log.Info("tenderly::OnNonceChange", "addr", addr, "prev", prev, "new", new) +} + +func (t *simpleTracer) OnCodeChange(addr gethcommon.Address, prevCodeHash gethcommon.Hash, prevCode []byte, codeHash gethcommon.Hash, code []byte) { + //log.Info("tenderly::OnCodeChange", "addr", addr, "prevCodeHash", prevCodeHash, "prevCode", prevCode, "codeHash", codeHash, "code", code) +} + +func (t *simpleTracer) OnStorageChange(addr gethcommon.Address, slot gethcommon.Hash, prev, new gethcommon.Hash) { + //log.Info("tenderly::OnStorageChange", "addr", addr, "slot", slot, "prev", prev, "new", new) +} + +func (t *simpleTracer) OnBalanceRead(addr gethcommon.Address, bal *big.Int) { + //log.Info("tenderly::OnBalanceRead", "addr", addr, "bal", bal) +} + +func (t *simpleTracer) OnNonceRead(addr gethcommon.Address, nonce uint64) { + //log.Info("tenderly::OnNonceRead", "addr", addr, "nonce", nonce) +} + +func (t *simpleTracer) OnCodeRead(addr gethcommon.Address, code []byte) { + //log.Info("tenderly::OnCodeRead", "addr", addr, "code", code) +} + +func (t *simpleTracer) OnCodeSizeRead(addr gethcommon.Address, size int) { + //log.Info("tenderly::OnCodeSizeRead", "addr", addr, "size", size) +} + +func (t *simpleTracer) OnCodeHashRead(addr gethcommon.Address, hash gethcommon.Hash) { + //log.Info("tenderly::OnCodeHashRead", "addr", addr, "hash", hash) +} + +func (t *simpleTracer) OnStorageRead(addr gethcommon.Address, slot gethcommon.Hash, value gethcommon.Hash) { + //log.Info("tenderly::OnStorageRead", "addr", addr, "slot", slot, "value", value) +}