[Feature] - Store Only Blinded Beacon Blocks Post-Merge

beacon-chain/blockchain/execution_engine.go

@@ -145,14 +145,7 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 	if err != nil {
 		return [32]byte{}, err
 	}
-	if blocks.IsPreBellatrixVersion(blk.Block().Version()) {
-		return params.BeaconConfig().ZeroHash, nil
-	}
-	payload, err := blk.Block().Body().ExecutionPayload()
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not get execution payload")
-	}
-	return bytesutil.ToBytes32(payload.BlockHash), nil
+	return getBlockPayloadHash(blk.Block())
 }
 
 // notifyForkchoiceUpdate signals execution engine on a new payload.

beacon-chain/blockchain/pow_block.go

@@ -85,7 +85,7 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBea
 
 // getBlkParentHashAndTD retrieves the parent hash and total difficulty of the given block.
 func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]byte, *uint256.Int, error) {
-	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash))
+	blk, err := s.cfg.ExecutionEngineCaller.ExecutionBlockByHash(ctx, common.BytesToHash(blkHash), false /* no txs */)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not get pow block")
 	}

beacon-chain/blockchain/process_block.go

@@ -537,6 +537,27 @@ func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashing
 	}
 }
 
+func getBlockPayloadHash(blk interfaces.BeaconBlock) ([32]byte, error) {
+	var blockHashFromPayload [32]byte
+	if blocks.IsPreBellatrixVersion(blk.Version()) {
+		return blockHashFromPayload, nil
+	}
+	payload, err := blk.Body().ExecutionPayload()
+	switch {
+	case errors.Is(err, wrapper.ErrUnsupportedField):
+		payloadHeader, err := blk.Body().ExecutionPayloadHeader()
+		if err != nil {
+			return blockHashFromPayload, err
+		}
+		blockHashFromPayload = bytesutil.ToBytes32(payloadHeader.BlockHash)
+	case err != nil:
+		return blockHashFromPayload, err
+	default:
+		blockHashFromPayload = bytesutil.ToBytes32(payload.BlockHash)
+	}
+	return blockHashFromPayload, nil
+}
+
 // This saves post state info to DB or cache. This also saves post state info to fork choice store.
 // Post state info consists of processed block and state. Do not call this method unless the block and state are verified.
 func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock, st state.BeaconState) error {

beacon-chain/db/kv/blocks.go

@@ -10,6 +10,7 @@ import (
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/consensus-types/primitives"
@@ -304,6 +305,15 @@ func (s *Store) SaveBlocks(ctx context.Context, blocks []interfaces.SignedBeacon
 			if err := updateValueForIndices(ctx, indicesForBlocks[i], blockRoots[i], tx); err != nil {
 				return errors.Wrap(err, "could not update DB indices")
 			}
+			if features.Get().EnableOnlyBlindedBeaconBlocks {
+				if _, err := blk.Block().Body().ExecutionPayload(); err == nil {
+					blindedBlock, err := wrapper.WrapSignedBlindedBeaconBlock(blk)
+					if err != nil {
+						return err
+					}
+					blk = blindedBlock
+				}
+			}
 			s.blockCache.Set(string(blockRoots[i]), blk, int64(len(encodedBlocks[i])))
 			if err := bkt.Put(blockRoots[i], encodedBlocks[i]); err != nil {
 				return err
@@ -790,20 +800,37 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 
 // marshal versioned beacon block from struct type down to bytes.
 func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte, error) {
-	obj, err := blk.MarshalSSZ()
+	encodedBlock, err := determineBlockTypeToMarshal(blk)
 	if err != nil {
 		return nil, err
 	}
 	switch blk.Version() {
-	case version.BellatrixBlind:
-		return snappy.Encode(nil, append(bellatrixBlindKey, obj...)), nil
-	case version.Bellatrix:
-		return snappy.Encode(nil, append(bellatrixKey, obj...)), nil
+	case version.Bellatrix, version.BellatrixBlind:
+		if features.Get().EnableOnlyBlindedBeaconBlocks {
+			return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil
+		}
+		return snappy.Encode(nil, append(bellatrixKey, encodedBlock...)), nil
 	case version.Altair:
-		return snappy.Encode(nil, append(altairKey, obj...)), nil
+		return snappy.Encode(nil, append(altairKey, encodedBlock...)), nil
 	case version.Phase0:
-		return snappy.Encode(nil, obj), nil
+		return snappy.Encode(nil, encodedBlock), nil
 	default:
 		return nil, errors.New("Unknown block version")
 	}
 }
+
+func determineBlockTypeToMarshal(blk interfaces.SignedBeaconBlock) ([]byte, error) {
+	if !features.Get().EnableOnlyBlindedBeaconBlocks {
+		return blk.MarshalSSZ()
+	}
+	// If the block supports blinding of execution payloads, we wrap as
+	// a signed, blinded beacon block and then marshal to bytes. Otherwise,
+	// We just marshal the block as it is.
+	blindedBlock, err := wrapper.WrapSignedBlindedBeaconBlock(blk)
+	if errors.Is(err, wrapper.ErrUnsupportedSignedBeaconBlock) {
+		return blk.MarshalSSZ()
+	} else if err != nil {
+		return nil, err
+	}
+	return blindedBlock.MarshalSSZ()
+}

beacon-chain/db/kv/blocks_test.go

@@ -134,11 +134,17 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err := db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			assert.DeepEqual(t, nil, retrievedBlock, "Expected nil block")
+
 			require.NoError(t, db.SaveBlock(ctx, blk))
 			assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
+			wanted := retrievedBlock
+			if _, err := retrievedBlock.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(retrievedBlock)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", wanted, retrievedBlock)
 		})
 	}
 }
@@ -314,7 +320,13 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(blk.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", blk, retrievedBlock)
+
+			wanted := blk
+			if _, err := blk.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(blk)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), retrievedBlock.Proto()), "Wanted: %v, received: %v", wanted, retrievedBlock)
 		})
 	}
 }
@@ -524,7 +536,12 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root := roots[0]
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
+			wanted := block1
+			if _, err := block1.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(wanted)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 11)
 			require.NoError(t, err)
@@ -533,7 +550,12 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block2.Proto(), b.Proto()), "Wanted: %v, received: %v", block2, b)
+			wanted2 := block2
+			if _, err := block2.PbBellatrixBlock(); err == nil {
+				wanted2, err = wrapper.WrapSignedBlindedBeaconBlock(block2)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted2.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted2, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 101)
 			require.NoError(t, err)
@@ -542,7 +564,12 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block3.Proto(), b.Proto()), "Wanted: %v, received: %v", block3, b)
+			wanted = block3
+			if _, err := block3.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(wanted)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted, b)
 		})
 	}
 }
@@ -569,23 +596,38 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			root := roots[0]
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(block1.Proto(), b.Proto()), "Wanted: %v, received: %v", block1, b)
+			wanted := block1
+			if _, err := block1.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(block1)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 1)
 			require.NoError(t, err)
 			require.Equal(t, 1, len(roots))
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
+			wanted = genesisBlock
+			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(genesisBlock)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted, b)
 
 			_, roots, err = db.HighestRootsBelowSlot(ctx, 0)
 			require.NoError(t, err)
 			require.Equal(t, 1, len(roots))
 			root = roots[0]
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(genesisBlock.Proto(), b.Proto()), "Wanted: %v, received: %v", genesisBlock, b)
+			wanted = genesisBlock
+			if _, err := genesisBlock.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(genesisBlock)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), b.Proto()), "Wanted: %v, received: %v", wanted, b)
 		})
 	}
 }
@@ -671,15 +713,31 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			assert.Equal(t, 0, len(retrievedBlocks), "Unexpected number of blocks received, expected none")
 			retrievedBlocks, err = db.BlocksBySlot(ctx, 20)
 			require.NoError(t, err)
-			assert.Equal(t, true, proto.Equal(b1.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b1, retrievedBlocks[0])
+
+			wanted := b1
+			if _, err := b1.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(b1)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(retrievedBlocks[0].Proto(), wanted.Proto()), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
 			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
 			retrievedBlocks, err = db.BlocksBySlot(ctx, 100)
 			require.NoError(t, err)
 			if len(retrievedBlocks) != 2 {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
-			assert.Equal(t, true, proto.Equal(b2.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", b2, retrievedBlocks[0])
-			assert.Equal(t, true, proto.Equal(b3.Proto(), retrievedBlocks[1].Proto()), "Wanted: %v, received: %v", b3, retrievedBlocks[1])
+			wanted = b2
+			if _, err := b2.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(b2)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(wanted.Proto(), retrievedBlocks[0].Proto()), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
+			wanted = b3
+			if _, err := b3.PbBellatrixBlock(); err == nil {
+				wanted, err = wrapper.WrapSignedBlindedBeaconBlock(b3)
+				require.NoError(t, err)
+			}
+			assert.Equal(t, true, proto.Equal(retrievedBlocks[1].Proto(), wanted.Proto()), "Wanted: %v, received: %v", retrievedBlocks[1], wanted)
 			assert.Equal(t, true, len(retrievedBlocks) > 0, "Expected to have blocks")
 
 			hasBlockRoots, retrievedBlockRoots, err := db.BlockRootsBySlot(ctx, 1)

beacon-chain/db/kv/init_test.go

@@ -1,6 +1,7 @@
 package kv
 
 import (
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 )
 
@@ -9,4 +10,7 @@ func init() {
 	if err := params.SetActive(params.MainnetTestConfig()); err != nil {
 		panic(err)
 	}
+	features.Init(&features.Flags{
+		EnableOnlyBlindedBeaconBlocks: true,
+	})
 }

beacon-chain/node/node.go

@@ -694,6 +694,7 @@ func (b *BeaconNode) registerSyncService() error {
 		regularsync.WithStateGen(b.stateGen),
 		regularsync.WithSlasherAttestationsFeed(b.slasherAttestationsFeed),
 		regularsync.WithSlasherBlockHeadersFeed(b.slasherBlockHeadersFeed),
+		regularsync.WithExecutionPayloadReconstructor(web3Service),
 	)
 	return b.services.RegisterService(rs)
 }
@@ -799,49 +800,50 @@ func (b *BeaconNode) registerRPCService() error {
 
 	p2pService := b.fetchP2P()
 	rpcService := rpc.NewService(b.ctx, &rpc.Config{
-		Host:                    host,
-		Port:                    port,
-		BeaconMonitoringHost:    beaconMonitoringHost,
-		BeaconMonitoringPort:    beaconMonitoringPort,
-		CertFlag:                cert,
-		KeyFlag:                 key,
-		BeaconDB:                b.db,
-		Broadcaster:             p2pService,
-		PeersFetcher:            p2pService,
-		PeerManager:             p2pService,
-		MetadataProvider:        p2pService,
-		ChainInfoFetcher:        chainService,
-		HeadUpdater:             chainService,
-		HeadFetcher:             chainService,
-		CanonicalFetcher:        chainService,
-		ForkFetcher:             chainService,
-		FinalizationFetcher:     chainService,
-		BlockReceiver:           chainService,
-		AttestationReceiver:     chainService,
-		GenesisTimeFetcher:      chainService,
-		GenesisFetcher:          chainService,
-		OptimisticModeFetcher:   chainService,
-		AttestationsPool:        b.attestationPool,
-		ExitPool:                b.exitPool,
-		SlashingsPool:           b.slashingsPool,
-		SlashingChecker:         slasherService,
-		SyncCommitteeObjectPool: b.syncCommitteePool,
-		POWChainService:         web3Service,
-		POWChainInfoFetcher:     web3Service,
-		ChainStartFetcher:       chainStartFetcher,
-		MockEth1Votes:           mockEth1DataVotes,
-		SyncService:             syncService,
-		DepositFetcher:          depositFetcher,
-		PendingDepositFetcher:   b.depositCache,
-		BlockNotifier:           b,
-		StateNotifier:           b,
-		OperationNotifier:       b,
-		StateGen:                b.stateGen,
-		EnableDebugRPCEndpoints: enableDebugRPCEndpoints,
-		MaxMsgSize:              maxMsgSize,
-		ProposerIdsCache:        b.proposerIdsCache,
-		ExecutionEngineCaller:   web3Service,
-		BlockBuilder:            b.fetchBuilderService(),
+		ExecutionEngineCaller:         web3Service,
+		ExecutionPayloadReconstructor: web3Service,
+		Host:                          host,
+		Port:                          port,
+		BeaconMonitoringHost:          beaconMonitoringHost,
+		BeaconMonitoringPort:          beaconMonitoringPort,
+		CertFlag:                      cert,
+		KeyFlag:                       key,
+		BeaconDB:                      b.db,
+		Broadcaster:                   p2pService,
+		PeersFetcher:                  p2pService,
+		PeerManager:                   p2pService,
+		MetadataProvider:              p2pService,
+		ChainInfoFetcher:              chainService,
+		HeadUpdater:                   chainService,
+		HeadFetcher:                   chainService,
+		CanonicalFetcher:              chainService,
+		ForkFetcher:                   chainService,
+		FinalizationFetcher:           chainService,
+		BlockReceiver:                 chainService,
+		AttestationReceiver:           chainService,
+		GenesisTimeFetcher:            chainService,
+		GenesisFetcher:                chainService,
+		OptimisticModeFetcher:         chainService,
+		AttestationsPool:              b.attestationPool,
+		ExitPool:                      b.exitPool,
+		SlashingsPool:                 b.slashingsPool,
+		SlashingChecker:               slasherService,
+		SyncCommitteeObjectPool:       b.syncCommitteePool,
+		POWChainService:               web3Service,
+		POWChainInfoFetcher:           web3Service,
+		ChainStartFetcher:             chainStartFetcher,
+		MockEth1Votes:                 mockEth1DataVotes,
+		SyncService:                   syncService,
+		DepositFetcher:                depositFetcher,
+		PendingDepositFetcher:         b.depositCache,
+		BlockNotifier:                 b,
+		StateNotifier:                 b,
+		OperationNotifier:             b,
+		StateGen:                      b.stateGen,
+		EnableDebugRPCEndpoints:       enableDebugRPCEndpoints,
+		MaxMsgSize:                    maxMsgSize,
+		ProposerIdsCache:              b.proposerIdsCache,
+		BlockBuilder:                  b.fetchBuilderService(),
 	})
 
 	return b.services.RegisterService(rpcService)