Merge branch 'develop' into peerDAS

CHANGELOG.md

@@ -18,8 +18,11 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Add field param placeholder for Electra blob target and max to pass spec tests.
 - Add EIP-7691: Blob throughput increase.
 - SSZ files generation: Remove the `// Hash: ...` header.
+- DB optimization for saving light client bootstraps (save unique sync committees only).
 - Trace IDONTWANT Messages in Pubsub.
 - Add Fulu fork boilerplate.
+- Separate type for unaggregated network attestations. [PR](https://github.com/prysmaticlabs/prysm/pull/14659)
+- Update spec tests to v1.5.0-beta.0.
 
 ### Changed
 
@@ -39,6 +42,10 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Update our `go-libp2p-pubsub` dependency.
 - Re-organize the content of files to ease the creation of a new fork boilerplate.
 - Fixed Metadata errors for peers connected via QUIC.
+- Process light client finality updates only for new finalized epochs instead of doing it for every block.
+- Update blobs by rpc topics from V2 to V1.
+- Updated geth to 1.14 ~
+- E2e tests start from bellatrix
 
 ### Deprecated
 
@@ -47,11 +54,13 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 - Cleanup ProcessSlashings method to remove unnecessary argument.
 - Remove `/proto/eth/v2` directory. [PR](https://github.com/prysmaticlabs/prysm/pull/14765)
+- Remove `/memsize/` pprof endpoint as it will no longer be supported in go 1.23, geth also removed in https://github.com/ethereum/go-ethereum/commit/e4675771eda550e7eeb63a8884816982c1980644
 
 ### Fixed
 
 - Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator.
 - EIP-7691: Ensure new blobs subnets are subscribed on epoch in advance.
+- Fix kzg commitment inclusion proof depth minimal value.
 
 ### Security
 

api/server/structs/conversions.go

@@ -432,6 +432,32 @@ func (a *AttestationElectra) ToConsensus() (*eth.AttestationElectra, error) {
 	}, nil
 }
 
+func (a *SingleAttestation) ToConsensus() (*eth.SingleAttestation, error) {
+	ci, err := strconv.ParseUint(a.CommitteeIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "CommitteeIndex")
+	}
+	ai, err := strconv.ParseUint(a.AttesterIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "AttesterIndex")
+	}
+	data, err := a.Data.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Data")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+
+	return &eth.SingleAttestation{
+		CommitteeId:   primitives.CommitteeIndex(ci),
+		AttesterIndex: primitives.ValidatorIndex(ai),
+		Data:          data,
+		Signature:     sig,
+	}, nil
+}
+
 func AttElectraFromConsensus(a *eth.AttestationElectra) *AttestationElectra {
 	return &AttestationElectra{
 		AggregationBits: hexutil.Encode(a.AggregationBits),

api/server/structs/other.go

@@ -36,6 +36,13 @@ type AttestationElectra struct {
 	CommitteeBits   string           `json:"committee_bits"`
 }
 
+type SingleAttestation struct {
+	CommitteeIndex string           `json:"committee_index"`
+	AttesterIndex  string           `json:"attester_index"`
+	Data           *AttestationData `json:"data"`
+	Signature      string           `json:"signature"`
+}
+
 type AttestationData struct {
 	Slot            string      `json:"slot"`
 	CommitteeIndex  string      `json:"index"`

beacon-chain/blockchain/kzg/kzg.go

@@ -39,15 +39,17 @@ type CellsAndProofs struct {
 }
 
 func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
-	comm, err := kzg4844.BlobToCommitment(kzg4844.Blob(*blob))
+	kzgBlob := kzg4844.Blob(*blob)
+	comm, err := kzg4844.BlobToCommitment(&kzgBlob)
 	if err != nil {
 		return Commitment{}, err
 	}
 	return Commitment(comm), nil
 }
 
 func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
-	proof, err := kzg4844.ComputeBlobProof(kzg4844.Blob(*blob), kzg4844.Commitment(commitment))
+	kzgBlob := kzg4844.Blob(*blob)
+	proof, err := kzg4844.ComputeBlobProof(&kzgBlob, kzg4844.Commitment(commitment))
 	if err != nil {
 		return [48]byte{}, err
 	}

beacon-chain/blockchain/kzg/validation.go

@@ -20,16 +20,17 @@ func Verify(sidecars ...blocks.ROBlob) error {
 	cmts := make([]GoKZG.KZGCommitment, len(sidecars))
 	proofs := make([]GoKZG.KZGProof, len(sidecars))
 	for i, sidecar := range sidecars {
-		blobs[i] = bytesToBlob(sidecar.Blob)
+		blobs[i] = *bytesToBlob(sidecar.Blob)
 		cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
 		proofs[i] = bytesToKZGProof(sidecar.KzgProof)
 	}
 	return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
 }
 
-func bytesToBlob(blob []byte) (ret GoKZG.Blob) {
+func bytesToBlob(blob []byte) *GoKZG.Blob {
+	var ret GoKZG.Blob
 	copy(ret[:], blob)
-	return
+	return &ret
 }
 
 func bytesToCommitment(commitment []byte) (ret GoKZG.KZGCommitment) {

beacon-chain/blockchain/kzg/validation_test.go

@@ -10,11 +10,11 @@ import (
 )
 
 func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) {
-	commitment, err := kzgContext.BlobToKZGCommitment(blob, 0)
+	commitment, err := kzgContext.BlobToKZGCommitment(&blob, 0)
 	if err != nil {
 		return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
 	}
-	proof, err := kzgContext.ComputeBlobKZGProof(blob, commitment, 0)
+	proof, err := kzgContext.ComputeBlobKZGProof(&blob, commitment, 0)
 	if err != nil {
 		return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
 	}
@@ -31,7 +31,7 @@ func TestBytesToAny(t *testing.T) {
 	blob := GoKZG.Blob{0x01, 0x02}
 	commitment := GoKZG.KZGCommitment{0x01, 0x02}
 	proof := GoKZG.KZGProof{0x01, 0x02}
-	require.DeepEqual(t, blob, bytesToBlob(bytes))
+	require.DeepEqual(t, blob, *bytesToBlob(bytes))
 	require.DeepEqual(t, commitment, bytesToCommitment(bytes))
 	require.DeepEqual(t, proof, bytesToKZGProof(bytes))
 }

beacon-chain/blockchain/process_block.go

@@ -71,6 +71,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
 		defer s.saveLightClientUpdate(cfg)
+		defer s.saveLightClientBootstrap(cfg)
 	}
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)

beacon-chain/core/helpers/attestation.go

@@ -32,6 +32,9 @@ func ValidateNilAttestation(attestation ethpb.Att) error {
 	if attestation.GetData().Target == nil {
 		return errors.New("attestation's target can't be nil")
 	}
+	if attestation.IsSingle() {
+		return nil
+	}
 	if attestation.GetAggregationBits() == nil {
 		return errors.New("attestation's bitfield can't be nil")
 	}

beacon-chain/core/helpers/attestation_test.go

@@ -308,6 +308,16 @@ func TestValidateNilAttestation(t *testing.T) {
 			},
 			errString: "",
 		},
+		{
+			name: "single attestation",
+			attestation: &ethpb.SingleAttestation{
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+					Source: &ethpb.Checkpoint{},
+				},
+			},
+			errString: "",
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -97,6 +97,13 @@ func TestVerifyBitfieldLength_OK(t *testing.T) {
 	assert.NoError(t, helpers.VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be")
 }
 
+func TestVerifyBitfieldLength_Incorrect(t *testing.T) {
+	helpers.ClearCache()
+
+	bf := bitfield.NewBitlist(1)
+	require.ErrorContains(t, "wanted participants bitfield length 2, got: 1", helpers.VerifyBitfieldLength(bf, 2))
+}
+
 func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 	helpers.ClearCache()
 

beacon-chain/db/kv/BUILD.bazel

@@ -41,6 +41,7 @@ go_library(
         "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

beacon-chain/db/kv/kv.go

@@ -109,6 +109,7 @@ var Buckets = [][]byte{
 	stateValidatorsBucket,
 	lightClientUpdatesBucket,
 	lightClientBootstrapBucket,
+	lightClientSyncCommitteeBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,

beacon-chain/db/kv/lightclient.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/golang/snappy"
 	"github.com/pkg/errors"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -35,9 +37,35 @@ func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot []byte,
 	_, span := trace.StartSpan(ctx, "BeaconDB.SaveLightClientBootstrap")
 	defer span.End()
 
+	bootstrapCopy, err := light_client.NewWrappedBootstrap(proto.Clone(bootstrap.Proto()))
+	if err != nil {
+		return errors.Wrap(err, "could not clone light client bootstrap")
+	}
+	syncCommitteeHash, err := bootstrapCopy.CurrentSyncCommittee().HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not hash current sync committee")
+	}
+
 	return s.db.Update(func(tx *bolt.Tx) error {
+		syncCommitteeBucket := tx.Bucket(lightClientSyncCommitteeBucket)
+		syncCommitteeAlreadyExists := syncCommitteeBucket.Get(syncCommitteeHash[:]) != nil
+		if !syncCommitteeAlreadyExists {
+			enc, err := bootstrapCopy.CurrentSyncCommittee().MarshalSSZ()
+			if err != nil {
+				return errors.Wrap(err, "could not marshal current sync committee")
+			}
+			if err := syncCommitteeBucket.Put(syncCommitteeHash[:], enc); err != nil {
+				return errors.Wrap(err, "could not save current sync committee")
+			}
+		}
+
+		err = bootstrapCopy.SetCurrentSyncCommittee(createEmptySyncCommittee())
+		if err != nil {
+			return errors.Wrap(err, "could not set current sync committee to zero while saving")
+		}
+
 		bkt := tx.Bucket(lightClientBootstrapBucket)
-		enc, err := encodeLightClientBootstrap(bootstrap)
+		enc, err := encodeLightClientBootstrap(bootstrapCopy, syncCommitteeHash)
 		if err != nil {
 			return err
 		}
@@ -50,20 +78,49 @@ func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot []byte) (int
 	defer span.End()
 
 	var bootstrap interfaces.LightClientBootstrap
+	var syncCommitteeHash []byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(lightClientBootstrapBucket)
+		syncCommitteeBucket := tx.Bucket(lightClientSyncCommitteeBucket)
 		enc := bkt.Get(blockRoot)
 		if enc == nil {
 			return nil
 		}
 		var err error
-		bootstrap, err = decodeLightClientBootstrap(enc)
+		bootstrap, syncCommitteeHash, err = decodeLightClientBootstrap(enc)
+		if err != nil {
+			return errors.Wrap(err, "could not decode light client bootstrap")
+		}
+		var syncCommitteeBytes = syncCommitteeBucket.Get(syncCommitteeHash)
+		if syncCommitteeBytes == nil {
+			return errors.New("sync committee not found")
+		}
+		syncCommittee := &ethpb.SyncCommittee{}
+		if err := syncCommittee.UnmarshalSSZ(syncCommitteeBytes); err != nil {
+			return errors.Wrap(err, "could not unmarshal sync committee")
+		}
+		err = bootstrap.SetCurrentSyncCommittee(syncCommittee)
+		if err != nil {
+			return errors.Wrap(err, "could not set current sync committee while retrieving")
+		}
 		return err
 	})
 	return bootstrap, err
 }
 
-func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]byte, error) {
+func createEmptySyncCommittee() *ethpb.SyncCommittee {
+	syncCom := make([][]byte, params.BeaconConfig().SyncCommitteeSize)
+	for i := 0; uint64(i) < params.BeaconConfig().SyncCommitteeSize; i++ {
+		syncCom[i] = make([]byte, fieldparams.BLSPubkeyLength)
+	}
+
+	return &ethpb.SyncCommittee{
+		Pubkeys:         syncCom,
+		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
+	}
+}
+
+func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap, syncCommitteeHash [32]byte) ([]byte, error) {
 	key, err := keyForLightClientUpdate(bootstrap.Version())
 	if err != nil {
 		return nil, err
@@ -72,48 +129,56 @@ func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]by
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal light client bootstrap")
 	}
-	fullEnc := make([]byte, len(key)+len(enc))
+	fullEnc := make([]byte, len(key)+32+len(enc))
 	copy(fullEnc, key)
-	copy(fullEnc[len(key):], enc)
-	return snappy.Encode(nil, fullEnc), nil
+	copy(fullEnc[len(key):len(key)+32], syncCommitteeHash[:])
+	copy(fullEnc[len(key)+32:], enc)
+	compressedEnc := snappy.Encode(nil, fullEnc)
+	return compressedEnc, nil
 }
 
-func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, error) {
+func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, []byte, error) {
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not snappy decode light client bootstrap")
+		return nil, nil, errors.Wrap(err, "could not snappy decode light client bootstrap")
 	}
 	var m proto.Message
+	var syncCommitteeHash []byte
 	switch {
 	case hasAltairKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapAltair{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Altair light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(altairKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Altair light client bootstrap")
 		}
 		m = bootstrap
+		syncCommitteeHash = enc[len(altairKey) : len(altairKey)+32]
 	case hasCapellaKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapCapella{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Capella light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Capella light client bootstrap")
 		}
 		m = bootstrap
+		syncCommitteeHash = enc[len(capellaKey) : len(capellaKey)+32]
 	case hasDenebKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapDeneb{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(denebKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Deneb light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(denebKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Deneb light client bootstrap")
 		}
 		m = bootstrap
+		syncCommitteeHash = enc[len(denebKey) : len(denebKey)+32]
 	case hasElectraKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapElectra{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(electraKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
 		}
 		m = bootstrap
+		syncCommitteeHash = enc[len(electraKey) : len(electraKey)+32]
 	default:
-		return nil, errors.New("decoding of saved light client bootstrap is unsupported")
+		return nil, nil, errors.New("decoding of saved light client bootstrap is unsupported")
 	}
-	return light_client.NewWrappedBootstrap(m)
+	bootstrap, err := light_client.NewWrappedBootstrap(m)
+	return bootstrap, syncCommitteeHash, err
 }
 
 func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error) {