miner: catalyst: return transaction fees for block

Author: MariusVanDerWijden

core/beacon/types.go

@@ -75,6 +75,11 @@ type executableDataMarshaling struct {
 	Transactions  []hexutil.Bytes
 }
 
+type ExecutableDataV2 struct {
+	ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
+	BlockValue       *big.Int        `json:"blockValue"  gencodec:"required"`
+}
+
 type PayloadStatusV1 struct {
 	Status          string       `json:"status"`
 	LatestValidHash *common.Hash `json:"latestValidHash"`
@@ -197,8 +202,8 @@ func ExecutableDataToBlock(params ExecutableData) (*types.Block, error) {
 
 // BlockToExecutableData constructs the ExecutableData structure by filling the
 // fields from the given block. It assumes the given block is post-merge block.
-func BlockToExecutableData(block *types.Block) *ExecutableData {
-	return &ExecutableData{
+func BlockToExecutableData(block *types.Block, fees *big.Int) *ExecutableDataV2 {
+	data := &ExecutableData{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
 		FeeRecipient:  block.Coinbase(),
@@ -215,4 +220,5 @@ func BlockToExecutableData(block *types.Block) *ExecutableData {
 		ExtraData:     block.Extra(),
 		Withdrawals:   block.Withdrawals(),
 	}
+	return &ExecutableDataV2{ExecutionPayload: data, BlockValue: fees}
 }

eth/catalyst/api.go

@@ -352,11 +352,11 @@ func (api *ConsensusAPI) GetPayloadV1(payloadID beacon.PayloadID) (*beacon.Execu
 	if err != nil {
 		return nil, err
 	}
-	return data, nil
+	return data.ExecutionPayload, nil
 }
 
 // GetPayloadV2 returns a cached payload by id.
-func (api *ConsensusAPI) GetPayloadV2(payloadID beacon.PayloadID) (*beacon.ExecutableData, error) {
+func (api *ConsensusAPI) GetPayloadV2(payloadID beacon.PayloadID) (*beacon.ExecutableDataV2, error) {
 	log.Trace("Engine API request received", "method", "GetPayload", "id", payloadID)
 	data := api.localBlocks.get(payloadID)
 	if data == nil {

eth/catalyst/api_test.go

@@ -657,7 +657,7 @@ func assembleBlock(api *ConsensusAPI, parentHash common.Hash, params *beacon.Pay
 	if err != nil {
 		return nil, err
 	}
-	return payload.ResolveFull(), nil
+	return payload.ResolveFull().ExecutionPayload, nil
 }
 
 func TestEmptyBlocks(t *testing.T) {
@@ -899,7 +899,7 @@ func TestNewPayloadOnInvalidTerminalBlock(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error preparing payload, err=%v", err)
 	}
-	data := *payload.Resolve()
+	data := *payload.Resolve().ExecutionPayload
 	resp2, err := api.NewPayloadV1(data)
 	if err != nil {
 		t.Fatalf("error sending NewPayload, err=%v", err)
@@ -1039,12 +1039,12 @@ func TestWithdrawals(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error getting payload, err=%v", err)
 	}
-	if execData.StateRoot != parent.Root {
-		t.Fatalf("mismatch state roots (got: %s, want: %s)", execData.StateRoot, blocks[8].Root())
+	if execData.ExecutionPayload.StateRoot != parent.Root {
+		t.Fatalf("mismatch state roots (got: %s, want: %s)", execData.ExecutionPayload.StateRoot, blocks[8].Root())
 	}
 
 	// 10: verify locally built block
-	if status, err := api.NewPayloadV2(*execData); err != nil {
+	if status, err := api.NewPayloadV2(*execData.ExecutionPayload); err != nil {
 		t.Fatalf("error validating payload: %v", err)
 	} else if status.Status != beacon.VALID {
 		t.Fatalf("invalid payload")
@@ -1054,7 +1054,7 @@ func TestWithdrawals(t *testing.T) {
 	aa := common.Address{0xaa}
 	bb := common.Address{0xbb}
 	params = beacon.PayloadAttributes{
-		Timestamp: execData.Timestamp + 5,
+		Timestamp: execData.ExecutionPayload.Timestamp + 5,
 		Withdrawals: []*types.Withdrawal{
 			{
 				Index:   0,
@@ -1068,7 +1068,7 @@ func TestWithdrawals(t *testing.T) {
 			},
 		},
 	}
-	fcState.HeadBlockHash = execData.BlockHash
+	fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash
 	_, err = api.ForkchoiceUpdatedV2(fcState, &params)
 	if err != nil {
 		t.Fatalf("error preparing payload, err=%v", err)
@@ -1085,21 +1085,21 @@ func TestWithdrawals(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error getting payload, err=%v", err)
 	}
-	if status, err := api.NewPayloadV2(*execData); err != nil {
+	if status, err := api.NewPayloadV2(*execData.ExecutionPayload); err != nil {
 		t.Fatalf("error validating payload: %v", err)
 	} else if status.Status != beacon.VALID {
 		t.Fatalf("invalid payload")
 	}
 
 	// 11: set block as head.
-	fcState.HeadBlockHash = execData.BlockHash
+	fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash
 	_, err = api.ForkchoiceUpdatedV2(fcState, nil)
 	if err != nil {
 		t.Fatalf("error preparing payload, err=%v", err)
 	}
 
 	// 11: verify withdrawals were processed.
-	db, _, err := ethservice.APIBackend.StateAndHeaderByNumber(context.Background(), rpc.BlockNumber(execData.Number))
+	db, _, err := ethservice.APIBackend.StateAndHeaderByNumber(context.Background(), rpc.BlockNumber(execData.ExecutionPayload.Number))
 	if err != nil {
 		t.Fatalf("unable to load db: %v", err)
 	}

eth/catalyst/queue.go

@@ -70,7 +70,7 @@ func (q *payloadQueue) put(id beacon.PayloadID, payload *miner.Payload) {
 }
 
 // get retrieves a previously stored payload item or nil if it does not exist.
-func (q *payloadQueue) get(id beacon.PayloadID) *beacon.ExecutableData {
+func (q *payloadQueue) get(id beacon.PayloadID) *beacon.ExecutableDataV2 {
 	q.lock.RLock()
 	defer q.lock.RUnlock()
 

eth/catalyst/tester.go

@@ -17,6 +17,7 @@
 package catalyst
 
 import (
+	"math/big"
 	"sync"
 	"time"
 
@@ -76,8 +77,8 @@ func (tester *FullSyncTester) Start() error {
 					return
 				}
 				// Shoot out consensus events in order to trigger syncing.
-				data := beacon.BlockToExecutableData(tester.block)
-				tester.api.NewPayloadV1(*data)
+				data := beacon.BlockToExecutableData(tester.block, big.NewInt(0))
+				tester.api.NewPayloadV1(*data.ExecutionPayload)
 				tester.api.ForkchoiceUpdatedV1(beacon.ForkchoiceStateV1{
 					HeadBlockHash:      tester.block.Hash(),
 					SafeBlockHash:      tester.block.Hash(),

miner/payload_building.go

@@ -108,7 +108,7 @@ func (payload *Payload) update(block *types.Block, fees *big.Int, elapsed time.D
 
 // Resolve returns the latest built payload and also terminates the background
 // thread for updating payload. It's safe to be called multiple times.
-func (payload *Payload) Resolve() *beacon.ExecutableData {
+func (payload *Payload) Resolve() *beacon.ExecutableDataV2 {
 	payload.lock.Lock()
 	defer payload.lock.Unlock()
 
@@ -118,23 +118,23 @@ func (payload *Payload) Resolve() *beacon.ExecutableData {
 		close(payload.stop)
 	}
 	if payload.full != nil {
-		return beacon.BlockToExecutableData(payload.full)
+		return beacon.BlockToExecutableData(payload.full, payload.fullFees)
 	}
-	return beacon.BlockToExecutableData(payload.empty)
+	return beacon.BlockToExecutableData(payload.empty, big.NewInt(0))
 }
 
 // ResolveEmpty is basically identical to Resolve, but it expects empty block only.
 // It's only used in tests.
-func (payload *Payload) ResolveEmpty() *beacon.ExecutableData {
+func (payload *Payload) ResolveEmpty() *beacon.ExecutableDataV2 {
 	payload.lock.Lock()
 	defer payload.lock.Unlock()
 
-	return beacon.BlockToExecutableData(payload.empty)
+	return beacon.BlockToExecutableData(payload.empty, big.NewInt(0))
 }
 
 // ResolveFull is basically identical to Resolve, but it expects full block only.
 // It's only used in tests.
-func (payload *Payload) ResolveFull() *beacon.ExecutableData {
+func (payload *Payload) ResolveFull() *beacon.ExecutableDataV2 {
 	payload.lock.Lock()
 	defer payload.lock.Unlock()
 
@@ -146,7 +146,7 @@ func (payload *Payload) ResolveFull() *beacon.ExecutableData {
 		}
 		payload.cond.Wait()
 	}
-	return beacon.BlockToExecutableData(payload.full)
+	return beacon.BlockToExecutableData(payload.full, payload.fullFees)
 }
 
 // buildPayload builds the payload according to the provided parameters.

miner/payload_building_test.go

@@ -47,20 +47,21 @@ func TestBuildPayload(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to build payload %v", err)
 	}
-	verify := func(data *beacon.ExecutableData, txs int) {
-		if data.ParentHash != b.chain.CurrentBlock().Hash() {
+	verify := func(outer *beacon.ExecutableDataV2, txs int) {
+		payload := outer.ExecutionPayload
+		if payload.ParentHash != b.chain.CurrentBlock().Hash() {
 			t.Fatal("Unexpect parent hash")
 		}
-		if data.Random != (common.Hash{}) {
+		if payload.Random != (common.Hash{}) {
 			t.Fatal("Unexpect random value")
 		}
-		if data.Timestamp != timestamp {
+		if payload.Timestamp != timestamp {
 			t.Fatal("Unexpect timestamp")
 		}
-		if data.FeeRecipient != recipient {
+		if payload.FeeRecipient != recipient {
 			t.Fatal("Unexpect fee recipient")
 		}
-		if len(data.Transactions) != txs {
+		if len(payload.Transactions) != txs {
 			t.Fatal("Unexpect transaction set")
 		}
 	}