merge upstream changes

Author: avalonche

builder/builder.go

@@ -3,10 +3,14 @@ package builder
 import (
 	"context"
 	"errors"
+	"math/big"
 	_ "os"
 	"sync"
 	"time"
 
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	"github.com/attestantio/go-eth2-client/spec/capella"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/ethereum/go-ethereum/common"
 	blockvalidation "github.com/ethereum/go-ethereum/eth/block-validation"
 	"github.com/holiman/uint256"
@@ -20,9 +24,7 @@ import (
 
 	capellaapi "github.com/attestantio/go-builder-client/api/capella"
 	apiv1 "github.com/attestantio/go-builder-client/api/v1"
-	"github.com/attestantio/go-eth2-client/spec/bellatrix"
-	"github.com/attestantio/go-eth2-client/spec/capella"
-	"github.com/attestantio/go-eth2-client/spec/phase0"
+
 	"github.com/flashbots/go-boost-utils/bls"
 	boostTypes "github.com/flashbots/go-boost-utils/types"
 )
@@ -106,34 +108,34 @@ func (b *Builder) Stop() error {
 	return nil
 }
 
-func (b *Builder) onSealedBlock(block *types.Block, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+func (b *Builder) onSealedBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
 	if b.eth.Config().IsShanghai(block.Time()) {
-		if err := b.submitCapellaBlock(block, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
+		if err := b.submitCapellaBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
 			return err
 		}
 	} else {
-		if err := b.submitBellatrixBlock(block, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
+		if err := b.submitBellatrixBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
 			return err
 		}
 	}
 
-	log.Info("submitted block", "slot", attrs.Slot, "value", block.Profit.String(), "parent", block.ParentHash, "hash", block.Hash(), "#commitedBundles", len(commitedBundles))
+	log.Info("submitted block", "slot", attrs.Slot, "value", blockValue.String(), "parent", block.ParentHash, "hash", block.Hash(), "#commitedBundles", len(commitedBundles))
 
 	return nil
 }
 
-func (b *Builder) submitBellatrixBlock(block *types.Block, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
-	value := new(boostTypes.U256Str)
-	err := value.FromBig(block.Profit)
+func (b *Builder) submitBellatrixBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+	executableData := engine.BlockToExecutableData(block, blockValue)
+	payload, err := executableDataToExecutionPayload(executableData.ExecutionPayload)
 	if err != nil {
-		log.Error("could not set block value", "err", err)
+		log.Error("could not format execution payload", "err", err)
 		return err
 	}
 
-	executableData := engine.BlockToExecutableData(block, block.Profit)
-	payload, err := executableDataToExecutionPayload(executableData.ExecutionPayload)
+	value := new(boostTypes.U256Str)
+	err = value.FromBig(blockValue)
 	if err != nil {
-		log.Error("could not format execution payload", "err", err)
+		log.Error("could not set block value", "err", err)
 		return err
 	}
 
@@ -167,26 +169,29 @@ func (b *Builder) submitBellatrixBlock(block *types.Block, ordersClosedAt time.T
 			log.Error("could not validate block", "err", err)
 		}
 	} else {
-		go b.ds.ConsumeBuiltBlock(block, ordersClosedAt, sealedAt, commitedBundles, allBundles, &blockBidMsg)
+		go b.ds.ConsumeBuiltBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, &blockBidMsg)
 		err = b.relay.SubmitBlock(&blockSubmitReq, vd)
 		if err != nil {
 			log.Error("could not submit block", "err", err, "#commitedBundles", len(commitedBundles))
 			return err
 		}
 	}
+
+	log.Info("submitted block", "slot", blockBidMsg.Slot, "value", blockBidMsg.Value.String(), "parent", blockBidMsg.ParentHash, "hash", block.Hash(), "#commitedBundles", len(commitedBundles))
+
 	return nil
 }
 
-func (b *Builder) submitCapellaBlock(block *types.Block, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
-	executableData := engine.BlockToExecutableData(block, block.Profit)
+func (b *Builder) submitCapellaBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+	executableData := engine.BlockToExecutableData(block, blockValue)
 	payload, err := executableDataToCapellaExecutionPayload(executableData.ExecutionPayload)
 	if err != nil {
 		log.Error("could not format execution payload", "err", err)
 		return err
 	}
 
 	value := new(boostTypes.U256Str)
-	err = value.FromBig(block.Profit)
+	err = value.FromBig(blockValue)
 	if err != nil {
 		log.Error("could not set block value", "err", err)
 		return err
@@ -218,13 +223,12 @@ func (b *Builder) submitCapellaBlock(block *types.Block, ordersClosedAt time.Tim
 		ExecutionPayload: payload,
 	}
 
-	go b.ds.ConsumeBuiltBlock(block, ordersClosedAt, sealedAt, commitedBundles, allBundles, &boostBidTrace)
+	go b.ds.ConsumeBuiltBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, &boostBidTrace)
 	err = b.relay.SubmitBlockCapella(&blockSubmitReq, vd)
 	if err != nil {
 		log.Error("could not submit block", "err", err, "#commitedBundles", len(commitedBundles))
 		return err
 	}
-
 	return nil
 }
 
@@ -274,10 +278,7 @@ func (b *Builder) OnPayloadAttribute(attrs *types.BuilderPayloadAttributes) erro
 	}
 
 	for _, currentAttrs := range b.slotAttrs {
-		seen := attrs.HeadHash == currentAttrs.HeadHash && attrs.Slot == currentAttrs.Slot &&
-			attrs.GasLimit == currentAttrs.GasLimit && attrs.SuggestedFeeRecipient == currentAttrs.SuggestedFeeRecipient
-
-		if seen {
+		if attrs.Equal(&currentAttrs) {
 			log.Debug("ignoring known payload attribute", "slot", attrs.Slot, "hash", attrs.HeadHash)
 			return nil
 		}
@@ -290,6 +291,7 @@ func (b *Builder) OnPayloadAttribute(attrs *types.BuilderPayloadAttributes) erro
 
 type blockQueueEntry struct {
 	block           *types.Block
+	blockValue      *big.Int
 	ordersCloseTime time.Time
 	sealedAt        time.Time
 	commitedBundles []types.SimulatedBundle
@@ -320,7 +322,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 	submitBestBlock := func() {
 		queueMu.Lock()
 		if queueBestEntry.block.Hash() != queueLastSubmittedHash {
-			err := b.onSealedBlock(queueBestEntry.block, queueBestEntry.ordersCloseTime, queueBestEntry.sealedAt, queueBestEntry.commitedBundles, queueBestEntry.allBundles, proposerPubkey, vd, attrs)
+			err := b.onSealedBlock(queueBestEntry.block, queueBestEntry.blockValue, queueBestEntry.ordersCloseTime, queueBestEntry.sealedAt, queueBestEntry.commitedBundles, queueBestEntry.allBundles, proposerPubkey, vd, attrs)
 
 			if err != nil {
 				log.Error("could not run sealed block hook", "err", err)
@@ -335,7 +337,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 	go runResubmitLoop(ctx, b.limiter, queueSignal, submitBestBlock)
 
 	// Populates queue with submissions that increase block profit
-	blockHook := func(block *types.Block, ordersCloseTime time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle) {
+	blockHook := func(block *types.Block, blockValue *big.Int, ordersCloseTime time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle) {
 		if ctx.Err() != nil {
 			return
 		}
@@ -347,6 +349,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 		if block.Hash() != queueLastSubmittedHash {
 			queueBestEntry = blockQueueEntry{
 				block:           block,
+				blockValue:      new(big.Int).Set(blockValue),
 				ordersCloseTime: ordersCloseTime,
 				sealedAt:        sealedAt,
 				commitedBundles: commitedBundles,

builder/builder_test.go

@@ -62,7 +62,6 @@ func TestOnPayloadAttributes(t *testing.T) {
 
 	testBlock, err := engine.ExecutableDataToBlock(*testExecutableData)
 	require.NoError(t, err)
-	testBlock.Profit = big.NewInt(10)
 
 	testPayloadAttributes := &types.BuilderPayloadAttributes{
 		Timestamp:             hexutil.Uint64(104),
@@ -72,7 +71,7 @@ func TestOnPayloadAttributes(t *testing.T) {
 		Slot:                  uint64(25),
 	}
 
-	testEthService := &testEthereumService{synced: true, testExecutableData: testExecutableData, testBlock: testBlock}
+	testEthService := &testEthereumService{synced: true, testExecutableData: testExecutableData, testBlock: testBlock, testBlockValue: big.NewInt(10)}
 
 	builder := NewBuilder(sk, flashbotsextra.NilDbService{}, &testRelay, bDomain, testEthService, false, nil)
 	builder.Start()
@@ -127,7 +126,8 @@ func TestOnPayloadAttributes(t *testing.T) {
 	require.Equal(t, uint64(25), testRelay.requestedSlot)
 
 	// Clear the submitted message and check that the job will be ran again and but a new message will not be submitted since the hash is the same
-	testBlock.Profit = big.NewInt(10)
+	testEthService.testBlockValue = big.NewInt(10)
+
 	testRelay.submittedMsg = nil
 	time.Sleep(2200 * time.Millisecond)
 	require.Nil(t, testRelay.submittedMsg)
@@ -136,7 +136,7 @@ func TestOnPayloadAttributes(t *testing.T) {
 	testExecutableData.ExtraData = hexutil.MustDecode("0x0042fafd")
 	testExecutableData.BlockHash = common.HexToHash("0x0579b1aaca5c079c91e5774bac72c7f9bc2ddf2b126e9c632be68a1cb8f3fc71")
 	testBlock, err = engine.ExecutableDataToBlock(*testExecutableData)
-	testBlock.Profit = big.NewInt(10)
+	testEthService.testBlockValue = big.NewInt(10)
 	require.NoError(t, err)
 	testEthService.testBlock = testBlock
 

builder/eth_service.go

@@ -2,6 +2,7 @@ package builder
 
 import (
 	"errors"
+	"math/big"
 	"time"
 
 	"github.com/ethereum/go-ethereum/beacon/engine"
@@ -24,21 +25,22 @@ type testEthereumService struct {
 	synced             bool
 	testExecutableData *engine.ExecutableData
 	testBlock          *types.Block
+	testBlockValue     *big.Int
 	testBundlesMerged  []types.SimulatedBundle
 	testAllBundles     []types.SimulatedBundle
 }
 
 func (t *testEthereumService) BuildBlock(attrs *types.BuilderPayloadAttributes, sealedBlockCallback miner.BlockHookFn) error {
-	sealedBlockCallback(t.testBlock, time.Now(), t.testBundlesMerged, t.testAllBundles)
+	sealedBlockCallback(t.testBlock, t.testBlockValue, time.Now(), t.testBundlesMerged, t.testAllBundles)
 	return nil
 }
 
 func (t *testEthereumService) GetBlockByHash(hash common.Hash) *types.Block { return t.testBlock }
 
-func (t *testEthereumService) Synced() bool { return t.synced }
-
 func (t *testEthereumService) Config() *params.ChainConfig { return params.TestChainConfig }
 
+func (t *testEthereumService) Synced() bool { return t.synced }
+
 type EthereumService struct {
 	eth *eth.Ethereum
 }
@@ -47,45 +49,56 @@ func NewEthereumService(eth *eth.Ethereum) *EthereumService {
 	return &EthereumService{eth: eth}
 }
 
+// TODO: we should move to a setup similar to catalyst local blocks & payload ids
 func (s *EthereumService) BuildBlock(attrs *types.BuilderPayloadAttributes, sealedBlockCallback miner.BlockHookFn) error {
 	// Send a request to generate a full block in the background.
 	// The result can be obtained via the returned channel.
 	args := &miner.BuildPayloadArgs{
 		Parent:       attrs.HeadHash,
 		Timestamp:    uint64(attrs.Timestamp),
 		FeeRecipient: attrs.SuggestedFeeRecipient,
+		GasLimit:     attrs.GasLimit,
 		Random:       attrs.Random,
 		Withdrawals:  attrs.Withdrawals,
+		BlockHook:    sealedBlockCallback,
 	}
-	resCh, err := s.eth.Miner().GetSealingBlock(args, false, sealedBlockCallback)
+
+	payload, err := s.eth.Miner().BuildPayload(args)
 	if err != nil {
-		log.Error("Failed to create async sealing payload", "err", err)
+		log.Error("Failed to build payload", "err", err)
 		return err
 	}
 
+	resCh := make(chan *engine.ExecutionPayloadEnvelope, 1)
+	go func() {
+		resCh <- payload.ResolveFull()
+	}()
+
 	timer := time.NewTimer(4 * time.Second)
 	defer timer.Stop()
 
 	select {
-	case block := <-resCh:
-		if block == nil {
-			return errors.New("received nil block from sealing work")
+	case payload := <-resCh:
+		if payload == nil {
+			return errors.New("received nil payload from sealing work")
 		}
 		return nil
 	case <-timer.C:
+		payload.Cancel()
 		log.Error("timeout waiting for block", "parent hash", attrs.HeadHash, "slot", attrs.Slot)
 		return errors.New("timeout waiting for block result")
 	}
+
 }
 
 func (s *EthereumService) GetBlockByHash(hash common.Hash) *types.Block {
 	return s.eth.BlockChain().GetBlockByHash(hash)
 }
 
-func (s *EthereumService) Synced() bool {
-	return s.eth.Synced()
-}
-
 func (s *EthereumService) Config() *params.ChainConfig {
 	return s.eth.BlockChain().Config()
 }
+
+func (s *EthereumService) Synced() bool {
+	return s.eth.Synced()
+}

builder/eth_service_test.go

@@ -93,16 +93,15 @@ func TestBuildBlock(t *testing.T) {
 	service := NewEthereumService(ethservice)
 	service.eth.APIBackend.Miner().SetEtherbase(common.Address{0x05, 0x11})
 
-	err := service.BuildBlock(testPayloadAttributes, func(block *types.Block, _ time.Time, _ []types.SimulatedBundle, _ []types.SimulatedBundle) {
-		executableData := engine.BlockToExecutableData(block, block.Profit)
-		executionPayload := executableData.ExecutionPayload
-		require.Equal(t, common.Address{0x05, 0x11}, executionPayload.FeeRecipient)
-		require.Equal(t, common.Hash{0x05, 0x10}, executionPayload.Random)
-		require.Equal(t, parent.Hash(), executionPayload.ParentHash)
-		require.Equal(t, parent.Time()+1, executionPayload.Timestamp)
+	err := service.BuildBlock(testPayloadAttributes, func(block *types.Block, blockValue *big.Int, _ time.Time, _ []types.SimulatedBundle, _ []types.SimulatedBundle) {
+		executableData := engine.BlockToExecutableData(block, blockValue)
+		require.Equal(t, common.Address{0x05, 0x11}, executableData.ExecutionPayload.FeeRecipient)
+		require.Equal(t, common.Hash{0x05, 0x10}, executableData.ExecutionPayload.Random)
+		require.Equal(t, parent.Hash(), executableData.ExecutionPayload.ParentHash)
+		require.Equal(t, parent.Time()+1, executableData.ExecutionPayload.Timestamp)
 		require.Equal(t, block.ParentHash(), parent.Hash())
-		require.Equal(t, block.Hash(), executionPayload.BlockHash)
-		require.Equal(t, block.Profit.Uint64(), uint64(0))
+		require.Equal(t, block.Hash(), executableData.ExecutionPayload.BlockHash)
+		require.Equal(t, blockValue.Uint64(), uint64(0))
 	})
 
 	require.NoError(t, err)

builder/local_relay_test.go

@@ -23,15 +23,15 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func newTestBackend(t *testing.T, forkchoiceData *engine.ExecutableData, block *types.Block) (*Builder, *LocalRelay, *ValidatorPrivateData) {
+func newTestBackend(t *testing.T, forkchoiceData *engine.ExecutableData, block *types.Block, blockValue *big.Int) (*Builder, *LocalRelay, *ValidatorPrivateData) {
 	validator := NewRandomValidator()
 	sk, _ := bls.GenerateRandomSecretKey()
 	bDomain := boostTypes.ComputeDomain(boostTypes.DomainTypeAppBuilder, [4]byte{0x02, 0x0, 0x0, 0x0}, boostTypes.Hash{})
 	genesisValidatorsRoot := boostTypes.Hash(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"))
 	cDomain := boostTypes.ComputeDomain(boostTypes.DomainTypeBeaconProposer, [4]byte{0x02, 0x0, 0x0, 0x0}, genesisValidatorsRoot)
 	beaconClient := &testBeaconClient{validator: validator}
 	localRelay := NewLocalRelay(sk, beaconClient, bDomain, cDomain, ForkData{}, true)
-	ethService := &testEthereumService{synced: true, testExecutableData: forkchoiceData, testBlock: block}
+	ethService := &testEthereumService{synced: true, testExecutableData: forkchoiceData, testBlock: block, testBlockValue: blockValue}
 	backend := NewBuilder(sk, flashbotsextra.NilDbService{}, localRelay, bDomain, ethService, false, nil)
 	// service := NewService("127.0.0.1:31545", backend)
 
@@ -59,7 +59,7 @@ func testRequest(t *testing.T, localRelay *LocalRelay, method string, path strin
 }
 
 func TestValidatorRegistration(t *testing.T) {
-	_, relay, _ := newTestBackend(t, nil, nil)
+	_, relay, _ := newTestBackend(t, nil, nil, nil)
 	log.Error("rsk", "sk", hexutil.Encode(relay.relaySecretKey.Serialize()))
 
 	v := NewRandomValidator()
@@ -128,9 +128,9 @@ func TestGetHeader(t *testing.T) {
 
 	forkchoiceBlock, err := engine.ExecutableDataToBlock(*forkchoiceData)
 	require.NoError(t, err)
-	forkchoiceBlock.Profit = big.NewInt(10)
+	forkchoiceBlockProfit := big.NewInt(10)
 
-	backend, relay, validator := newTestBackend(t, forkchoiceData, forkchoiceBlock)
+	backend, relay, validator := newTestBackend(t, forkchoiceData, forkchoiceBlock, forkchoiceBlockProfit)
 
 	path := fmt.Sprintf("/eth/v1/builder/header/%d/%s/%s", 0, forkchoiceData.ParentHash.Hex(), validator.Pk.String())
 	rr := testRequest(t, relay, "GET", path, nil)
@@ -162,7 +162,7 @@ func TestGetHeader(t *testing.T) {
 	expectedHeader, err := boostTypes.PayloadToPayloadHeader(executionPayload)
 	require.NoError(t, err)
 	expectedValue := new(boostTypes.U256Str)
-	err = expectedValue.FromBig(forkchoiceBlock.Profit)
+	err = expectedValue.FromBig(forkchoiceBlockProfit)
 	require.NoError(t, err)
 	require.EqualValues(t, &boostTypes.BuilderBid{
 		Header: expectedHeader,
@@ -189,9 +189,9 @@ func TestGetPayload(t *testing.T) {
 
 	forkchoiceBlock, err := engine.ExecutableDataToBlock(*forkchoiceData)
 	require.NoError(t, err)
-	forkchoiceBlock.Profit = big.NewInt(10)
+	forkchoiceBlockProfit := big.NewInt(10)
 
-	backend, relay, validator := newTestBackend(t, forkchoiceData, forkchoiceBlock)
+	backend, relay, validator := newTestBackend(t, forkchoiceData, forkchoiceBlock, forkchoiceBlockProfit)
 
 	registerValidator(t, validator, relay)
 	backend.OnPayloadAttribute(&types.BuilderPayloadAttributes{})

cmd/geth/main.go

@@ -130,6 +130,8 @@ var (
 		utils.MinerExtraDataFlag,
 		utils.MinerRecommitIntervalFlag,
 		utils.MinerNoVerifyFlag,
+		utils.MinerMaxMergedBundlesFlag,
+		utils.MinerBlocklistFileFlag,
 		utils.MinerNewPayloadTimeout,
 		utils.NATFlag,
 		utils.NoDiscoverFlag,