plugeth/plugins/test-plugin/engine.go
2023-10-02 14:45:41 -05:00

113 lines
3.4 KiB
Go

package main
import(
"errors"
"math/big"
"github.com/openrelayxyz/plugeth-utils/core"
"github.com/openrelayxyz/plugeth-utils/restricted"
"github.com/openrelayxyz/plugeth-utils/restricted/types"
"github.com/openrelayxyz/plugeth-utils/restricted/hasher"
"github.com/openrelayxyz/plugeth-utils/restricted/consensus"
"github.com/openrelayxyz/plugeth-utils/restricted/params"
)
var (
pl core.PluginLoader
backend restricted.Backend
log core.Logger
events core.Feed
)
var httpApiFlagName = "http.api"
func Initialize(ctx core.Context, loader core.PluginLoader, logger core.Logger) {
pl = loader
events = pl.GetFeed()
log = logger
v := ctx.String(httpApiFlagName)
if v != "" {
ctx.Set(httpApiFlagName, v+",plugeth")
} else {
ctx.Set(httpApiFlagName, "eth,net,web3,plugeth")
log.Info("Loaded consensus engine plugin")
}
}
type engine struct {
}
func (e *engine) Author(header *types.Header) (core.Address, error) {
return header.Coinbase, nil
}
func (e *engine) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, seal bool) error {
return nil
}
func (e *engine) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) {
quit := make(chan struct{})
err := make(chan error)
go func () {
for i, h := range headers {
select {
case <-quit:
return
case err<- e.VerifyHeader(chain, h, seals[i]):
}
}
} ()
return quit, err
}
func (e *engine) VerifyUncles(chain consensus.ChainReader, block *types.Block) error {
return nil
}
func (e *engine) Prepare(chain consensus.ChainHeaderReader, header *types.Header) error {
if header.BaseFee == nil {
header.BaseFee = new(big.Int)
}
header.Difficulty = new(big.Int).SetUint64(123456789)
header.UncleHash = core.HexToHash("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")
return nil
}
func (e *engine) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state core.RWStateDB, txs []*types.Transaction,uncles []*types.Header, withdrawals []*types.Withdrawal) {
}
func (e *engine) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state core.RWStateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt, withdrawals []*types.Withdrawal) (*types.Block, error) {
if header.BaseFee == nil {
header.BaseFee = new(big.Int)
}
header.Root = state.IntermediateRoot(false)
hasher := hasher.NewStackTrie(nil)
block := types.NewBlockWithWithdrawals(header, txs, uncles, receipts, withdrawals, hasher)
return block, nil
}
func (e *engine) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
if len(block.Transactions()) == 0 {
return errors.New("sealing paused while waiting for transactions")
}
go func () {
results <- block
close(results)
} ()
// TO DO: the stop channel will need to be addressed in a non test case scenerio
return nil
}
func (e *engine) SealHash(header *types.Header) core.Hash {
return header.Hash()
}
func (e *engine) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
return new(big.Int).SetUint64(uint64(123456789))
}
func (e *engine) APIs(chain consensus.ChainHeaderReader) []core.API {
return []core.API{}
}
func (e *engine) Close() error {
return nil
}
func CreateEngine(chainConfig *params.ChainConfig, db restricted.Database) consensus.Engine {
return &engine{}
}