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

beacon-chain/blockchain/pow_block.go

@@ -84,7 +84,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/db/kv/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "log.go",
         "migration.go",
         "migration_archived_index.go",
+        "migration_blinded_beacon_blocks.go",
         "migration_block_slot_index.go",
         "migration_state_validators.go",
         "powchain.go",

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"
@@ -130,7 +131,7 @@ func (s *Store) Blocks(ctx context.Context, f *filters.QueryFilter) ([]interface
 			encoded := bkt.Get(keys[i])
 			blk, err := unmarshalBlock(ctx, encoded)
 			if err != nil {
-				return err
+				return errors.Wrapf(err, "could not unmarshal block with key %#x", keys[i])
 			}
 			blocks = append(blocks, blk)
 			blockRoots = append(blockRoots, bytesutil.ToBytes32(keys[i]))
@@ -304,6 +305,16 @@ 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 {
+				blindedBlock, err := blk.ToBlinded()
+				if err != nil {
+					if !errors.Is(err, wrapper.ErrUnsupportedVersion) {
+						return err
+					}
+				} else {
+					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
@@ -758,51 +769,73 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.SignedBeaconBlock
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "could not snappy decode block")
 	}
 	var rawBlock ssz.Unmarshaler
 	switch {
 	case hasAltairKey(enc):
 		// Marshal block bytes to altair beacon block.
 		rawBlock = &ethpb.SignedBeaconBlockAltair{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not unmarshal Altair block")
 		}
 	case hasBellatrixKey(enc):
 		rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not unmarshal Bellatrix block")
 		}
 	case hasBellatrixBlindKey(enc):
 		rawBlock = &ethpb.SignedBlindedBeaconBlockBellatrix{}
 		if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixBlindKey):]); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not unmarshal blinded Bellatrix block")
 		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
 		if err := rawBlock.UnmarshalSSZ(enc); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "could not unmarshal Phase0 block")
 		}
 	}
 	return wrapper.WrappedSignedBeaconBlock(rawBlock)
 }
 
 // marshal versioned beacon block from struct type down to bytes.
 func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte, error) {
-	obj, err := blk.MarshalSSZ()
-	if err != nil {
-		return nil, err
+	var encodedBlock []byte
+	var err error
+	blockToSave := blk
+	if features.Get().EnableOnlyBlindedBeaconBlocks {
+		blindedBlock, err := blk.ToBlinded()
+		switch {
+		case errors.Is(err, wrapper.ErrUnsupportedVersion):
+			encodedBlock, err = blk.MarshalSSZ()
+			if err != nil {
+				return nil, errors.Wrap(err, "could not marshal non-blinded block")
+			}
+		case err != nil:
+			return nil, errors.Wrap(err, "could not convert block to blinded format")
+		default:
+			encodedBlock, err = blindedBlock.MarshalSSZ()
+			if err != nil {
+				return nil, errors.Wrap(err, "could not marshal blinded block")
+			}
+			blockToSave = blindedBlock
+		}
+	} else {
+		encodedBlock, err = blk.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
 	}
-	switch blk.Version() {
+	switch blockToSave.Version() {
 	case version.BellatrixBlind:
-		return snappy.Encode(nil, append(bellatrixBlindKey, obj...)), nil
+		return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil
 	case version.Bellatrix:
-		return snappy.Encode(nil, append(bellatrixKey, obj...)), 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")
 	}

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 = retrievedBlock.ToBlinded()
+				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 = blk.ToBlinded()
+				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 = wanted.ToBlinded()
+				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 = block2.ToBlinded()
+				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 = wanted.ToBlinded()
+				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 = block1.ToBlinded()
+				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 = genesisBlock.ToBlinded()
+				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 = genesisBlock.ToBlinded()
+				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 = b1.ToBlinded()
+				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 = b2.ToBlinded()
+				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 = b3.ToBlinded()
+				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/db/kv/kv.go

@@ -4,6 +4,7 @@ package kv
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path"
 	"time"
@@ -14,6 +15,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	prombolt "github.com/prysmaticlabs/prombbolt"
 	"github.com/prysmaticlabs/prysm/beacon-chain/db/iface"
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/io/file"
 	bolt "go.etcd.io/bbolt"
@@ -183,8 +185,13 @@ func NewKVStore(ctx context.Context, dirPath string, config *Config) (*Store, er
 	}); err != nil {
 		return nil, err
 	}
-	err = prometheus.Register(createBoltCollector(kv.db))
-	return kv, err
+	if err = prometheus.Register(createBoltCollector(kv.db)); err != nil {
+		return nil, err
+	}
+	if err = kv.checkNeedsResync(); err != nil {
+		return nil, err
+	}
+	return kv, nil
 }
 
 // ClearDB removes the previously stored database in the data directory.
@@ -216,6 +223,23 @@ func (s *Store) DatabasePath() string {
 	return s.databasePath
 }
 
+func (s *Store) checkNeedsResync() error {
+	return s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(migrationsBucket)
+		hasDisabledFeature := !features.Get().EnableOnlyBlindedBeaconBlocks
+		if hasDisabledFeature && bkt.Get(migrationBlindedBeaconBlocksKey) != nil {
+			return fmt.Errorf(
+				"you have disabled the flag %s, and your node must resync to ensure your "+
+					"database is compatible. If you do not want to resync, please re-enable the %s flag",
+				features.EnableOnlyBlindedBeaconBlocks.Name,
+				features.EnableOnlyBlindedBeaconBlocks.Name,
+			)
+		}
+		return nil
+	})
+
+}
+
 func createBuckets(tx *bolt.Tx, buckets ...[]byte) error {
 	for _, bucket := range buckets {
 		if _, err := tx.CreateBucketIfNotExists(bucket); err != nil {

beacon-chain/db/kv/kv_test.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/testing/require"
+	bolt "go.etcd.io/bbolt"
 )
 
 // setupDB instantiates and returns a Store instance.
@@ -16,3 +18,17 @@ func setupDB(t testing.TB) *Store {
 	})
 	return db
 }
+
+func Test_checkNeedsResync(t *testing.T) {
+	store := setupDB(t)
+	resetFn := features.InitWithReset(&features.Flags{
+		EnableOnlyBlindedBeaconBlocks: false,
+	})
+	defer resetFn()
+	require.NoError(t, store.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(migrationsBucket)
+		return bkt.Put(migrationBlindedBeaconBlocksKey, migrationCompleted)
+	}))
+	err := store.checkNeedsResync()
+	require.ErrorContains(t, "your node must resync", err)
+}

beacon-chain/db/kv/migration.go

@@ -14,6 +14,7 @@ var migrations = []migration{
 	migrateArchivedIndex,
 	migrateBlockSlotIndex,
 	migrateStateValidators,
+	migrateBlindedBeaconBlocksEnabled,
 }
 
 // RunMigrations defined in the migrations array.