Execution API Electra: removing bodies v2 logic

CHANGELOG.md

@@ -108,6 +108,7 @@ Updating to this release is recommended at your convenience.
 - Removed gRPC Gateway.
 - Removed unused blobs bundle cache.
 - Removed consolidation signing domain from params. The Electra design changed such that EL handles consolidation signature verification.
+- Remove engine_getPayloadBodiesBy{Hash|Range}V2
 
 ### Fixed
 

beacon-chain/execution/engine_client.go

@@ -44,8 +44,6 @@ var (
 		GetPayloadMethodV4,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
-		GetPayloadBodiesByHashV2,
-		GetPayloadBodiesByRangeV2,
 	}
 )
 
@@ -77,12 +75,8 @@ const (
 	BlockByNumberMethod = "eth_getBlockByNumber"
 	// GetPayloadBodiesByHashV1 is the engine_getPayloadBodiesByHashX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1"
-	// GetPayloadBodiesByHashV2 is the engine_getPayloadBodiesByHashX JSON-RPC method introduced by Electra.
-	GetPayloadBodiesByHashV2 = "engine_getPayloadBodiesByHashV2"
 	// GetPayloadBodiesByRangeV1 is the engine_getPayloadBodiesByRangeX JSON-RPC method for pre-Electra payloads.
 	GetPayloadBodiesByRangeV1 = "engine_getPayloadBodiesByRangeV1"
-	// GetPayloadBodiesByRangeV2 is the engine_getPayloadBodiesByRangeX JSON-RPC method introduced by Electra.
-	GetPayloadBodiesByRangeV2 = "engine_getPayloadBodiesByRangeV2"
 	// ExchangeCapabilities request string for JSON-RPC.
 	ExchangeCapabilities = "engine_exchangeCapabilities"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.

beacon-chain/execution/mock_test.go

@@ -3,7 +3,6 @@ package execution
 import (
 	"context"
 	"encoding/json"
-	"math"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -131,21 +130,10 @@ func TestParseRequest(t *testing.T) {
 				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
 			},
 		},
-		{
-			method: GetPayloadBodiesByHashV2,
-			byteArgs: []hexutil.Bytes{
-				strToHexBytes(t, "0x656d707479000000000000000000000000000000000000000000000000000000"),
-				strToHexBytes(t, "0x66756c6c00000000000000000000000000000000000000000000000000000000"),
-			},
-		},
 		{
 			method:  GetPayloadBodiesByRangeV1,
 			hexArgs: []string{hexutil.EncodeUint64(0), hexutil.EncodeUint64(1)},
 		},
-		{
-			method:  GetPayloadBodiesByRangeV2,
-			hexArgs: []string{hexutil.EncodeUint64(math.MaxUint64), hexutil.EncodeUint64(1)},
-		},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {
@@ -191,20 +179,16 @@ func TestParseRequest(t *testing.T) {
 func TestCallCount(t *testing.T) {
 	methods := []string{
 		GetPayloadBodiesByHashV1,
-		GetPayloadBodiesByHashV2,
 		GetPayloadBodiesByRangeV1,
-		GetPayloadBodiesByRangeV2,
 	}
 	cases := []struct {
 		method string
 		count  int
 	}{
 		{method: GetPayloadBodiesByHashV1, count: 1},
 		{method: GetPayloadBodiesByHashV1, count: 2},
-		{method: GetPayloadBodiesByHashV2, count: 1},
 		{method: GetPayloadBodiesByRangeV1, count: 1},
 		{method: GetPayloadBodiesByRangeV1, count: 2},
-		{method: GetPayloadBodiesByRangeV2, count: 1},
 	}
 	for _, c := range cases {
 		t.Run(c.method, func(t *testing.T) {

beacon-chain/execution/payload_body.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -87,10 +86,7 @@ func (r *blindedBlockReconstructor) addToBatch(b interfaces.ReadOnlySignedBeacon
 	return nil
 }
 
-func payloadBodyMethodForBlock(b interface{ Version() int }) string {
-	if b.Version() > version.Deneb {
-		return GetPayloadBodiesByHashV2
-	}
+func payloadBodyMethodForBlock(_ interface{ Version() int }) string {
 	return GetPayloadBodiesByHashV1
 }
 
@@ -243,9 +239,6 @@ func (r *blindedBlockReconstructor) unblinded() ([]interfaces.SignedBeaconBlock,
 	return unblinded, nil
 }
 
-func rangeMethodForHashMethod(method string) string {
-	if method == GetPayloadBodiesByHashV2 {
-		return GetPayloadBodiesByRangeV2
-	}
+func rangeMethodForHashMethod(_ string) string {
 	return GetPayloadBodiesByRangeV1
 }

beacon-chain/execution/payload_body_test.go

@@ -25,33 +25,6 @@ func (v versioner) Version() int {
 	return v.version
 }
 
-func TestPayloadBodyMethodForBlock(t *testing.T) {
-	cases := []struct {
-		versions []int
-		want     string
-	}{
-		{
-			versions: []int{version.Phase0, version.Altair, version.Bellatrix, version.Capella, version.Deneb},
-			want:     GetPayloadBodiesByHashV1,
-		},
-		{
-			versions: []int{version.Electra},
-			want:     GetPayloadBodiesByHashV2,
-		},
-	}
-	for _, c := range cases {
-		for _, v := range c.versions {
-			t.Run(version.String(v), func(t *testing.T) {
-				v := versioner{version: v}
-				require.Equal(t, c.want, payloadBodyMethodForBlock(v))
-			})
-		}
-	}
-	t.Run("post-electra", func(t *testing.T) {
-		require.Equal(t, GetPayloadBodiesByHashV2, payloadBodyMethodForBlock(versioner{version: version.Electra + 1}))
-	})
-}
-
 func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPayloadBody {
 	body := &pb.ExecutionPayloadBody{}
 	txs, err := ed.Transactions()
@@ -347,22 +320,6 @@ func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
 			}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
-		// separate methods for the electra block
-		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{nil}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
-		srv.register(GetPayloadBodiesByRangeV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			p := mockParseUintList(t, msg.Params)
-			require.Equal(t, 2, len(p))
-			start, count := p[0], p[1]
-			require.Equal(t, fx.electra.blinded.header.BlockNumber(), start)
-			require.Equal(t, uint64(1), count)
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{
-				payloadToBody(t, fx.electra.blinded.header),
-			}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
 		blind := []interfaces.ReadOnlySignedBeaconBlock{
 			fx.denebBlock.blinded.block,
 			fx.emptyDenebBlock.blinded.block,
@@ -381,13 +338,8 @@ func TestReconstructBlindedBlockBatchDenebAndElectra(t *testing.T) {
 	t.Run("deneb and electra", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
 		fx := testBlindedBlockFixtures(t)
-		// The reconstructed should make separate calls for the deneb (v1) and electra (v2) blocks.
 		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header)}
-			mockWriteResult(t, w, msg, executionPayloadBodies)
-		})
-		srv.register(GetPayloadBodiesByHashV2, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.electra.blinded.header)}
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header), payloadToBody(t, fx.electra.blinded.header)}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
 		blinded := []interfaces.ReadOnlySignedBeaconBlock{