useful

api/server/structs/block.go

@@ -578,6 +578,12 @@ type SignedBeaconBlockContentsFulu struct {
 	Blobs       []string               `json:"blobs"`
 }
 
+type BeaconBlockContentsFulu struct {
+	Block     *BeaconBlockElectra `json:"block"`
+	KzgProofs []string            `json:"kzg_proofs"`
+	Blobs     []string            `json:"blobs"`
+}
+
 type SignedBeaconBlockFulu struct {
 	Message   *BeaconBlockElectra `json:"message"`
 	Signature string              `json:"signature"`

api/server/structs/conversions_block.go

@@ -265,6 +265,8 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockElectraFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockElectra:
 		return SignedBeaconBlockElectraFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockFulu:
+		return SignedBlindedBeaconBlockFuluFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockFulu:
 		return SignedBeaconBlockFuluFromConsensus(pbStruct)
 	default:
@@ -3119,6 +3121,36 @@ func (b *BlindedBeaconBlockElectra) ToConsensus() (*eth.BlindedBeaconBlockElectr
 	}, nil
 }
 
+func (b *BeaconBlockContentsFulu) ToConsensus() (*eth.BeaconBlockContentsFulu, error) {
+	if b == nil {
+		return nil, errNilValue
+	}
+
+	electraBlock, err := b.Block.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Block")
+	}
+	proofs := make([][]byte, len(b.KzgProofs))
+	for i, proof := range b.KzgProofs {
+		proofs[i], err = bytesutil.DecodeHexWithLength(proof, fieldparams.BLSPubkeyLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("KzgProofs[%d]", i))
+		}
+	}
+	blbs := make([][]byte, len(b.Blobs))
+	for i, blob := range b.Blobs {
+		blbs[i], err = bytesutil.DecodeHexWithLength(blob, fieldparams.BlobLength)
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Blobs[%d]", i))
+		}
+	}
+	return &eth.BeaconBlockContentsFulu{
+		Block:     electraBlock,
+		KzgProofs: proofs,
+		Blobs:     blbs,
+	}, nil
+}
+
 func (b *BlindedBeaconBlockElectra) ToGeneric() (*eth.GenericBeaconBlock, error) {
 	if b == nil {
 		return nil, errNilValue
@@ -3560,6 +3592,18 @@ func (b *BlindedBeaconBlockFulu) ToConsensus() (*eth.BlindedBeaconBlockFulu, err
 	}, nil
 }
 
+func (b *BlindedBeaconBlockFulu) ToGeneric() (*eth.GenericBeaconBlock, error) {
+	if b == nil {
+		return nil, errNilValue
+	}
+
+	blindedBlock, err := b.ToConsensus()
+	if err != nil {
+		return nil, err
+	}
+	return &eth.GenericBeaconBlock{Block: &eth.GenericBeaconBlock_BlindedFulu{BlindedFulu: blindedBlock}, IsBlinded: true}, nil
+}
+
 func (b *SignedBeaconBlockContentsFulu) ToGeneric() (*eth.GenericSignedBeaconBlock, error) {
 	if b == nil {
 		return nil, errNilValue
@@ -3628,6 +3672,15 @@ func (b *SignedBeaconBlockFulu) ToConsensus() (*eth.SignedBeaconBlockFulu, error
 	}, nil
 }
 
+func (b *BeaconBlockContentsFulu) ToGeneric() (*eth.GenericBeaconBlock, error) {
+	block, err := b.ToConsensus()
+	if err != nil {
+		return nil, err
+	}
+
+	return &eth.GenericBeaconBlock{Block: &eth.GenericBeaconBlock_Fulu{Fulu: block}}, nil
+}
+
 func SignedBeaconBlockFuluFromConsensus(b *eth.SignedBeaconBlockFulu) (*SignedBeaconBlockFulu, error) {
 	block, err := BeaconBlockFuluFromConsensus(b.Block)
 	if err != nil {
@@ -3709,9 +3762,28 @@ func SignedBeaconBlockContentsFuluFromConsensus(b *eth.SignedBeaconBlockContents
 	}, nil
 }
 
+func BeaconBlockContentsFuluFromConsensus(b *eth.BeaconBlockContentsFulu) (*BeaconBlockContentsFulu, error) {
+	block, err := BeaconBlockElectraFromConsensus(b.Block)
+	if err != nil {
+		return nil, err
+	}
+	proofs := make([]string, len(b.KzgProofs))
+	for i, proof := range b.KzgProofs {
+		proofs[i] = hexutil.Encode(proof)
+	}
+	blbs := make([]string, len(b.Blobs))
+	for i, blob := range b.Blobs {
+		blbs[i] = hexutil.Encode(blob)
+	}
+	return &BeaconBlockContentsFulu{
+		Block:     block,
+		KzgProofs: proofs,
+		Blobs:     blbs,
+	}, nil
+}
+
 var (
 	BeaconBlockFuluFromConsensus            = BeaconBlockElectraFromConsensus
-	BeaconBlockContentsFuluFromConsensus    = BeaconBlockContentsElectraFromConsensus
 	ExecutionPayloadFuluFromConsensus       = ExecutionPayloadDenebFromConsensus
 	ExecutionPayloadHeaderFuluFromConsensus = ExecutionPayloadHeaderDenebFromConsensus
 )

beacon-chain/db/kv/blocks.go

@@ -907,12 +907,12 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 			return nil, errors.Wrap(err, "could not unmarshal blinded Electra block")
 		}
 	case hasFuluKey(enc):
-		rawBlock = &ethpb.SignedBeaconBlockElectra{}
+		rawBlock = &ethpb.SignedBeaconBlockFulu{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(fuluKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal Fulu block")
 		}
 	case hasFuluBlindKey(enc):
-		rawBlock = &ethpb.SignedBlindedBeaconBlockElectra{}
+		rawBlock = &ethpb.SignedBlindedBeaconBlockFulu{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(fuluBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Fulu block")
 		}

beacon-chain/p2p/gossip_topic_mappings.go

@@ -29,6 +29,9 @@ var gossipTopicMappings = map[string]func() proto.Message{
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 	switch topic {
 	case BlockSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().FuluForkEpoch {
+			return &ethpb.SignedBeaconBlockFulu{}
+		}
 		if epoch >= params.BeaconConfig().ElectraForkEpoch {
 			return &ethpb.SignedBeaconBlockElectra{}
 		}
@@ -110,5 +113,6 @@ func init() {
 	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
 
-	// Nothing to specially handle for Fulu.
+	// Specially handle Fulu objects.
+	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockFulu{})] = BlockSubnetTopicFormat
 }

beacon-chain/p2p/types/object_mapping.go

@@ -72,7 +72,7 @@ func InitializeDataMaps() {
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
 			return blocks.NewSignedBeaconBlock(
-				&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
+				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
 			)
 		},
 	}

beacon-chain/rpc/eth/beacon/handlers_test.go

@@ -1603,7 +1603,7 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		cfg.FuluForkEpoch = 7
 		params.OverrideBeaconConfig(cfg)
 		params.SetupTestConfigCleanup(t)
-		var signedblock *structs.SignedBeaconBlockContentsElectra
+		var signedblock *structs.SignedBeaconBlockContentsFulu
 		require.NoError(t, json.Unmarshal([]byte(rpctesting.FuluBlockContents), &signedblock))
 		signedblock.SignedBlock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().FuluForkEpoch))
 		newContents, err := json.Marshal(signedblock)
@@ -1618,7 +1618,7 @@ func TestVersionHeaderFromRequest(t *testing.T) {
 		params.OverrideBeaconConfig(cfg)
 		params.SetupTestConfigCleanup(t)
 		var signedblock *structs.SignedBlindedBeaconBlockFulu
-		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock))
+		require.NoError(t, json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock))
 		signedblock.Message.Slot = fmt.Sprintf("%d", uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().FuluForkEpoch))
 		newBlock, err := json.Marshal(signedblock)
 		require.NoError(t, err)
@@ -2215,7 +2215,7 @@ func TestPublishBlindedBlock(t *testing.T) {
 			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
 			require.NoError(t, err)
 			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -2225,7 +2225,7 @@ func TestPublishBlindedBlock(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedFuluBlock)))
 		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -2445,20 +2445,20 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 	t.Run("Fulu", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
 			return ok
 		}))
 		server := &Server{
 			V1Alpha1ValidatorServer: v1alpha1Server,
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		var blk structs.SignedBlindedBeaconBlockElectra
-		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		var blk structs.SignedBlindedBeaconBlockFulu
+		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
@@ -3157,8 +3157,8 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
 			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockElectra
-			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			var signedblock *structs.SignedBlindedBeaconBlockFulu
+			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -3168,7 +3168,7 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedFuluBlock)))
 		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
@@ -3400,7 +3400,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 	t.Run("Fulu", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
 			return ok
 		}))
 		server := &Server{
@@ -3409,11 +3409,11 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		}
 
 		var blk structs.SignedBlindedBeaconBlockElectra
-		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)

beacon-chain/rpc/eth/shared/testing/json.go

@@ -1858,6 +1858,8 @@ var BlindedElectraBlock = fmt.Sprintf(`{
   "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
 }`, attestationCommitteeBits)
 
+var BlindedFuluBlock = BlindedElectraBlock
+
 var DenebBlockContents = fmt.Sprintf(`{
  	"signed_block":{
 		 "message": {

beacon-chain/rpc/eth/validator/handlers_block.go

@@ -305,7 +305,7 @@ func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *h
 		handleProduceBlindedFuluV3(w, isSSZ, blindedFuluBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
 		return
 	}
-	fuluBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_Electra)
+	fuluBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_Fulu)
 	if ok {
 		w.Header().Set(api.VersionHeader, version.String(version.Fulu))
 		handleProduceFuluV3(w, isSSZ, fuluBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
@@ -721,12 +721,12 @@ func handleProduceBlindedFuluV3(
 func handleProduceFuluV3(
 	w http.ResponseWriter,
 	isSSZ bool,
-	blk *eth.GenericBeaconBlock_Electra,
+	blk *eth.GenericBeaconBlock_Fulu,
 	executionPayloadValue string,
 	consensusBlockValue string,
 ) {
 	if isSSZ {
-		sszResp, err := blk.Electra.MarshalSSZ()
+		sszResp, err := blk.Fulu.MarshalSSZ()
 		if err != nil {
 			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 			return
@@ -735,7 +735,7 @@ func handleProduceFuluV3(
 		return
 	}
 
-	blockContents, err := structs.BeaconBlockContentsFuluFromConsensus(blk.Electra)
+	blockContents, err := structs.BeaconBlockContentsFuluFromConsensus(blk.Fulu)
 	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 		return

beacon-chain/rpc/prysm/v1alpha1/validator/blocks.go

@@ -175,12 +175,12 @@ func sendVerifiedBlocks(stream ethpb.BeaconNodeValidator_StreamBlocksAltairServe
 		if err != nil {
 			return errors.Wrap(err, "could not get protobuf block")
 		}
-		phBlk, ok := pb.(*ethpb.SignedBeaconBlockElectra)
+		phBlk, ok := pb.(*ethpb.SignedBeaconBlockFulu)
 		if !ok {
 			log.Warn("Mismatch between version and block type, was expecting SignedBeaconBlockFulu")
 			return nil
 		}
-		b.Block = &ethpb.StreamBlocksResponse_ElectraBlock{ElectraBlock: phBlk}
+		b.Block = &ethpb.StreamBlocksResponse_FuluBlock{FuluBlock: phBlk}
 	}
 
 	if err := stream.Send(b); err != nil {

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block.go

@@ -94,12 +94,12 @@ func (vs *Server) constructElectraBlock(blockProto proto.Message, isBlinded bool
 
 func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
 	if isBlinded {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blockProto.(*ethpb.BlindedBeaconBlockElectra)}, IsBlinded: true, PayloadValue: payloadValue}
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blockProto.(*ethpb.BlindedBeaconBlockFulu)}, IsBlinded: true, PayloadValue: payloadValue}
 	}
-	fuluContents := &ethpb.BeaconBlockContentsElectra{Block: blockProto.(*ethpb.BeaconBlockElectra)}
+	fuluContents := &ethpb.BeaconBlockContentsFulu{Block: blockProto.(*ethpb.BeaconBlockElectra)}
 	if bundle != nil {
 		fuluContents.KzgProofs = bundle.Proofs
 		fuluContents.Blobs = bundle.Blobs
 	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: fuluContents}, IsBlinded: false, PayloadValue: payloadValue}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: fuluContents}, IsBlinded: false, PayloadValue: payloadValue}
 }

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block_test.go

@@ -31,7 +31,7 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 		require.NoError(t, err)
 		result, err := vs.constructGenericBeaconBlock(b, nil, primitives.ZeroWei())
 		require.NoError(t, err)
-		r2, err := result.GetElectra().Block.HashTreeRoot()
+		r2, err := result.GetFulu().Block.HashTreeRoot()
 		require.NoError(t, err)
 		require.Equal(t, r1, r2)
 		require.Equal(t, result.IsBlinded, false)

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -519,6 +519,9 @@ func blobsAndProofs(req *ethpb.GenericSignedBeaconBlock) ([][]byte, [][]byte, er
 	case req.GetElectra() != nil:
 		dbBlockContents := req.GetElectra()
 		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
+	case req.GetFulu() != nil:
+		dbBlockContents := req.GetFulu()
+		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
 	default:
 		return nil, nil, errors.Errorf("unknown request type provided: %T", req)
 	}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block.go

@@ -16,6 +16,11 @@ func getEmptyBlock(slot primitives.Slot) (interfaces.SignedBeaconBlock, error) {
 	var err error
 	epoch := slots.ToEpoch(slot)
 	switch {
+	case epoch >= params.BeaconConfig().FuluForkEpoch:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
 	case epoch >= params.BeaconConfig().ElectraForkEpoch:
 		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 		if err != nil {

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block_test.go

@@ -76,7 +76,7 @@ func Test_getEmptyBlock(t *testing.T) {
 			name: "fulu",
 			slot: primitives.Slot(params.BeaconConfig().FuluForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
 			want: func() interfaces.ReadOnlySignedBeaconBlock {
-				b, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
+				b, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 				require.NoError(t, err)
 				return b
 			},

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -736,7 +736,7 @@ func TestServer_GetBeaconBlock_Fulu(t *testing.T) {
 			TargetPubkey:  bytesutil.PadTo(privKeys[2].PublicKey().Marshal(), 48),
 		},
 	}
-	blk := &ethpb.SignedBeaconBlockElectra{
+	blk := &ethpb.SignedBeaconBlockFulu{
 		Block: &ethpb.BeaconBlockElectra{
 			Slot:       fuluSlot + 1,
 			ParentRoot: parentRoot[:],