diff --git a/cmd/geth/main.go b/cmd/geth/main.go index deeb458f9..173bc6b4f 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -41,7 +41,7 @@ import ( "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/plugins" - "github.com/ethereum/go-ethereum/plugins/wrappers" + "github.com/ethereum/go-ethereum/plugins/wrappers/backendwrapper" "gopkg.in/urfave/cli.v1" ) @@ -307,7 +307,9 @@ func prepare(ctx *cli.Context) { // It creates a default node based on the command line arguments and runs it in // blocking mode, waiting for it to be shut down. func geth(ctx *cli.Context) error { - if err := plugins.Initialize(path.Join(ctx.GlobalString(utils.DataDirFlag.Name), "plugins"), ctx); err != nil { return err } + if err := plugins.Initialize(path.Join(ctx.GlobalString(utils.DataDirFlag.Name), "plugins"), ctx); err != nil { + return err + } prepare(ctx) if !plugins.ParseFlags(ctx.Args()) { if args := ctx.Args(); len(args) > 0 { @@ -315,7 +317,7 @@ func geth(ctx *cli.Context) error { } } stack, backend := makeFullNode(ctx) - wrapperBackend := wrappers.NewBackend(backend) + wrapperBackend := backendwrapper.NewBackend(backend) pluginsInitializeNode(stack, wrapperBackend) if ok, err := plugins.RunSubcommand(ctx); ok { stack.Close() diff --git a/core/plugin_hooks.go b/core/plugin_hooks.go index 462560d2e..de38dfcfe 100644 --- a/core/plugin_hooks.go +++ b/core/plugin_hooks.go @@ -1,182 +1,286 @@ package core import ( - "encoding/json" - "math/big" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/plugins" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/rlp" - "github.com/openrelayxyz/plugeth-utils/core" + "encoding/json" + "math/big" + "reflect" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/plugins" + "github.com/ethereum/go-ethereum/plugins/wrappers" + "github.com/ethereum/go-ethereum/rlp" + "github.com/openrelayxyz/plugeth-utils/core" ) func PluginPreProcessBlock(pl *plugins.PluginLoader, block *types.Block) { - fnList := pl.Lookup("PreProcessBlock", func(item interface{}) bool { - _, ok := item.(func(core.Hash, uint64, []byte)) - return ok - }) - encoded, _ := rlp.EncodeToBytes(block) - for _, fni := range fnList { - if fn, ok := fni.(func(core.Hash, uint64, []byte)); ok { - fn(core.Hash(block.Hash()), block.NumberU64(), encoded) - } - } + fnList := pl.Lookup("PreProcessBlock", func(item interface{}) bool { + _, ok := item.(func(core.Hash, uint64, []byte)) + return ok + }) + encoded, _ := rlp.EncodeToBytes(block) + for _, fni := range fnList { + if fn, ok := fni.(func(core.Hash, uint64, []byte)); ok { + fn(core.Hash(block.Hash()), block.NumberU64(), encoded) + } + } } func pluginPreProcessBlock(block *types.Block) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting PreProcessBlock, but default PluginLoader has not been initialized") - return - } - PluginPreProcessBlock(plugins.DefaultPluginLoader, block) // TODO + return + } + PluginPreProcessBlock(plugins.DefaultPluginLoader, block) // TODO } func PluginPreProcessTransaction(pl *plugins.PluginLoader, tx *types.Transaction, block *types.Block, i int) { - fnList := pl.Lookup("PreProcessTransaction", func(item interface{}) bool { - _, ok := item.(func([]byte, core.Hash, core.Hash, int)) - return ok - }) - txBytes, _ := tx.MarshalBinary() - for _, fni := range fnList { - if fn, ok := fni.(func([]byte, core.Hash, core.Hash, int)); ok { - fn(txBytes, core.Hash(tx.Hash()), core.Hash(block.Hash()), i) - } - } + fnList := pl.Lookup("PreProcessTransaction", func(item interface{}) bool { + _, ok := item.(func([]byte, core.Hash, core.Hash, int)) + return ok + }) + txBytes, _ := tx.MarshalBinary() + for _, fni := range fnList { + if fn, ok := fni.(func([]byte, core.Hash, core.Hash, int)); ok { + fn(txBytes, core.Hash(tx.Hash()), core.Hash(block.Hash()), i) + } + } } func pluginPreProcessTransaction(tx *types.Transaction, block *types.Block, i int) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting PreProcessTransaction, but default PluginLoader has not been initialized") - return - } - PluginPreProcessTransaction(plugins.DefaultPluginLoader, tx, block, i) + return + } + PluginPreProcessTransaction(plugins.DefaultPluginLoader, tx, block, i) } func PluginBlockProcessingError(pl *plugins.PluginLoader, tx *types.Transaction, block *types.Block, err error) { - fnList := pl.Lookup("BlockProcessingError", func(item interface{}) bool { - _, ok := item.(func(core.Hash, core.Hash, error)) - return ok - }) - for _, fni := range fnList { - if fn, ok := fni.(func(core.Hash, core.Hash, error)); ok { - fn(core.Hash(tx.Hash()), core.Hash(block.Hash()), err) - } - } + fnList := pl.Lookup("BlockProcessingError", func(item interface{}) bool { + _, ok := item.(func(core.Hash, core.Hash, error)) + return ok + }) + for _, fni := range fnList { + if fn, ok := fni.(func(core.Hash, core.Hash, error)); ok { + fn(core.Hash(tx.Hash()), core.Hash(block.Hash()), err) + } + } } func pluginBlockProcessingError(tx *types.Transaction, block *types.Block, err error) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting BlockProcessingError, but default PluginLoader has not been initialized") - return - } - PluginBlockProcessingError(plugins.DefaultPluginLoader, tx, block, err) + return + } + PluginBlockProcessingError(plugins.DefaultPluginLoader, tx, block, err) } func PluginPostProcessTransaction(pl *plugins.PluginLoader, tx *types.Transaction, block *types.Block, i int, receipt *types.Receipt) { - fnList := pl.Lookup("PostProcessTransaction", func(item interface{}) bool { - _, ok := item.(func(core.Hash, core.Hash, int, []byte)) - return ok - }) - receiptBytes, _ := json.Marshal(receipt) - for _, fni := range fnList { - if fn, ok := fni.(func(core.Hash, core.Hash, int, []byte)); ok { - fn(core.Hash(tx.Hash()), core.Hash(block.Hash()), i, receiptBytes) - } - } + fnList := pl.Lookup("PostProcessTransaction", func(item interface{}) bool { + _, ok := item.(func(core.Hash, core.Hash, int, []byte)) + return ok + }) + receiptBytes, _ := json.Marshal(receipt) + for _, fni := range fnList { + if fn, ok := fni.(func(core.Hash, core.Hash, int, []byte)); ok { + fn(core.Hash(tx.Hash()), core.Hash(block.Hash()), i, receiptBytes) + } + } } func pluginPostProcessTransaction(tx *types.Transaction, block *types.Block, i int, receipt *types.Receipt) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting PostProcessTransaction, but default PluginLoader has not been initialized") - return - } - PluginPostProcessTransaction(plugins.DefaultPluginLoader, tx, block, i, receipt) + return + } + PluginPostProcessTransaction(plugins.DefaultPluginLoader, tx, block, i, receipt) } func PluginPostProcessBlock(pl *plugins.PluginLoader, block *types.Block) { - fnList := pl.Lookup("PostProcessBlock", func(item interface{}) bool { - _, ok := item.(func(core.Hash)) - return ok - }) - for _, fni := range fnList { - if fn, ok := fni.(func(core.Hash)); ok { - fn(core.Hash(block.Hash())) - } - } + fnList := pl.Lookup("PostProcessBlock", func(item interface{}) bool { + _, ok := item.(func(core.Hash)) + return ok + }) + for _, fni := range fnList { + if fn, ok := fni.(func(core.Hash)); ok { + fn(core.Hash(block.Hash())) + } + } } func pluginPostProcessBlock(block *types.Block) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting PostProcessBlock, but default PluginLoader has not been initialized") - return - } - PluginPostProcessBlock(plugins.DefaultPluginLoader, block) + return + } + PluginPostProcessBlock(plugins.DefaultPluginLoader, block) } - - func PluginNewHead(pl *plugins.PluginLoader, block *types.Block, hash common.Hash, logs []*types.Log, td *big.Int) { - fnList := pl.Lookup("NewHead", func(item interface{}) bool { - _, ok := item.(func([]byte, core.Hash, [][]byte, *big.Int)) - return ok - }) - blockBytes, _ := rlp.EncodeToBytes(block) - logBytes := make([][]byte, len(logs)) - for i, l := range logs { - logBytes[i], _ = rlp.EncodeToBytes(l) - } - for _, fni := range fnList { - if fn, ok := fni.(func([]byte, core.Hash, [][]byte, *big.Int)); ok { - fn(blockBytes, core.Hash(hash), logBytes, td) - } - } + fnList := pl.Lookup("NewHead", func(item interface{}) bool { + _, ok := item.(func([]byte, core.Hash, [][]byte, *big.Int)) + return ok + }) + blockBytes, _ := rlp.EncodeToBytes(block) + logBytes := make([][]byte, len(logs)) + for i, l := range logs { + logBytes[i], _ = rlp.EncodeToBytes(l) + } + for _, fni := range fnList { + if fn, ok := fni.(func([]byte, core.Hash, [][]byte, *big.Int)); ok { + fn(blockBytes, core.Hash(hash), logBytes, td) + } + } } func pluginNewHead(block *types.Block, hash common.Hash, logs []*types.Log, td *big.Int) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting NewHead, but default PluginLoader has not been initialized") - return - } - PluginNewHead(plugins.DefaultPluginLoader, block, hash, logs, td) + return + } + PluginNewHead(plugins.DefaultPluginLoader, block, hash, logs, td) } func PluginNewSideBlock(pl *plugins.PluginLoader, block *types.Block, hash common.Hash, logs []*types.Log) { - fnList := pl.Lookup("NewSideBlock", func(item interface{}) bool { - _, ok := item.(func([]byte, core.Hash, [][]byte)) - return ok - }) - blockBytes, _ := rlp.EncodeToBytes(block) - logBytes := make([][]byte, len(logs)) - for i, l := range logs { - logBytes[i], _ = rlp.EncodeToBytes(l) - } - for _, fni := range fnList { - if fn, ok := fni.(func([]byte, core.Hash, [][]byte)); ok { - fn(blockBytes, core.Hash(hash), logBytes) - } - } + fnList := pl.Lookup("NewSideBlock", func(item interface{}) bool { + _, ok := item.(func([]byte, core.Hash, [][]byte)) + return ok + }) + blockBytes, _ := rlp.EncodeToBytes(block) + logBytes := make([][]byte, len(logs)) + for i, l := range logs { + logBytes[i], _ = rlp.EncodeToBytes(l) + } + for _, fni := range fnList { + if fn, ok := fni.(func([]byte, core.Hash, [][]byte)); ok { + fn(blockBytes, core.Hash(hash), logBytes) + } + } } func pluginNewSideBlock(block *types.Block, hash common.Hash, logs []*types.Log) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting NewSideBlock, but default PluginLoader has not been initialized") - return - } - PluginNewSideBlock(plugins.DefaultPluginLoader, block, hash, logs) + return + } + PluginNewSideBlock(plugins.DefaultPluginLoader, block, hash, logs) } func PluginReorg(pl *plugins.PluginLoader, commonBlock *types.Block, oldChain, newChain types.Blocks) { - fnList := pl.Lookup("Reorg", func(item interface{}) bool { - _, ok := item.(func(core.Hash, []core.Hash, []core.Hash)) - return ok - }) - oldChainHashes := make([]core.Hash, len(oldChain)) - for i, block := range oldChain { - oldChainHashes[i] = core.Hash(block.Hash()) - } - newChainHashes := make([]core.Hash, len(newChain)) - for i, block := range newChain { - newChainHashes[i] = core.Hash(block.Hash()) - } - for _, fni := range fnList { - if fn, ok := fni.(func(core.Hash, []core.Hash, []core.Hash)); ok { - fn(core.Hash(commonBlock.Hash()), oldChainHashes, newChainHashes) - } - } + fnList := pl.Lookup("Reorg", func(item interface{}) bool { + _, ok := item.(func(core.Hash, []core.Hash, []core.Hash)) + return ok + }) + oldChainHashes := make([]core.Hash, len(oldChain)) + for i, block := range oldChain { + oldChainHashes[i] = core.Hash(block.Hash()) + } + newChainHashes := make([]core.Hash, len(newChain)) + for i, block := range newChain { + newChainHashes[i] = core.Hash(block.Hash()) + } + for _, fni := range fnList { + if fn, ok := fni.(func(core.Hash, []core.Hash, []core.Hash)); ok { + fn(core.Hash(commonBlock.Hash()), oldChainHashes, newChainHashes) + } + } } func pluginReorg(commonBlock *types.Block, oldChain, newChain types.Blocks) { - if plugins.DefaultPluginLoader == nil { + if plugins.DefaultPluginLoader == nil { log.Warn("Attempting Reorg, but default PluginLoader has not been initialized") - return - } - PluginReorg(plugins.DefaultPluginLoader, commonBlock, oldChain, newChain) + return + } + PluginReorg(plugins.DefaultPluginLoader, commonBlock, oldChain, newChain) +} + +type metaTracer struct { + tracers []core.BlockTracer +} + +func (mt *metaTracer) PreProcessBlock(block *types.Block) { + blockHash := core.Hash(block.Hash()) + blockNumber := block.NumberU64() + encoded, _ := rlp.EncodeToBytes(block) + for _, tracer := range mt.tracers { + tracer.PreProcessBlock(blockHash, blockNumber, encoded) + } +} +func (mt *metaTracer) PreProcessTransaction(tx *types.Transaction, block *types.Block, i int) { + blockHash := core.Hash(block.Hash()) + transactionHash := core.Hash(tx.Hash()) + for _, tracer := range mt.tracers { + tracer.PreProcessTransaction(transactionHash, blockHash, i) + } +} +func (mt *metaTracer) BlockProcessingError(tx *types.Transaction, block *types.Block, err error) { + blockHash := core.Hash(block.Hash()) + transactionHash := core.Hash(tx.Hash()) + for _, tracer := range mt.tracers { + tracer.BlockProcessingError(transactionHash, blockHash, err) + } +} +func (mt *metaTracer) PostProcessTransaction(tx *types.Transaction, block *types.Block, i int, receipt *types.Receipt) { + blockHash := core.Hash(block.Hash()) + transactionHash := core.Hash(tx.Hash()) + receiptBytes, _ := json.Marshal(receipt) + for _, tracer := range mt.tracers { + tracer.PostProcessTransaction(transactionHash, blockHash, i, receiptBytes) + } +} +func (mt *metaTracer) PostProcessBlock(block *types.Block) { + blockHash := core.Hash(block.Hash()) + for _, tracer := range mt.tracers { + tracer.PostProcessBlock(blockHash) + } +} +func (mt *metaTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) { + for _, tracer := range mt.tracers { + tracer.CaptureStart(core.Address(from), core.Address(to), create, input, gas, value) + } +} +func (mt *metaTracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) { + for _, tracer := range mt.tracers { + tracer.CaptureState(pc, core.OpCode(op), gas, cost, wrappers.NewWrappedScopeContext(scope), rData, depth, err) + } +} +func (mt *metaTracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) { + for _, tracer := range mt.tracers { + tracer.CaptureFault(pc, core.OpCode(op), gas, cost, wrappers.NewWrappedScopeContext(scope), depth, err) + } +} +func (mt *metaTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) { + for _, tracer := range mt.tracers { + tracer.CaptureEnd(output, gasUsed, t, err) + } +} + +func (mt *metaTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) { + for _, tracer := range mt.tracers { + tracer.CaptureEnter(core.OpCode(typ), core.Address(from), core.Address(to), input, gas, value) + } +} + +func (mt *metaTracer) CaptureExit(output []byte, gasUsed uint64, err error) { + for _, tracer := range mt.tracers { + tracer.CaptureExit(output, gasUsed, err) + } +} + +func PluginGetBlockTracer(pl *plugins.PluginLoader, hash common.Hash, statedb *state.StateDB) *metaTracer { + //look for a function that takes whatever the ctx provides and statedb and returns a core.blocktracer append into meta tracer + log.Info("in pluginGetLiveTracer") + tracerList := plugins.Lookup("GetLiveTracer", func(item interface{}) bool { + _, ok := item.(func(core.Hash, core.StateDB) core.BlockTracer) + log.Info("Item is LiveTracer", "ok", ok, "type", reflect.TypeOf(item)) + return ok + }) + mt := &metaTracer{tracers: []core.BlockTracer{}} + for _, tracer := range tracerList { + if v, ok := tracer.(func(core.Hash, core.StateDB) core.BlockTracer); ok { + bt := v(core.Hash(hash), wrappers.NewWrappedStateDB(statedb)) + if bt != nil { + mt.tracers = append(mt.tracers, bt) + } + } + } + return mt +} +func pluginGetBlockTracer(hash common.Hash, statedb *state.StateDB) *metaTracer { + if plugins.DefaultPluginLoader == nil { + log.Warn("Attempting GetBlockTracer, but default PluginLoader has not been initialized") + return nil + } + return PluginGetBlockTracer(plugins.DefaultPluginLoader, hash, statedb) } diff --git a/core/state_processor.go b/core/state_processor.go index 09f80380d..273815fae 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -71,29 +71,38 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg misc.ApplyDAOHardFork(statedb) } blockContext := NewEVMBlockContext(header, p.bc, nil) + blockTracer := pluginGetBlockTracer(header.Hash(), statedb) + cfg.Tracer = blockTracer + cfg.Debug = true vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg) // Iterate over and process the individual transactions pluginPreProcessBlock(block) + blockTracer.PreProcessBlock(block) for i, tx := range block.Transactions() { msg, err := tx.AsMessage(types.MakeSigner(p.config, header.Number), header.BaseFee) if err != nil { pluginBlockProcessingError(tx, block, err) + blockTracer.BlockProcessingError(tx, block, err) return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } statedb.Prepare(tx.Hash(), i) pluginPreProcessTransaction(tx, block, i) + blockTracer.PreProcessTransaction(tx, block, i) receipt, err := applyTransaction(msg, p.config, p.bc, nil, gp, statedb, blockNumber, blockHash, tx, usedGas, vmenv) if err != nil { pluginBlockProcessingError(tx, block, err) + blockTracer.BlockProcessingError(tx, block, err) return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } pluginPostProcessTransaction(tx, block, i, receipt) + blockTracer.PostProcessTransaction(tx, block, i, receipt) receipts = append(receipts, receipt) allLogs = append(allLogs, receipt.Logs...) } // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles()) pluginPostProcessBlock(block) + blockTracer.PostProcessBlock(block) return receipts, allLogs, *usedGas, nil } diff --git a/eth/backend.go b/eth/backend.go index e482bd1ad..9bfa844c7 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -188,7 +188,6 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { Preimages: config.Preimages, } ) - pluginUpdateBlockchainVMConfig(&vmConfig) eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, chainConfig, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit) if err != nil { return nil, err diff --git a/eth/plugin_hooks.go b/eth/plugin_hooks.go deleted file mode 100644 index 5773504af..000000000 --- a/eth/plugin_hooks.go +++ /dev/null @@ -1,74 +0,0 @@ -package eth - -import ( - "math/big" - "reflect" - "time" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/vm" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/plugins" - "github.com/ethereum/go-ethereum/plugins/wrappers" - "github.com/openrelayxyz/plugeth-utils/core" -) - -type metaTracer struct { - tracers []core.TracerResult -} - -func (mt *metaTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) { - for _, tracer := range mt.tracers { - tracer.CaptureStart(core.Address(from), core.Address(to), create, input, gas, value) - } -} -func (mt *metaTracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) { - for _, tracer := range mt.tracers { - tracer.CaptureState(pc, core.OpCode(op), gas, cost, wrappers.NewWrappedScopeContext(scope), rData, depth, err) - } -} -func (mt *metaTracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) { - for _, tracer := range mt.tracers { - tracer.CaptureFault(pc, core.OpCode(op), gas, cost, wrappers.NewWrappedScopeContext(scope), depth, err) - } -} -func (mt *metaTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) { - for _, tracer := range mt.tracers { - tracer.CaptureEnd(output, gasUsed, t, err) - } -} -// TODO: Align these with PluGeth-utils -func (mt *metaTracer) CaptureEnter(vm.OpCode, common.Address, common.Address, []byte, uint64, *big.Int) {} -func (mt *metaTracer) CaptureExit([]byte, uint64, error) {} - -func PluginUpdateBlockchainVMConfig(pl *plugins.PluginLoader, cfg *vm.Config) { - tracerList := plugins.Lookup("LiveTracer", func(item interface{}) bool { - _, ok := item.(core.TracerResult) - log.Info("Item is LiveTracer", "ok", ok, "type", reflect.TypeOf(item)) - return ok - }) - if len(tracerList) > 0 { - mt := &metaTracer{tracers: []core.TracerResult{}} - for _, tracer := range tracerList { - if v, ok := tracer.(core.TracerResult); ok { - log.Info("LiveTracer registered") - mt.tracers = append(mt.tracers, v) - } else { - log.Info("Item is not tracer") - } - } - cfg.Debug = true - cfg.Tracer = mt - } else { - log.Warn("Module is not tracer") - } - -} - -func pluginUpdateBlockchainVMConfig(cfg *vm.Config) { - if plugins.DefaultPluginLoader == nil { - log.Warn("Attempting CreateConsensusEngine, but default PluginLoader has not been initialized") - return - } - PluginUpdateBlockchainVMConfig(plugins.DefaultPluginLoader, cfg) -} diff --git a/plugins/wrappers/backendwrapper/backendwrapper.go b/plugins/wrappers/backendwrapper/backendwrapper.go new file mode 100644 index 000000000..1c89de3fa --- /dev/null +++ b/plugins/wrappers/backendwrapper/backendwrapper.go @@ -0,0 +1,422 @@ +package backendwrapper + +import ( + "context" + "encoding/json" + "fmt" + "math/big" + "reflect" + "sync" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + gcore "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/log" + + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/rpc" + "github.com/openrelayxyz/plugeth-utils/core" + "github.com/openrelayxyz/plugeth-utils/restricted" + "github.com/openrelayxyz/plugeth-utils/restricted/params" +) + +type Backend struct { + b ethapi.Backend + newTxsFeed event.Feed + newTxsOnce sync.Once + chainFeed event.Feed + chainOnce sync.Once + chainHeadFeed event.Feed + chainHeadOnce sync.Once + chainSideFeed event.Feed + chainSideOnce sync.Once + logsFeed event.Feed + logsOnce sync.Once + pendingLogsFeed event.Feed + pendingLogsOnce sync.Once + removedLogsFeed event.Feed + removedLogsOnce sync.Once + chainConfig *params.ChainConfig +} + +func NewBackend(b ethapi.Backend) *Backend { + return &Backend{b: b} +} + +func (b *Backend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) { + return b.b.SuggestGasTipCap(ctx) +} +func (b *Backend) ChainDb() restricted.Database { + return &dbWrapper{b.b.ChainDb()} +} +func (b *Backend) ExtRPCEnabled() bool { + return b.b.ExtRPCEnabled() +} +func (b *Backend) RPCGasCap() uint64 { + return b.b.RPCGasCap() +} +func (b *Backend) RPCTxFeeCap() float64 { + return b.b.RPCTxFeeCap() +} +func (b *Backend) UnprotectedAllowed() bool { + return b.b.UnprotectedAllowed() +} +func (b *Backend) SetHead(number uint64) { + b.b.SetHead(number) +} +func (b *Backend) HeaderByNumber(ctx context.Context, number int64) ([]byte, error) { + header, err := b.b.HeaderByNumber(ctx, rpc.BlockNumber(number)) + if err != nil { + return nil, err + } + return rlp.EncodeToBytes(header) +} +func (b *Backend) HeaderByHash(ctx context.Context, hash core.Hash) ([]byte, error) { + header, err := b.b.HeaderByHash(ctx, common.Hash(hash)) + if err != nil { + return nil, err + } + return rlp.EncodeToBytes(header) +} +func (b *Backend) CurrentHeader() []byte { + ret, _ := rlp.EncodeToBytes(b.b.CurrentHeader()) + return ret +} +func (b *Backend) CurrentBlock() []byte { + ret, _ := rlp.EncodeToBytes(b.b.CurrentBlock()) + return ret +} +func (b *Backend) BlockByNumber(ctx context.Context, number int64) ([]byte, error) { + block, err := b.b.BlockByNumber(ctx, rpc.BlockNumber(number)) + if err != nil { + return nil, err + } + return rlp.EncodeToBytes(block) +} +func (b *Backend) BlockByHash(ctx context.Context, hash core.Hash) ([]byte, error) { + block, err := b.b.BlockByHash(ctx, common.Hash(hash)) + if err != nil { + return nil, err + } + return rlp.EncodeToBytes(block) +} +func (b *Backend) GetReceipts(ctx context.Context, hash core.Hash) ([]byte, error) { + receipts, err := b.b.GetReceipts(ctx, common.Hash(hash)) + if err != nil { + return nil, err + } + return json.Marshal(receipts) +} +func (b *Backend) GetTd(ctx context.Context, hash core.Hash) *big.Int { + return b.b.GetTd(ctx, common.Hash(hash)) +} +func (b *Backend) SendTx(ctx context.Context, signedTx []byte) error { + tx := new(types.Transaction) + if err := tx.UnmarshalBinary(signedTx); err != nil { + return err + } + return b.b.SendTx(ctx, tx) +} +func (b *Backend) GetTransaction(ctx context.Context, txHash core.Hash) ([]byte, core.Hash, uint64, uint64, error) { // RLP Encoded transaction { + tx, blockHash, blockNumber, index, err := b.b.GetTransaction(ctx, common.Hash(txHash)) + if err != nil { + return nil, core.Hash(blockHash), blockNumber, index, err + } + enc, err := tx.MarshalBinary() + return enc, core.Hash(blockHash), blockNumber, index, err +} +func (b *Backend) GetPoolTransactions() ([][]byte, error) { + txs, err := b.b.GetPoolTransactions() + if err != nil { + return nil, err + } + results := make([][]byte, len(txs)) + for i, tx := range txs { + results[i], _ = rlp.EncodeToBytes(tx) + } + return results, nil +} +func (b *Backend) GetPoolTransaction(txHash core.Hash) []byte { + tx := b.b.GetPoolTransaction(common.Hash(txHash)) + if tx == nil { + return []byte{} + } + enc, _ := rlp.EncodeToBytes(tx) + return enc +} +func (b *Backend) GetPoolNonce(ctx context.Context, addr core.Address) (uint64, error) { + return b.b.GetPoolNonce(ctx, common.Address(addr)) +} +func (b *Backend) Stats() (pending int, queued int) { + return b.b.Stats() +} +func (b *Backend) TxPoolContent() (map[core.Address][][]byte, map[core.Address][][]byte) { + pending, queued := b.b.TxPoolContent() + trpending, trqueued := make(map[core.Address][][]byte), make(map[core.Address][][]byte) + for k, v := range pending { + trpending[core.Address(k)] = make([][]byte, len(v)) + for i, tx := range v { + trpending[core.Address(k)][i], _ = tx.MarshalBinary() + } + } + for k, v := range queued { + trqueued[core.Address(k)] = make([][]byte, len(v)) + for i, tx := range v { + trpending[core.Address(k)][i], _ = tx.MarshalBinary() + } + } + return trpending, trqueued +} // RLP encoded transactions +func (b *Backend) BloomStatus() (uint64, uint64) { + return b.b.BloomStatus() +} +func (b *Backend) GetLogs(ctx context.Context, blockHash core.Hash) ([][]byte, error) { + logs, err := b.b.GetLogs(ctx, common.Hash(blockHash)) + if err != nil { + return nil, err + } + encLogs := make([][]byte, len(logs)) + for i, log := range logs { + encLogs[i], _ = rlp.EncodeToBytes(log) + } + return encLogs, nil +} // []RLP encoded logs + +type dli interface { + SyncProgress() ethereum.SyncProgress +} + +type dl struct { + dl dli +} + +type progress struct { + p ethereum.SyncProgress +} + +func (p *progress) StartingBlock() uint64 { + return p.p.StartingBlock +} +func (p *progress) CurrentBlock() uint64 { + return p.p.CurrentBlock +} +func (p *progress) HighestBlock() uint64 { + return p.p.HighestBlock +} +func (p *progress) PulledStates() uint64 { + return p.p.PulledStates +} +func (p *progress) KnownStates() uint64 { + return p.p.KnownStates +} + +func (d *dl) Progress() core.Progress { + return &progress{d.dl.SyncProgress()} +} + +func (b *Backend) Downloader() core.Downloader { + return &dl{b.b} +} + +func (b *Backend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) core.Subscription { + var sub event.Subscription + b.newTxsOnce.Do(func() { + bch := make(chan gcore.NewTxsEvent, 100) + sub = b.b.SubscribeNewTxsEvent(bch) + go func() { + for { + select { + case item := <-bch: + txe := core.NewTxsEvent{ + Txs: make([][]byte, len(item.Txs)), + } + for i, tx := range item.Txs { + txe.Txs[i], _ = tx.MarshalBinary() + } + b.newTxsFeed.Send(txe) + case err := <-sub.Err(): + log.Warn("Subscription error for NewTxs", "err", err) + return + } + } + }() + }) + return b.newTxsFeed.Subscribe(ch) +} +func (b *Backend) SubscribeChainEvent(ch chan<- core.ChainEvent) core.Subscription { + var sub event.Subscription + b.chainOnce.Do(func() { + bch := make(chan gcore.ChainEvent, 100) + sub = b.b.SubscribeChainEvent(bch) + go func() { + for { + select { + case item := <-bch: + ce := core.ChainEvent{ + Hash: core.Hash(item.Hash), + } + ce.Block, _ = rlp.EncodeToBytes(item.Block) + ce.Logs, _ = rlp.EncodeToBytes(item.Logs) + b.chainFeed.Send(ce) + case err := <-sub.Err(): + log.Warn("Subscription error for Chain", "err", err) + return + } + } + }() + }) + return b.chainFeed.Subscribe(ch) +} +func (b *Backend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) core.Subscription { + var sub event.Subscription + b.chainHeadOnce.Do(func() { + bch := make(chan gcore.ChainHeadEvent, 100) + sub = b.b.SubscribeChainHeadEvent(bch) + go func() { + for { + select { + case item := <-bch: + che := core.ChainHeadEvent{} + che.Block, _ = rlp.EncodeToBytes(item.Block) + b.chainHeadFeed.Send(che) + case err := <-sub.Err(): + log.Warn("Subscription error for ChainHead", "err", err) + return + } + } + }() + }) + return b.chainHeadFeed.Subscribe(ch) +} +func (b *Backend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) core.Subscription { + var sub event.Subscription + b.chainSideOnce.Do(func() { + bch := make(chan gcore.ChainSideEvent, 100) + sub = b.b.SubscribeChainSideEvent(bch) + go func() { + for { + select { + case item := <-bch: + cse := core.ChainSideEvent{} + cse.Block, _ = rlp.EncodeToBytes(item.Block) + b.chainSideFeed.Send(cse) + case err := <-sub.Err(): + log.Warn("Subscription error for ChainSide", "err", err) + return + } + } + }() + }) + return b.chainSideFeed.Subscribe(ch) +} +func (b *Backend) SubscribeLogsEvent(ch chan<- [][]byte) core.Subscription { + var sub event.Subscription + b.logsOnce.Do(func() { + bch := make(chan []*types.Log, 100) + sub = b.b.SubscribeLogsEvent(bch) + go func() { + for { + select { + case item := <-bch: + logs := make([][]byte, len(item)) + for i, log := range item { + logs[i], _ = rlp.EncodeToBytes(log) + } + b.logsFeed.Send(logs) + case err := <-sub.Err(): + log.Warn("Subscription error for Logs", "err", err) + return + } + } + }() + }) + return b.logsFeed.Subscribe(ch) +} // []RLP encoded logs +func (b *Backend) SubscribePendingLogsEvent(ch chan<- [][]byte) core.Subscription { + var sub event.Subscription + b.pendingLogsOnce.Do(func() { + bch := make(chan []*types.Log, 100) + sub = b.b.SubscribePendingLogsEvent(bch) + go func() { + for { + select { + case item := <-bch: + logs := make([][]byte, len(item)) + for i, log := range item { + logs[i], _ = rlp.EncodeToBytes(log) + } + b.pendingLogsFeed.Send(logs) + case err := <-sub.Err(): + log.Warn("Subscription error for PendingLogs", "err", err) + return + } + } + }() + }) + return b.pendingLogsFeed.Subscribe(ch) +} // RLP Encoded logs +func (b *Backend) SubscribeRemovedLogsEvent(ch chan<- []byte) core.Subscription { + var sub event.Subscription + b.removedLogsOnce.Do(func() { + bch := make(chan gcore.RemovedLogsEvent, 100) + sub = b.b.SubscribeRemovedLogsEvent(bch) + go func() { + for { + select { + case item := <-bch: + logs := make([][]byte, len(item.Logs)) + for i, log := range item.Logs { + logs[i], _ = rlp.EncodeToBytes(log) + } + b.removedLogsFeed.Send(item) + case err := <-sub.Err(): + log.Warn("Subscription error for RemovedLogs", "err", err) + return + } + } + }() + }) + return b.removedLogsFeed.Subscribe(ch) +} // RLP encoded logs + +func convertAndSet(a, b reflect.Value) (err error) { + defer func() { + if recover() != nil { + fmt.Errorf("error converting: %v", err.Error()) + } + }() + a.Set(b.Convert(a.Type())) + return nil +} + +func (b *Backend) ChainConfig() *params.ChainConfig { + // We're using the reflect library to copy data from params.ChainConfig to + // pparams.ChainConfig, so this function shouldn't need to be touched for + // simple changes to ChainConfig (though pparams.ChainConfig may need to be + // updated). Note that this probably won't carry over consensus engine data. + if b.chainConfig != nil { + return b.chainConfig + } + b.chainConfig = ¶ms.ChainConfig{} + nval := reflect.ValueOf(b.b.ChainConfig()) + ntype := nval.Elem().Type() + lval := reflect.ValueOf(b.chainConfig) + for i := 0; i < nval.Elem().NumField(); i++ { + field := ntype.Field(i) + v := nval.Elem().FieldByName(field.Name) + lv := lval.Elem().FieldByName(field.Name) + log.Info("Checking value for", "field", field.Name) + if lv.Kind() != reflect.Invalid { + // If core.ChainConfig doesn't have this field, skip it. + if v.Type() == lv.Type() && lv.CanSet() { + lv.Set(v) + } else { + convertAndSet(lv, v) + } + } + } + return b.chainConfig +} diff --git a/plugins/wrappers/backendwrapper/dbwrapper.go b/plugins/wrappers/backendwrapper/dbwrapper.go new file mode 100644 index 000000000..a6c8ccb17 --- /dev/null +++ b/plugins/wrappers/backendwrapper/dbwrapper.go @@ -0,0 +1,49 @@ +package backendwrapper + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/ethdb" + "github.com/openrelayxyz/plugeth-utils/restricted" +) + +type dbWrapper struct { + db ethdb.Database +} + +func (d *dbWrapper) Has(key []byte) (bool, error) { return d.db.Has(key) } +func (d *dbWrapper) Get(key []byte) ([]byte, error) { return d.db.Get(key) } +func (d *dbWrapper) Put(key []byte, value []byte) error { return d.db.Put(key, value) } +func (d *dbWrapper) Delete(key []byte) error { return d.db.Delete(key) } +func (d *dbWrapper) Stat(property string) (string, error) { return d.db.Stat(property) } +func (d *dbWrapper) Compact(start []byte, limit []byte) error { return d.db.Compact(start, limit) } +func (d *dbWrapper) HasAncient(kind string, number uint64) (bool, error) { + return d.db.HasAncient(kind, number) +} +func (d *dbWrapper) Ancient(kind string, number uint64) ([]byte, error) { + return d.db.Ancient(kind, number) +} +func (d *dbWrapper) Ancients() (uint64, error) { return d.db.Ancients() } +func (d *dbWrapper) AncientSize(kind string) (uint64, error) { return d.db.AncientSize(kind) } +func (d *dbWrapper) AppendAncient(number uint64, hash, header, body, receipt, td []byte) error { + return fmt.Errorf("AppendAncient is no longer supported in geth 1.10.9 and above. Use ModifyAncients instead.") +} +func (d *dbWrapper) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (int64, error) { + return d.db.ModifyAncients(fn) +} +func (d *dbWrapper) TruncateAncients(n uint64) error { return d.db.TruncateAncients(n) } +func (d *dbWrapper) Sync() error { return d.db.Sync() } +func (d *dbWrapper) Close() error { return d.db.Close() } +func (d *dbWrapper) NewIterator(prefix []byte, start []byte) restricted.Iterator { + return &iterWrapper{d.db.NewIterator(prefix, start)} +} + +type iterWrapper struct { + iter ethdb.Iterator +} + +func (it *iterWrapper) Next() bool { return it.iter.Next() } +func (it *iterWrapper) Error() error { return it.iter.Error() } +func (it *iterWrapper) Key() []byte { return it.iter.Key() } +func (it *iterWrapper) Value() []byte { return it.iter.Value() } +func (it *iterWrapper) Release() { it.iter.Release() }