Update block's commitment size

beacon-chain/db/kv/BUILD.bazel

@@ -39,6 +39,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/blob.go

@@ -7,6 +7,7 @@ import (
 	"sort"
 
 	"github.com/pkg/errors"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
@@ -71,8 +72,8 @@ func (s *Store) verifySideCars(scs []*ethpb.BlobSidecar) error {
 	if len(scs) == 0 {
 		return errors.New("nil or empty blob sidecars")
 	}
-	if uint64(len(scs)) > params.BeaconConfig().MaxBlobsPerBlock {
-		return fmt.Errorf("too many sidecars: %d > %d", len(scs), params.BeaconConfig().MaxBlobsPerBlock)
+	if uint64(len(scs)) > fieldparams.MaxBlobsPerBlock {
+		return fmt.Errorf("too many sidecars: %d > %d", len(scs), fieldparams.MaxBlobsPerBlock)
 	}
 
 	sl := scs[0].Slot

beacon-chain/db/kv/blob_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
+	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
@@ -63,18 +64,18 @@ func TestStore_BlobSidecars(t *testing.T) {
 	})
 	t.Run("save and retrieve by root (max)", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
 		require.NoError(t, equalBlobSlices(scs, got))
 	})
 	t.Run("save and retrieve valid subset by root", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 
 		// we'll request indices 0 and 3, so make a slice with those indices for comparison
 		expect := make([]*ethpb.BlobSidecar, 2)
@@ -89,9 +90,9 @@ func TestStore_BlobSidecars(t *testing.T) {
 	})
 	t.Run("error for invalid index when retrieving by root", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 
 		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot), uint64(len(scs)))
 		require.ErrorIs(t, err, ErrNotFound)
@@ -108,18 +109,18 @@ func TestStore_BlobSidecars(t *testing.T) {
 	})
 	t.Run("save and retrieve by slot (max)", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot)
 		require.NoError(t, err)
 		require.NoError(t, equalBlobSlices(scs, got))
 	})
 	t.Run("save and retrieve valid subset by slot", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 
 		// we'll request indices 0 and 3, so make a slice with those indices for comparison
 		expect := make([]*ethpb.BlobSidecar, 2)
@@ -135,19 +136,19 @@ func TestStore_BlobSidecars(t *testing.T) {
 	})
 	t.Run("error for invalid index when retrieving by slot", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 
 		got, err := db.BlobSidecarsBySlot(ctx, scs[0].Slot, uint64(len(scs)))
 		require.ErrorIs(t, err, ErrNotFound)
 		require.Equal(t, 0, len(got))
 	})
 	t.Run("delete works", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
 		require.NoError(t, equalBlobSlices(scs, got))
@@ -158,25 +159,25 @@ func TestStore_BlobSidecars(t *testing.T) {
 	})
 	t.Run("saving a blob with older slot", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(scs[0].BlockRoot))
 		require.NoError(t, err)
 		require.NoError(t, equalBlobSlices(scs, got))
 		require.ErrorContains(t, "but already have older blob with slot", db.SaveBlobSidecar(ctx, scs))
 	})
 	t.Run("saving a new blob for rotation", func(t *testing.T) {
 		db := setupDB(t)
-		scs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		scs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		require.NoError(t, db.SaveBlobSidecar(ctx, scs))
-		require.Equal(t, int(params.BeaconConfig().MaxBlobsPerBlock), len(scs))
+		require.Equal(t, int(fieldparams.MaxBlobsPerBlock), len(scs))
 		oldBlockRoot := scs[0].BlockRoot
 		got, err := db.BlobSidecarsByRoot(ctx, bytesutil.ToBytes32(oldBlockRoot))
 		require.NoError(t, err)
 		require.NoError(t, equalBlobSlices(scs, got))
 
-		newScs := generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock)
+		newScs := generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock)
 		newRetentionSlot := primitives.Slot(params.BeaconNetworkConfig().MinEpochsForBlobsSidecarsRequest.Mul(uint64(params.BeaconConfig().SlotsPerEpoch)))
 		for _, sc := range newScs {
 			sc.Slot = sc.Slot + newRetentionSlot
@@ -231,7 +232,7 @@ func TestStore_verifySideCars(t *testing.T) {
 		error string
 	}{
 		{name: "empty", scs: []*ethpb.BlobSidecar{}, error: "nil or empty blob sidecars"},
-		{name: "too many sidecars", scs: generateBlobSidecars(t, params.BeaconConfig().MaxBlobsPerBlock+1), error: "too many sidecars: 5 > 4"},
+		{name: "too many sidecars", scs: generateBlobSidecars(t, fieldparams.MaxBlobsPerBlock+1), error: "too many sidecars: 5 > 4"},
 		{name: "invalid slot", scs: []*ethpb.BlobSidecar{{Slot: 1}, {Slot: 2}}, error: "sidecar slot mismatch: 2 != 1"},
 		{name: "invalid proposer index", scs: []*ethpb.BlobSidecar{{ProposerIndex: 1}, {ProposerIndex: 2}}, error: "sidecar proposer index mismatch: 2 != 1"},
 		{name: "invalid root", scs: []*ethpb.BlobSidecar{{BlockRoot: []byte{1}}, {BlockRoot: []byte{2}}}, error: "sidecar root mismatch: 02 != 01"},

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

@@ -141,7 +141,7 @@ func TestGetSpec(t *testing.T) {
 	resp, err := server.GetSpec(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.Equal(t, 112, len(resp.Data))
+	assert.Equal(t, 111, len(resp.Data))
 	for k, v := range resp.Data {
 		switch k {
 		case "CONFIG_NAME":
@@ -378,6 +378,8 @@ func TestGetSpec(t *testing.T) {
 			assert.Equal(t, "2", v)
 		case "REORG_WEIGHT_THRESHOLD":
 			assert.Equal(t, "20", v)
+		case "REORG_PARENT_WEIGHT_THRESHOLD":
+			assert.Equal(t, "160", v)
 		case "SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY":
 		default:
 			t.Errorf("Incorrect key: %s", k)

config/fieldparams/mainnet.go

@@ -26,5 +26,7 @@ const (
 	SyncCommitteeAggregationBytesLength   = 16            // SyncCommitteeAggregationBytesLength defines the length of sync committee aggregate bytes.
 	SyncAggregateSyncCommitteeBytesLength = 64            // SyncAggregateSyncCommitteeBytesLength defines the length of sync committee bytes in a sync aggregate.
 	MaxWithdrawalsPerPayload              = 16            // MaxWithdrawalsPerPayloadLength defines the maximum number of withdrawals that can be included in a payload.
+	MaxBlobsPerBlock                      = 4             // MaxBlobsPerBlock defines the maximum number of blobs with respect to consensus rule can be included in a block.
+	MaxBlobCommitmentsPerBlock            = 4096          // MaxBlobCommitmentsPerBlock defines the theoretical limit of blobs can be included in a block.
 	BlobLength                            = 131072        // BlobLength defines the byte length of a blob.
 )

config/fieldparams/minimal.go

@@ -26,5 +26,7 @@ const (
 	SyncCommitteeAggregationBytesLength   = 1             // SyncCommitteeAggregationBytesLength defines the sync committee aggregate bytes.
 	SyncAggregateSyncCommitteeBytesLength = 4             // SyncAggregateSyncCommitteeBytesLength defines the length of sync committee bytes in a sync aggregate.
 	MaxWithdrawalsPerPayload              = 4             // MaxWithdrawalsPerPayloadLength defines the maximum number of withdrawals that can be included in a payload.
+	MaxBlobsPerBlock                      = 4             // MaxBlobsPerBlock defines the maximum number of blobs with respect to consensus rule can be included in a block.
+	MaxBlobCommitmentsPerBlock            = 16            // MaxBlobCommitmentsPerBlock defines the theoretical limit of blobs can be included in a block.
 	BlobLength                            = 4             // BlobLength defines the byte length of a blob.
 )

config/params/config.go

@@ -105,7 +105,6 @@ type BeaconChainConfig struct {
 	MaxWithdrawalsPerPayload         uint64 `yaml:"MAX_WITHDRAWALS_PER_PAYLOAD" spec:"true"`          // MaxWithdrawalsPerPayload defines the maximum number of withdrawals in a block.
 	MaxBlsToExecutionChanges         uint64 `yaml:"MAX_BLS_TO_EXECUTION_CHANGES" spec:"true"`         // MaxBlsToExecutionChanges defines the maximum number of BLS-to-execution-change objects in a block.
 	MaxValidatorsPerWithdrawalsSweep uint64 `yaml:"MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP" spec:"true"` // MaxValidatorsPerWithdrawalsSweep bounds the size of the sweep searching for withdrawals per slot.
-	MaxBlobsPerBlock                 uint64 `yaml:"MAX_BLOBS_PER_BLOCK" spec:"true"`                  // MaxBlobsPerBlock defines the maximum number of blobs in a block.
 
 	// BLS domain values.
 	DomainBeaconProposer              [4]byte `yaml:"DOMAIN_BEACON_PROPOSER" spec:"true"`                // DomainBeaconProposer defines the BLS signature domain for beacon proposal verification.

config/params/loader_test.go

@@ -20,8 +20,7 @@ import (
 
 // Variables defined in the placeholderFields will not be tested in `TestLoadConfigFile`.
 // These are variables that we don't use in Prysm. (i.e. future hardfork, light client... etc)
-var placeholderFields = []string{"UPDATE_TIMEOUT", "DENEB_FORK_EPOCH", "DENEB_FORK_VERSION",
-	"ATTESTATION_SUBNET_EXTRA_BITS", "RESP_TIMEOUT", "MAX_REQUEST_BLOCKS", "EPOCHS_PER_SUBNET_SUBSCRIPTION",
+var placeholderFields = []string{"UPDATE_TIMEOUT", "ATTESTATION_SUBNET_EXTRA_BITS", "RESP_TIMEOUT", "MAX_REQUEST_BLOCKS", "EPOCHS_PER_SUBNET_SUBSCRIPTION",
 	"EIP6110_FORK_EPOCH", "MESSAGE_DOMAIN_INVALID_SNAPPY", "MIN_EPOCHS_FOR_BLOCK_REQUESTS", "MAXIMUM_GOSSIP_CLOCK_DISPARITY",
 	"MESSAGE_DOMAIN_VALID_SNAPPY", "GOSSIP_MAX_SIZE", "SUBNETS_PER_NODE", "ATTESTATION_SUBNET_COUNT",
 	"MAX_CHUNK_SIZE", "ATTESTATION_PROPAGATION_SLOT_RANGE", "ATTESTATION_SUBNET_PREFIX_BITS", "EIP6110_FORK_VERSION", "TTFB_TIMEOUT"}

config/params/mainnet_config.go

@@ -161,7 +161,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxWithdrawalsPerPayload:         16,
 	MaxBlsToExecutionChanges:         16,
 	MaxValidatorsPerWithdrawalsSweep: 16384,
-	MaxBlobsPerBlock:                 4,
 
 	// BLS domain values.
 	DomainBeaconProposer:              bytesutil.Uint32ToBytes4(0x00000000),