Experiment Prysm with eip4844

beacon-chain/blockchain/BUILD.bazel

@@ -37,6 +37,7 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositcache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blob:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",

beacon-chain/blockchain/log.go

@@ -37,14 +37,14 @@ func logStateTransitionData(b interfaces.BeaconBlock) error {
 	if len(b.Body().VoluntaryExits()) > 0 {
 		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
 	}
-	if b.Version() == version.Altair || b.Version() == version.Bellatrix {
+	if b.Version() == version.Altair || b.Version() == version.Bellatrix || b.Version() == version.EIP4844 {
 		agg, err := b.Body().SyncAggregate()
 		if err != nil {
 			return err
 		}
 		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 	}
-	if b.Version() == version.Bellatrix {
+	if b.Version() == version.Bellatrix || b.Version() == version.EIP4844 {
 		p, err := b.Body().Execution()
 		if err != nil {
 			return err
@@ -56,6 +56,13 @@ func logStateTransitionData(b interfaces.BeaconBlock) error {
 		}
 		log = log.WithField("txCount", len(txs))
 	}
+	if b.Version() == version.EIP4844 {
+		k, err := b.Body().BlobKzgs()
+		if err != nil {
+			return err
+		}
+		log = log.WithField("blobKzgCount", len(k))
+	}
 	log.Info("Finished applying state transition")
 	return nil
 }

beacon-chain/blockchain/metrics.go

@@ -277,7 +277,7 @@ func reportEpochMetrics(ctx context.Context, postState, headState state.BeaconSt
 		if err != nil {
 			return err
 		}
-	case version.Altair, version.Bellatrix:
+	case version.Altair, version.Bellatrix, version.EIP4844:
 		v, b, err = altair.InitializePrecomputeValidators(ctx, headState)
 		if err != nil {
 			return err

beacon-chain/blockchain/process_block.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/async/event"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blob"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
@@ -280,8 +281,7 @@ func getStateVersionAndPayload(st state.BeaconState) (int, *enginev1.ExecutionPa
 	return preStateVersion, preStateHeader, nil
 }
 
-func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock,
-	blockRoots [][32]byte) error {
+func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock, blockRoots [][32]byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()
 
@@ -400,6 +400,11 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 			tracing.AnnotateError(span, err)
 			return err
 		}
+
+		if err := s.saveSidecar(ctx, b); err != nil {
+			return err
+		}
+
 		if i > 0 && jCheckpoints[i].Epoch > jCheckpoints[i-1].Epoch {
 			if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, jCheckpoints[i]); err != nil {
 				tracing.AnnotateError(span, err)
@@ -543,15 +548,36 @@ func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashing
 func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock, st state.BeaconState) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.savePostStateInfo")
 	defer span.End()
+
 	if err := s.cfg.BeaconDB.SaveBlock(ctx, b); err != nil {
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block().Slot())
 	}
+	if err := s.saveSidecar(ctx, b); err != nil {
+		return errors.Wrapf(err, "could not save sidecar from slot %d", b.Block().Slot())
+	}
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
 		return errors.Wrap(err, "could not save state")
 	}
 	return nil
 }
 
+// Saves sidecar to the DB for the compatible block that contains the sidecar.
+func (s *Service) saveSidecar(ctx context.Context, b interfaces.SignedBeaconBlock) error {
+	ok, err := blob.BlockContainsSidecar(b)
+	if err != nil {
+		return errors.Wrap(err, "could not determine if block contains sidecar")
+	}
+	if !ok {
+		return nil
+	}
+
+	sc, err := b.SideCar()
+	if err != nil {
+		return errors.Wrap(err, "could not get sidecar")
+	}
+	return s.cfg.BeaconDB.SaveBlobsSidecar(ctx, sc.Message)
+}
+
 // This removes the attestations from the mem pool. It will only remove the attestations if input root `r` is canonical,
 // meaning the block `b` is part of the canonical chain.
 func (s *Service) pruneCanonicalAttsFromPool(ctx context.Context, r [32]byte, b interfaces.SignedBeaconBlock) error {

beacon-chain/blockchain/service.go

@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/async/event"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/blob"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -205,9 +206,9 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	var forkChoicer f.ForkChoicer
 	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
 	if features.Get().EnableForkChoiceDoublyLinkedTree {
-		forkChoicer = doublylinkedtree.New()
+		forkChoicer = doublylinkedtree.New(NewDBDataAvailability(s.cfg.BeaconDB))
 	} else {
-		forkChoicer = protoarray.New()
+		forkChoicer = protoarray.New(NewDBDataAvailability(s.cfg.BeaconDB))
 	}
 	s.cfg.ForkChoiceStore = forkChoicer
 	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
@@ -510,3 +511,39 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }
+
+type dbDataAvailability struct {
+	db db.ReadOnlyDatabase
+}
+
+func NewDBDataAvailability(db db.ReadOnlyDatabase) f.DataAvailability {
+	return &dbDataAvailability{db}
+}
+
+func (d *dbDataAvailability) IsDataAvailable(ctx context.Context, root [32]byte) error {
+	b, err := d.db.Block(ctx, root)
+	if err != nil {
+		return err
+	}
+	if err := wrapper.BeaconBlockIsNil(b); err != nil {
+		return err
+	}
+	if !blob.BlockContainsKZGs(b.Block()) {
+		// no sidecar referenced. We have all the data we need
+		return nil
+	}
+
+	kzgs, err := b.Block().Body().BlobKzgs()
+	if err != nil {
+		// shouldn't happen if blob contains kzgs
+		return err
+	}
+	sidecar, err := d.db.BlobsSidecar(ctx, root)
+	if err != nil {
+		return err
+	}
+	if sidecar.BeaconBlockSlot != b.Block().Slot() {
+		return errors.New("blobs sidecar is unavailable")
+	}
+	return blob.VerifyBlobsSidecar(b.Block().Slot(), root, bytesutil.ToBytes48Array(kzgs), sidecar)
+}

beacon-chain/blockchain/testing/mock.go

@@ -48,9 +48,11 @@ type ChainService struct {
 	DB                          db.Database
 	State                       state.BeaconState
 	Block                       interfaces.SignedBeaconBlock
+	Sidecar                     *ethpb.BlobsSidecar
 	VerifyBlkDescendantErr      error
 	stateNotifier               statefeed.Notifier
 	BlocksReceived              []interfaces.SignedBeaconBlock
+	SidecarsReceived            []*ethpb.BlobsSidecar
 	SyncCommitteeIndices        []types.CommitteeIndex
 	blockNotifier               blockfeed.Notifier
 	opNotifier                  opfeed.Notifier
@@ -194,7 +196,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interf
 }
 
 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock, _ [][32]byte) error {
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.SignedBeaconBlock, _ [][32]byte, sidecars []*ethpb.BlobsSidecar) error {
 	if s.State == nil {
 		return ErrNilState
 	}
@@ -210,20 +212,35 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []interfaces.
 		if err != nil {
 			return err
 		}
+		sidecar := findSidecarForBlock(b.Block(), signingRoot, sidecars)
+		if sidecar != nil {
+			if bytesutil.ToBytes32(sidecar.BeaconBlockRoot) != signingRoot {
+				return errors.Errorf("sidecar root mismatch blk=%#x sidecar=%#x", signingRoot, sidecar.BeaconBlockRoot)
+			}
+			if sidecar.BeaconBlockSlot != b.Block().Slot() {
+				return errors.Errorf("sidecar slot mismatch blk=%#x sidecar=%#x", b.Block().Slot(), sidecar.BeaconBlockSlot)
+			}
+		}
 		if s.DB != nil {
+			if sidecar != nil {
+				if err := s.DB.SaveBlobsSidecar(ctx, sidecar); err != nil {
+					return err
+				}
+			}
 			if err := s.DB.SaveBlock(ctx, b); err != nil {
 				return err
 			}
 			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, b.Block().Slot())
 		}
 		s.Root = signingRoot[:]
 		s.Block = b
+		s.Sidecar = sidecar
 	}
 	return nil
 }
 
 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte) error {
+func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, _ [32]byte, sidecar *ethpb.BlobsSidecar) error {
 	if s.ReceiveBlockMockErr != nil {
 		return s.ReceiveBlockMockErr
 	}
@@ -241,14 +258,31 @@ func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.Signed
 	if err != nil {
 		return err
 	}
+	if sidecar != nil {
+		if bytesutil.ToBytes32(sidecar.BeaconBlockRoot) != signingRoot {
+			return errors.Errorf("sidecar root mismatch blk=%#x sidecar=%#x", signingRoot, sidecar.BeaconBlockRoot)
+		}
+		if sidecar.BeaconBlockSlot != block.Block().Slot() {
+			return errors.Errorf("sidecar slot mismatch blk=%#x sidecar=%#x", block.Block().Slot(), sidecar.BeaconBlockSlot)
+		}
+	}
+	if sidecar != nil {
+		s.SidecarsReceived = append(s.SidecarsReceived, sidecar)
+	}
 	if s.DB != nil {
+		if sidecar != nil {
+			if err := s.DB.SaveBlobsSidecar(ctx, sidecar); err != nil {
+				return err
+			}
+		}
 		if err := s.DB.SaveBlock(ctx, block); err != nil {
 			return err
 		}
 		logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
 	}
 	s.Root = signingRoot[:]
 	s.Block = block
+	s.Sidecar = sidecar
 	return nil
 }
 
@@ -464,3 +498,16 @@ func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterS
 func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {
 	return s.FinalizedRoots[blockRoot]
 }
+
+func findSidecarForBlock(b interfaces.BeaconBlock, blkRoot [32]byte, sidecars []*ethpb.BlobsSidecar) *ethpb.BlobsSidecar {
+	for _, s := range sidecars {
+		if b.Slot() != s.BeaconBlockSlot {
+			continue
+		}
+		if blkRoot != bytesutil.ToBytes32(s.BeaconBlockRoot) {
+			continue
+		}
+		return s
+	}
+	return nil
+}

beacon-chain/cache/sync_committee_head_state.go

@@ -53,7 +53,7 @@ func (c *SyncCommitteeHeadStateCache) Get(slot types.Slot) (state.BeaconState, e
 		return nil, ErrIncorrectType
 	}
 	switch st.Version() {
-	case version.Altair, version.Bellatrix:
+	case version.Altair, version.Bellatrix, version.EIP4844:
 	default:
 		return nil, ErrIncorrectType
 	}

beacon-chain/core/altair/transition.go

@@ -68,11 +68,11 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	}
 
 	// Modified in Altair and Bellatrix.
-	proportionalSlashingMultipler, err := state.ProportionalSlashingMultiplier()
+	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
 	if err != nil {
 		return nil, err
 	}
-	state, err = e.ProcessSlashings(state, proportionalSlashingMultipler)
+	state, err = e.ProcessSlashings(state, proportionalSlashingMultiplier)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blob/BUILD.bazel

@@ -0,0 +1,18 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["sidecar.go"],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/blob",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//consensus-types/wrapper:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)