Sort by descending

api/client/builder/client.go

@@ -241,7 +241,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 		return nil, errors.Wrap(err, "error getting header from builder server")
 	}
 
-	bid, err := c.parseHeaderResponse(data, header)
+	bid, err := c.parseHeaderResponse(data, header, slot)
 	if err != nil {
 		return nil, errors.Wrapf(
 			err,
@@ -254,7 +254,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 	return bid, nil
 }
 
-func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid, error) {
+func (c *Client) parseHeaderResponse(data []byte, header http.Header, slot primitives.Slot) (SignedBid, error) {
 	var versionHeader string
 	if c.sszEnabled || header.Get(api.VersionHeader) != "" {
 		versionHeader = header.Get(api.VersionHeader)
@@ -276,7 +276,7 @@ func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid
 	}
 
 	if ver >= version.Electra {
-		return c.parseHeaderElectra(data)
+		return c.parseHeaderElectra(data, slot)
 	}
 	if ver >= version.Deneb {
 		return c.parseHeaderDeneb(data)
@@ -291,7 +291,7 @@ func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid
 	return nil, fmt.Errorf("unsupported header version %s", versionHeader)
 }
 
-func (c *Client) parseHeaderElectra(data []byte) (SignedBid, error) {
+func (c *Client) parseHeaderElectra(data []byte, slot primitives.Slot) (SignedBid, error) {
 	if c.sszEnabled {
 		sb := &ethpb.SignedBuilderBidElectra{}
 		if err := sb.UnmarshalSSZ(data); err != nil {
@@ -303,7 +303,7 @@ func (c *Client) parseHeaderElectra(data []byte) (SignedBid, error) {
 	if err := json.Unmarshal(data, hr); err != nil {
 		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponseElectra JSON")
 	}
-	p, err := hr.ToProto()
+	p, err := hr.ToProto(slot)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert ExecHeaderResponseElectra to proto")
 	}

api/client/builder/client_test.go

@@ -532,7 +532,7 @@ func TestClient_GetHeader(t *testing.T) {
 				require.Equal(t, expectedPath, r.URL.Path)
 				epr := &ExecHeaderResponseElectra{}
 				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseElectra), epr))
-				pro, err := epr.ToProto()
+				pro, err := epr.ToProto(100)
 				require.NoError(t, err)
 				ssz, err := pro.MarshalSSZ()
 				require.NoError(t, err)

api/client/builder/types.go

@@ -1284,8 +1284,8 @@ type ExecHeaderResponseElectra struct {
 }
 
 // ToProto creates a SignedBuilderBidElectra Proto from ExecHeaderResponseElectra.
-func (ehr *ExecHeaderResponseElectra) ToProto() (*eth.SignedBuilderBidElectra, error) {
-	bb, err := ehr.Data.Message.ToProto()
+func (ehr *ExecHeaderResponseElectra) ToProto(slot types.Slot) (*eth.SignedBuilderBidElectra, error) {
+	bb, err := ehr.Data.Message.ToProto(slot)
 	if err != nil {
 		return nil, err
 	}
@@ -1296,13 +1296,14 @@ func (ehr *ExecHeaderResponseElectra) ToProto() (*eth.SignedBuilderBidElectra, e
 }
 
 // ToProto creates a BuilderBidElectra Proto from BuilderBidElectra.
-func (bb *BuilderBidElectra) ToProto() (*eth.BuilderBidElectra, error) {
+func (bb *BuilderBidElectra) ToProto(slot types.Slot) (*eth.BuilderBidElectra, error) {
 	header, err := bb.Header.ToProto()
 	if err != nil {
 		return nil, err
 	}
-	if len(bb.BlobKzgCommitments) > params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra) {
-		return nil, fmt.Errorf("blob commitment count %d exceeds the maximum %d", len(bb.BlobKzgCommitments), params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra))
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	if len(bb.BlobKzgCommitments) > maxBlobsPerBlock {
+		return nil, fmt.Errorf("blob commitment count %d exceeds the maximum %d", len(bb.BlobKzgCommitments), maxBlobsPerBlock)
 	}
 	kzgCommitments := make([][]byte, len(bb.BlobKzgCommitments))
 	for i, commit := range bb.BlobKzgCommitments {

beacon-chain/core/transition/BUILD.bazel

@@ -46,6 +46,7 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/core/transition/transition.go

@@ -27,7 +27,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	prysmTrace "github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -291,6 +293,8 @@ func ProcessSlotsCore(ctx context.Context, span trace.Span, state state.BeaconSt
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "failed to upgrade state")
 		}
+
+		logBlobLimitIncrease(state.Slot())
 	}
 	return state, nil
 }
@@ -507,3 +511,19 @@ func ProcessEpochPrecompute(ctx context.Context, state state.BeaconState) (state
 	}
 	return state, nil
 }
+
+func logBlobLimitIncrease(slot primitives.Slot) {
+	if !slots.IsEpochStart(slot) {
+		return
+	}
+
+	epoch := slots.ToEpoch(slot)
+	for _, entry := range params.BeaconConfig().BlobSchedule {
+		if entry.Epoch == epoch {
+			log.WithFields(logrus.Fields{
+				"epoch":     epoch,
+				"blobLimit": entry.MaxBlobsPerBlock,
+			}).Info("Blob limit updated")
+		}
+	}
+}

beacon-chain/rpc/eth/blob/handlers_test.go

@@ -265,7 +265,7 @@ func TestBlobs(t *testing.T) {
 		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("blob index over max", func(t *testing.T) {
-		overLimit := params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Deneb)
+		overLimit := maxBlobsPerBlockByVersion(version.Deneb)
 		u := fmt.Sprintf("http://foo.example/123?indices=%d", overLimit)
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
@@ -412,10 +412,14 @@ func TestBlobs_Electra(t *testing.T) {
 	cfg := params.BeaconConfig().Copy()
 	cfg.DenebForkEpoch = 0
 	cfg.ElectraForkEpoch = 1
+	cfg.BlobSchedule = []params.BlobScheduleEntry{
+		{Epoch: 0, MaxBlobsPerBlock: 6},
+		{Epoch: 1, MaxBlobsPerBlock: 9},
+	}
 	params.OverrideBeaconConfig(cfg)
 
 	db := testDB.SetupDB(t)
-	electraBlock, blobs := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, 123, params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra))
+	electraBlock, blobs := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, 123, maxBlobsPerBlockByVersion(version.Electra))
 	require.NoError(t, db.SaveBlock(context.Background(), electraBlock))
 	bs := filesystem.NewEphemeralBlobStorage(t)
 	testSidecars := verification.FakeVerifySliceForTest(t, blobs)
@@ -451,7 +455,7 @@ func TestBlobs_Electra(t *testing.T) {
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra), len(resp.Data))
+		require.Equal(t, maxBlobsPerBlockByVersion(version.Electra), len(resp.Data))
 		sidecar := resp.Data[0]
 		require.NotNil(t, sidecar)
 		assert.Equal(t, "0", sidecar.Index)
@@ -464,7 +468,7 @@ func TestBlobs_Electra(t *testing.T) {
 		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("requested blob index at max", func(t *testing.T) {
-		limit := params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra) - 1
+		limit := maxBlobsPerBlockByVersion(version.Electra) - 1
 		u := fmt.Sprintf("http://foo.example/123?indices=%d", limit)
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
@@ -496,7 +500,7 @@ func TestBlobs_Electra(t *testing.T) {
 		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("blob index over max", func(t *testing.T) {
-		overLimit := params.BeaconConfig().MaxBlobsPerBlockByVersion(version.Electra)
+		overLimit := maxBlobsPerBlockByVersion(version.Electra)
 		u := fmt.Sprintf("http://foo.example/123?indices=%d", overLimit)
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
@@ -554,3 +558,11 @@ func Test_parseIndices(t *testing.T) {
 		})
 	}
 }
+
+func maxBlobsPerBlockByVersion(v int) int {
+	if v >= version.Electra {
+		return params.BeaconConfig().DeprecatedMaxBlobsPerBlockElectra
+	}
+
+	return params.BeaconConfig().DeprecatedMaxBlobsPerBlock
+}

changelog/tt_corn.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add blob schedule support from https://github.com/ethereum/consensus-specs/pull/4277

config/params/BUILD.bazel

@@ -73,7 +73,6 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
-        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

config/params/config.go

@@ -3,6 +3,7 @@ package params
 
 import (
 	"math"
+	"slices"
 	"time"
 
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -295,6 +296,7 @@ type BeaconChainConfig struct {
 	NodeIdBits                      uint64          `yaml:"NODE_ID_BITS" spec:"true"`                       // NodeIdBits defines the bit length of a node id.
 
 	// Blobs Values
+	BlobSchedule []BlobScheduleEntry `yaml:"BLOB_SCHEDULE"`
 
 	// Deprecated_MaxBlobsPerBlock defines the max blobs that could exist in a block.
 	// Deprecated: This field is no longer supported. Avoid using it.
@@ -313,6 +315,11 @@ type BeaconChainConfig struct {
 	DeprecatedMaxBlobsPerBlockFulu int `yaml:"MAX_BLOBS_PER_BLOCK_FULU" spec:"true"`
 }
 
+type BlobScheduleEntry struct {
+	Epoch            primitives.Epoch `yaml:"EPOCH"`
+	MaxBlobsPerBlock uint64           `yaml:"MAX_BLOBS_PER_BLOCK"`
+}
+
 // InitializeForkSchedule initializes the schedules forks baked into the config.
 func (b *BeaconChainConfig) InitializeForkSchedule() {
 	// Reset Fork Version Schedule.
@@ -400,14 +407,22 @@ func (b *BeaconChainConfig) TargetBlobsPerBlock(slot primitives.Slot) int {
 	return b.DeprecatedMaxBlobsPerBlock / 2
 }
 
-// MaxBlobsPerBlock returns the maximum number of blobs per block for the given slot.
 func (b *BeaconChainConfig) MaxBlobsPerBlock(slot primitives.Slot) int {
 	epoch := primitives.Epoch(slot.DivSlot(b.SlotsPerEpoch))
 
-	if epoch >= b.FuluForkEpoch {
-		return b.DeprecatedMaxBlobsPerBlockFulu
+	if len(b.BlobSchedule) > 0 {
+		slices.SortFunc(b.BlobSchedule, func(a, b BlobScheduleEntry) int {
+			return int(b.Epoch - a.Epoch)
+		})
+
+		for i := len(b.BlobSchedule) - 1; i >= 0; i-- {
+			if epoch >= b.BlobSchedule[i].Epoch {
+				return int(b.BlobSchedule[i].MaxBlobsPerBlock)
+			}
+		}
 	}
 
+	// If the blob schedule is empty, we fall back to the deprecated value.
 	if epoch >= b.ElectraForkEpoch {
 		return b.DeprecatedMaxBlobsPerBlockElectra
 	}
@@ -415,26 +430,21 @@ func (b *BeaconChainConfig) MaxBlobsPerBlock(slot primitives.Slot) int {
 	return b.DeprecatedMaxBlobsPerBlock
 }
 
-// MaxBlobsPerBlockByVersion returns the maximum number of blobs per block for the given fork version
-func (b *BeaconChainConfig) MaxBlobsPerBlockByVersion(v int) int {
-	if v >= version.Fulu {
-		return b.DeprecatedMaxBlobsPerBlockFulu
-	}
-
-	if v >= version.Electra {
-		return b.DeprecatedMaxBlobsPerBlockElectra
-	}
-
-	return b.DeprecatedMaxBlobsPerBlock
-}
-
-// MaxBlobsPerBlockByEpoch returns the maximum number of blobs per block for the given epoch,
-// adjusting for the Electra fork.
+// MaxBlobsPerBlockAtEpoch returns the maximum number of blobs per block for the given epoch
 func (b *BeaconChainConfig) MaxBlobsPerBlockAtEpoch(epoch primitives.Epoch) int {
-	if epoch >= b.FuluForkEpoch {
-		return b.DeprecatedMaxBlobsPerBlockFulu
+	if len(b.BlobSchedule) > 0 {
+		slices.SortFunc(b.BlobSchedule, func(a, b BlobScheduleEntry) int {
+			return int(b.Epoch - a.Epoch)
+		})
+
+		for i := len(b.BlobSchedule) - 1; i >= 0; i-- {
+			if epoch >= b.BlobSchedule[i].Epoch {
+				return int(b.BlobSchedule[i].MaxBlobsPerBlock)
+			}
+		}
 	}
 
+	// If the blob schedule is empty, we fall back to the deprecated value.
 	if epoch >= b.ElectraForkEpoch {
 		return b.DeprecatedMaxBlobsPerBlockElectra
 	}

config/params/config_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 )
 
@@ -108,12 +107,44 @@ func TestConfigGenesisValidatorRoot(t *testing.T) {
 	}
 }
 
-func Test_MaxBlobCount(t *testing.T) {
-	cfg := params.MainnetConfig()
-	cfg.ElectraForkEpoch = 10
-	require.Equal(t, cfg.MaxBlobsPerBlock(primitives.Slot(cfg.ElectraForkEpoch)*cfg.SlotsPerEpoch-1), 6)
-	require.Equal(t, cfg.MaxBlobsPerBlock(primitives.Slot(cfg.ElectraForkEpoch)*cfg.SlotsPerEpoch), 9)
-	cfg.ElectraForkEpoch = math.MaxUint64
+func TestMaxBlobsPerBlock(t *testing.T) {
+	t.Run("Before all forks and no BlobSchedule", func(t *testing.T) {
+		cfg := params.MainnetConfig()
+		cfg.BlobSchedule = nil
+		cfg.ElectraForkEpoch = 100
+		cfg.FuluForkEpoch = 200
+		require.Equal(t, cfg.MaxBlobsPerBlock(0), cfg.DeprecatedMaxBlobsPerBlock)
+	})
+
+	t.Run("Uses latest matching BlobSchedule entry", func(t *testing.T) {
+		cfg := params.MainnetConfig()
+		cfg.BlobSchedule = []params.BlobScheduleEntry{
+			{Epoch: 5, MaxBlobsPerBlock: 7},
+			{Epoch: 10, MaxBlobsPerBlock: 11},
+		}
+		slot := 11 * cfg.SlotsPerEpoch
+		require.Equal(t, cfg.MaxBlobsPerBlock(slot), 11)
+	})
+
+	t.Run("Uses earlier matching BlobSchedule entry", func(t *testing.T) {
+		cfg := params.MainnetConfig()
+		cfg.BlobSchedule = []params.BlobScheduleEntry{
+			{Epoch: 5, MaxBlobsPerBlock: 7},
+			{Epoch: 10, MaxBlobsPerBlock: 11},
+		}
+		slot := 6 * cfg.SlotsPerEpoch
+		require.Equal(t, cfg.MaxBlobsPerBlock(slot), 7)
+	})
+
+	t.Run("Before first BlobSchedule entry falls back to fork logic", func(t *testing.T) {
+		cfg := params.MainnetConfig()
+		cfg.FuluForkEpoch = 1
+		cfg.BlobSchedule = []params.BlobScheduleEntry{
+			{Epoch: 5, MaxBlobsPerBlock: 7},
+		}
+		slot := primitives.Slot(2) // Epoch 0
+		require.Equal(t, cfg.MaxBlobsPerBlock(slot), cfg.DeprecatedMaxBlobsPerBlock)
+	})
 }
 
 func Test_TargetBlobCount(t *testing.T) {
@@ -123,41 +154,3 @@ func Test_TargetBlobCount(t *testing.T) {
 	require.Equal(t, cfg.TargetBlobsPerBlock(primitives.Slot(cfg.ElectraForkEpoch)*cfg.SlotsPerEpoch), 6)
 	cfg.ElectraForkEpoch = math.MaxUint64
 }
-
-func TestMaxBlobsPerBlockByVersion(t *testing.T) {
-	tests := []struct {
-		name string
-		v    int
-		want int
-	}{
-		{
-			name: "Version below Electra",
-			v:    version.Electra - 1,
-			want: params.BeaconConfig().DeprecatedMaxBlobsPerBlock,
-		},
-		{
-			name: "Version equal to Electra",
-			v:    version.Electra,
-			want: params.BeaconConfig().DeprecatedMaxBlobsPerBlockElectra,
-		},
-		{
-			name: "Version equal to Fulu",
-			v:    version.Fulu,
-			want: params.BeaconConfig().DeprecatedMaxBlobsPerBlockFulu,
-		},
-		{
-			name: "Version above Fulu",
-			v:    version.Fulu + 1,
-			want: params.BeaconConfig().DeprecatedMaxBlobsPerBlockFulu,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := params.BeaconConfig().MaxBlobsPerBlockByVersion(tt.v)
-			if got != tt.want {
-				t.Errorf("MaxBlobsPerBlockByVersion(%d) = %d, want %d", tt.v, got, tt.want)
-			}
-		})
-	}
-}

config/params/loader.go

@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"os"
+	"strconv"
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -244,6 +245,16 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("MAX_BLOBS_PER_BLOCK_FULU: %d", cfg.DeprecatedMaxBlobsPerBlockFulu),
 	}
 
+	if len(cfg.BlobSchedule) > 0 {
+		lines = append(lines, "BLOB_SCHEDULE:")
+		for _, entry := range cfg.BlobSchedule {
+			lines = append(lines,
+				"  - EPOCH: "+strconv.FormatUint(uint64(entry.Epoch), 10),
+				"    MAX_BLOBS_PER_BLOCK: "+strconv.FormatUint(entry.MaxBlobsPerBlock, 10),
+			)
+		}
+	}
+
 	yamlFile := []byte(strings.Join(lines, "\n"))
 	return yamlFile
 }

config/params/loader_test.go

@@ -25,7 +25,6 @@ import (
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
 	"ATTESTATION_DEADLINE",
-	"BLOB_SCHEDULE",
 	"BLOB_SIDECAR_SUBNET_COUNT_FULU",
 	"EIP6110_FORK_EPOCH",
 	"EIP6110_FORK_VERSION",

config/params/mainnet_config.go

@@ -339,6 +339,11 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	AttestationSubnetPrefixBits:     6,
 	SubnetsPerNode:                  2,
 	NodeIdBits:                      256,
+
+	BlobSchedule: []BlobScheduleEntry{
+		{Epoch: 269568, MaxBlobsPerBlock: 6},
+		{Epoch: 364032, MaxBlobsPerBlock: 9},
+	},
 }
 
 // MainnetTestConfig provides a version of the mainnet config that has a different name

config/params/minimal_config.go

@@ -127,6 +127,11 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ConfigName = MinimalName
 	minimalConfig.PresetBase = "minimal"
 
+	minimalConfig.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 18446744073709551615, MaxBlobsPerBlock: 6},
+		{Epoch: 18446744073709551615, MaxBlobsPerBlock: 9},
+	}
+
 	minimalConfig.InitializeForkSchedule()
 	return minimalConfig
 }

config/params/testdata/e2e_config.yaml

@@ -124,4 +124,13 @@ SLOTS_PER_EPOCH: 6
 EPOCHS_PER_ETH1_VOTING_PERIOD: 2
 MAX_SEED_LOOKAHEAD: 1
 
+# Blob Scheduling
+# ---------------------------------------------------------------
 
+BLOB_SCHEDULE:
+  # Deneb
+  - EPOCH: 12
+    MAX_BLOBS_PER_BLOCK: 6
+  # Electra
+  - EPOCH: 14
+    MAX_BLOBS_PER_BLOCK: 9

config/params/testnet_e2e_config.go

@@ -60,6 +60,11 @@ func E2ETestConfig() *BeaconChainConfig {
 	e2eConfig.ElectraForkVersion = []byte{5, 0, 0, 253}
 	e2eConfig.FuluForkVersion = []byte{6, 0, 0, 253}
 
+	e2eConfig.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 12, MaxBlobsPerBlock: 6},
+		{Epoch: 14, MaxBlobsPerBlock: 9},
+	}
+
 	e2eConfig.InitializeForkSchedule()
 	return e2eConfig
 }
@@ -109,6 +114,11 @@ func E2EMainnetTestConfig() *BeaconChainConfig {
 	// Deneb changes.
 	e2eConfig.MinPerEpochChurnLimit = 2
 
+	e2eConfig.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 12, MaxBlobsPerBlock: 6},
+		{Epoch: 14, MaxBlobsPerBlock: 9},
+	}
+
 	e2eConfig.InitializeForkSchedule()
 	return e2eConfig
 }

config/params/testnet_holesky_config.go

@@ -46,6 +46,10 @@ func HoleskyConfig() *BeaconChainConfig {
 	cfg.TerminalTotalDifficulty = "0"
 	cfg.DepositContractAddress = "0x4242424242424242424242424242424242424242"
 	cfg.EjectionBalance = 28000000000
+	cfg.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 29696, MaxBlobsPerBlock: 6},
+		{Epoch: 115968, MaxBlobsPerBlock: 9},
+	}
 	cfg.InitializeForkSchedule()
 	return cfg
 }

config/params/testnet_hoodi_config.go

@@ -53,6 +53,10 @@ func HoodiConfig() *BeaconChainConfig {
 	cfg.FuluForkVersion = []byte{0x70, 0x00, 0x09, 0x10}
 	cfg.TerminalTotalDifficulty = "0"
 	cfg.DepositContractAddress = "0x00000000219ab540356cBB839Cbe05303d7705Fa"
+	cfg.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 0, MaxBlobsPerBlock: 6},
+		{Epoch: 2048, MaxBlobsPerBlock: 9},
+	}
 	cfg.InitializeForkSchedule()
 	return cfg
 }

config/params/testnet_sepolia_config.go

@@ -51,6 +51,10 @@ func SepoliaConfig() *BeaconChainConfig {
 	cfg.TerminalTotalDifficulty = "17000000000000000"
 	cfg.DepositContractAddress = "0x7f02C3E3c98b133055B8B348B2Ac625669Ed295D"
 	cfg.DefaultBuilderGasLimit = uint64(60000000)
+	cfg.BlobSchedule = []BlobScheduleEntry{
+		{Epoch: 132608, MaxBlobsPerBlock: 6},
+		{Epoch: 222464, MaxBlobsPerBlock: 9},
+	}
 	cfg.InitializeForkSchedule()
 	return cfg
 }

testing/endtoend/components/web3remotesigner.go

@@ -256,7 +256,13 @@ func (w *Web3RemoteSigner) UnderlyingProcess() *os.Process {
 func createTestnetDir() (string, error) {
 	testNetDir := e2e.TestParams.TestPath + "/web3signer-testnet"
 	configPath := filepath.Join(testNetDir, "config.yaml")
-	rawYaml := params.ConfigToYaml(params.BeaconConfig())
+
+	// TODO: add blob schedule back in as soon as web3signer supports it!
+	configCopy := params.BeaconConfig().Copy()
+	configCopy.BlobSchedule = nil
+	// ---
+
+	rawYaml := params.ConfigToYaml(configCopy)
 
 	// Add in deposit contract in yaml
 	depContractStr := fmt.Sprintf("\nDEPOSIT_CONTRACT_ADDRESS: %s\n", params.BeaconConfig().DepositContractAddress)

testing/spectest/shared/electra/sanity/block_processing.go

@@ -38,7 +38,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
 		t.Run(folder.Name(), func(t *testing.T) {
 			params.SetupTestConfigCleanup(t)
 			cfg := params.BeaconConfig().Copy()
-			cfg.ElectraForkEpoch = 0
+			cfg.BlobSchedule = []params.BlobScheduleEntry{{MaxBlobsPerBlock: 9}}
 			params.OverrideBeaconConfig(cfg)
 
 			helpers.ClearCache()