Remove test artifacts

-exec sed -i '' 's|OffchainLabs/prysm/v6|OffchainLabs/prysm/v7|g' {} +

beacon-chain/execution/BUILD.bazel

@@ -100,7 +100,6 @@ go_test(
     deps = [
         "//async/event:go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
-        "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",

beacon-chain/execution/service_test.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/async/event"
-	chainMock "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache/depositsnapshot"
 	dbutil "github.com/OffchainLabs/prysm/v7/beacon-chain/db/testing"
 	mockExecution "github.com/OffchainLabs/prysm/v7/beacon-chain/execution/testing"
@@ -100,7 +99,7 @@ func TestStart_OK(t *testing.T) {
 	c := startup.NewClockSynchronizer()
 	require.NoError(t, c.SetClock(startup.NewClock(time.Unix(0, 0), [32]byte{})))
 	waiter := verification.NewInitializerWaiter(
-		c, forkchoice.NewROForkChoice(nil), nil, &chainMock.ChainService{})
+		c, forkchoice.NewROForkChoice(nil), nil)
 
 	web3Service, err := NewService(t.Context(),
 		WithHttpEndpoint(endpoint),

beacon-chain/node/node.go

@@ -124,7 +124,6 @@ type BeaconNode struct {
 	DataColumnStorage        *filesystem.DataColumnStorage
 	DataColumnStorageOptions []filesystem.DataColumnStorageOption
 	verifyInitWaiter         *verification.InitializerWaiter
-	lhsp                     *verification.LazyHeadStateProvider
 	syncChecker              *initialsync.SyncChecker
 	slasherEnabled           bool
 	lcStore                  *lightclient.Store
@@ -231,9 +230,8 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		return nil, errors.Wrap(err, "could not start modules")
 	}
 
-	beacon.lhsp = &verification.LazyHeadStateProvider{}
 	beacon.verifyInitWaiter = verification.NewInitializerWaiter(
-		beacon.clockWaiter, forkchoice.NewROForkChoice(beacon.forkChoicer), beacon.stateGen, beacon.lhsp)
+		beacon.clockWaiter, forkchoice.NewROForkChoice(beacon.forkChoicer), beacon.stateGen)
 
 	beacon.BackfillOpts = append(
 		beacon.BackfillOpts,
@@ -751,7 +749,6 @@ func (b *BeaconNode) registerBlockchainService(fc forkchoice.ForkChoicer, gs *st
 	if err != nil {
 		return errors.Wrap(err, "could not register blockchain service")
 	}
-	b.lhsp.HeadStateProvider = blockchainService
 	return b.services.RegisterService(blockchainService)
 }
 

beacon-chain/sync/data_column_sidecars_test.go

@@ -154,7 +154,7 @@ func TestFetchDataColumnSidecars(t *testing.T) {
 	err = gs.SetClock(startup.NewClock(time.Unix(4113849600, 0), [fieldparams.RootLength]byte{}))
 	require.NoError(t, err)
 
-	waiter := verification.NewInitializerWaiter(gs, nil, nil, nil)
+	waiter := verification.NewInitializerWaiter(gs, nil, nil)
 	initializer, err := waiter.WaitForInitializer(t.Context())
 	require.NoError(t, err)
 
@@ -787,7 +787,7 @@ func TestVerifyDataColumnSidecarsByPeer(t *testing.T) {
 		err := gs.SetClock(startup.NewClock(time.Unix(4113849600, 0), [fieldparams.RootLength]byte{}))
 		require.NoError(t, err)
 
-		waiter := verification.NewInitializerWaiter(gs, nil, nil, nil)
+		waiter := verification.NewInitializerWaiter(gs, nil, nil)
 		initializer, err := waiter.WaitForInitializer(t.Context())
 		require.NoError(t, err)
 
@@ -832,7 +832,7 @@ func TestVerifyDataColumnSidecarsByPeer(t *testing.T) {
 		err := gs.SetClock(startup.NewClock(time.Unix(4113849600, 0), [fieldparams.RootLength]byte{}))
 		require.NoError(t, err)
 
-		waiter := verification.NewInitializerWaiter(gs, nil, nil, nil)
+		waiter := verification.NewInitializerWaiter(gs, nil, nil)
 		initializer, err := waiter.WaitForInitializer(t.Context())
 		require.NoError(t, err)
 

beacon-chain/sync/initial-sync/service_test.go

@@ -174,7 +174,7 @@ func TestService_InitStartStop(t *testing.T) {
 				StateNotifier:       &mock.MockStateNotifier{},
 				InitialSyncComplete: make(chan struct{}),
 			})
-			s.verifierWaiter = verification.NewInitializerWaiter(gs, nil, nil, nil)
+			s.verifierWaiter = verification.NewInitializerWaiter(gs, nil, nil)
 			time.Sleep(500 * time.Millisecond)
 			assert.NotNil(t, s)
 			if tt.setGenesis != nil {
@@ -217,7 +217,7 @@ func TestService_waitForStateInitialization(t *testing.T) {
 			counter:      ratecounter.NewRateCounter(counterSeconds * time.Second),
 			genesisChan:  make(chan time.Time),
 		}
-		s.verifierWaiter = verification.NewInitializerWaiter(cs, nil, nil, nil)
+		s.verifierWaiter = verification.NewInitializerWaiter(cs, nil, nil)
 		return s, cs
 	}
 
@@ -786,7 +786,7 @@ func TestFetchOriginColumns(t *testing.T) {
 		err = gs.SetClock(startup.NewClock(time.Unix(4113849600, 0), [fieldparams.RootLength]byte{}))
 		require.NoError(t, err)
 
-		waiter := verification.NewInitializerWaiter(gs, nil, nil, nil)
+		waiter := verification.NewInitializerWaiter(gs, nil, nil)
 		initializer, err := waiter.WaitForInitializer(t.Context())
 		require.NoError(t, err)
 

beacon-chain/sync/rpc_status_test.go

@@ -332,7 +332,7 @@ func TestHandshakeHandlers_Roundtrip(t *testing.T) {
 	markInitSyncComplete(t, r)
 	clock := startup.NewClockSynchronizer()
 	require.NoError(t, clock.SetClock(startup.NewClock(time.Now(), [32]byte{})))
-	r.verifierWaiter = verification.NewInitializerWaiter(clock, chain.ForkChoiceStore, r.cfg.stateGen, chain)
+	r.verifierWaiter = verification.NewInitializerWaiter(clock, chain.ForkChoiceStore, r.cfg.stateGen)
 	p1.Digest, err = r.currentForkDigest()
 	require.NoError(t, err)
 
@@ -354,7 +354,7 @@ func TestHandshakeHandlers_Roundtrip(t *testing.T) {
 	markInitSyncComplete(t, r2)
 	clock = startup.NewClockSynchronizer()
 	require.NoError(t, clock.SetClock(startup.NewClock(time.Now(), [32]byte{})))
-	r2.verifierWaiter = verification.NewInitializerWaiter(clock, chain2.ForkChoiceStore, r2.cfg.stateGen, chain2)
+	r2.verifierWaiter = verification.NewInitializerWaiter(clock, chain2.ForkChoiceStore, r2.cfg.stateGen)
 
 	p2.Digest, err = r.currentForkDigest()
 	require.NoError(t, err)
@@ -948,7 +948,7 @@ func TestStatusRPCRequest_BadPeerHandshake(t *testing.T) {
 	markInitSyncComplete(t, r)
 	clock := startup.NewClockSynchronizer()
 	require.NoError(t, clock.SetClock(startup.NewClock(time.Now(), [32]byte{})))
-	r.verifierWaiter = verification.NewInitializerWaiter(clock, chain.ForkChoiceStore, r.cfg.stateGen, chain)
+	r.verifierWaiter = verification.NewInitializerWaiter(clock, chain.ForkChoiceStore, r.cfg.stateGen)
 
 	go r.Start()
 

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -1847,7 +1847,7 @@ func TestBlockVerifyingState_SameEpochAsParent(t *testing.T) {
 
 	// Create a different head block at a later epoch
 	headBlock := util.NewBeaconBlock()
-	headBlock.Block.Slot = 40                  // Different epoch (epoch 1)
+	headBlock.Block.Slot = 40                 // Different epoch (epoch 1)
 	headBlock.Block.ParentRoot = parentRoot[:] // Head descends from parent
 	util.SaveBlock(t, ctx, db, headBlock)
 	headRoot, err := headBlock.Block.HashTreeRoot()

beacon-chain/sync/validate_bls_to_execution_change_test.go

@@ -433,7 +433,7 @@ func TestService_ValidateBlsToExecutionChange(t *testing.T) {
 				tt.clock = startup.NewClock(time.Now(), [32]byte{})
 			}
 			require.NoError(t, cw.SetClock(tt.clock))
-			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen, chainService)
+			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen)
 			go svc.Start()
 
 			marshalledObj, err := tt.args.msg.MarshalSSZ()

beacon-chain/sync/validate_sync_committee_message_test.go

@@ -411,7 +411,7 @@ func TestService_ValidateSyncCommitteeMessage(t *testing.T) {
 			svc, tt.args.topic, clock = tt.setupSvc(svc, tt.args.msg, tt.args.topic)
 			markInitSyncComplete(t, svc)
 			require.NoError(t, cw.SetClock(clock))
-			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen, chainService)
+			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen)
 			go svc.Start()
 
 			marshalledObj, err := tt.args.msg.MarshalSSZ()

beacon-chain/sync/validate_sync_contribution_proof_test.go

@@ -855,7 +855,7 @@ func TestService_ValidateSyncContributionAndProof(t *testing.T) {
 			var clock *startup.Clock
 			svc, clock = tt.setupSvc(svc, tt.args.msg)
 			require.NoError(t, cw.SetClock(clock))
-			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen, chainService)
+			svc.verifierWaiter = verification.NewInitializerWaiter(cw, chainService.ForkChoiceStore, svc.cfg.stateGen)
 			markInitSyncComplete(t, svc)
 			go svc.Start()
 			marshalledObj, err := tt.args.msg.MarshalSSZ()

beacon-chain/verification/BUILD.bazel

@@ -69,7 +69,6 @@ go_test(
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/verification/blob_test.go

@@ -11,7 +11,6 @@ import (
 	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -627,45 +626,6 @@ func (sbr *mockStateByRooter) StateByRoot(ctx context.Context, root [32]byte) (s
 
 var _ StateByRooter = &mockStateByRooter{}
 
-type mockHeadStateProvider struct {
-	headRoot          []byte
-	headSlot          primitives.Slot
-	headState         state.BeaconState
-	headStateReadOnly state.ReadOnlyBeaconState
-}
-
-func (m *mockHeadStateProvider) HeadRoot(_ context.Context) ([]byte, error) {
-	if m.headRoot != nil {
-		return m.headRoot, nil
-	}
-	root := make([]byte, 32)
-	root[0] = 0xff
-	return root, nil
-}
-
-func (m *mockHeadStateProvider) HeadSlot() primitives.Slot {
-	if m.headSlot == 0 {
-		return 1000
-	}
-	return m.headSlot
-}
-
-func (m *mockHeadStateProvider) HeadState(_ context.Context) (state.BeaconState, error) {
-	if m.headState == nil {
-		return nil, errors.New("head state not available")
-	}
-	return m.headState, nil
-}
-
-func (m *mockHeadStateProvider) HeadStateReadOnly(_ context.Context) (state.ReadOnlyBeaconState, error) {
-	if m.headStateReadOnly == nil {
-		return nil, errors.New("head state read only not available")
-	}
-	return m.headStateReadOnly, nil
-}
-
-var _ HeadStateProvider = &mockHeadStateProvider{}
-
 func sbrErrorIfCalled(t *testing.T) sbrfunc {
 	return func(_ context.Context, _ [32]byte) (state.BeaconState, error) {
 		t.Error("StateByRoot should not have been called")
@@ -683,56 +643,15 @@ func sbrNotFound(t *testing.T, expectedRoot [32]byte) *mockStateByRooter {
 }
 
 func sbrForValOverride(idx primitives.ValidatorIndex, val *ethpb.Validator) *mockStateByRooter {
-	return sbrForValOverrideWithT(nil, idx, val)
-}
-
-func sbrForValOverrideWithT(t testing.TB, idx primitives.ValidatorIndex, val *ethpb.Validator) *mockStateByRooter {
 	return &mockStateByRooter{sbr: func(_ context.Context, root [32]byte) (state.BeaconState, error) {
-		// Use a real deterministic state so that helpers.BeaconProposerIndexAtSlot works correctly
-		numValidators := uint64(idx + 1)
-		if numValidators < 64 {
-			numValidators = 64
-		}
-
-		var st state.BeaconState
-		var err error
-		if t != nil {
-			st, _ = util.DeterministicGenesisStateFulu(t, numValidators)
-		} else {
-			// Fallback for blob tests that don't need the full state
-			return &validxStateOverride{
-				slot: 0,
-				vals: map[primitives.ValidatorIndex]*ethpb.Validator{
-					idx: val,
-				},
-			}, nil
-		}
-
-		// Override the specific validator if provided
-		if val != nil {
-			vals := st.Validators()
-			if idx < primitives.ValidatorIndex(len(vals)) {
-				vals[idx] = val
-				// Ensure the validator is active
-				if vals[idx].ActivationEpoch > 0 {
-					vals[idx].ActivationEpoch = 0
-				}
-				if vals[idx].ExitEpoch == 0 || vals[idx].ExitEpoch < params.BeaconConfig().FarFutureEpoch {
-					vals[idx].ExitEpoch = params.BeaconConfig().FarFutureEpoch
-				}
-				if vals[idx].EffectiveBalance == 0 {
-					vals[idx].EffectiveBalance = params.BeaconConfig().MaxEffectiveBalance
-				}
-				_ = st.SetValidators(vals)
-			}
-		}
-		return st, err
+		return &validxStateOverride{vals: map[primitives.ValidatorIndex]*ethpb.Validator{
+			idx: val,
+		}}, nil
 	}}
 }
 
 type validxStateOverride struct {
 	state.BeaconState
-	slot primitives.Slot
 	vals map[primitives.ValidatorIndex]*ethpb.Validator
 }
 
@@ -746,105 +665,6 @@ func (v *validxStateOverride) ValidatorAtIndex(idx primitives.ValidatorIndex) (*
 	return val, nil
 }
 
-func (v *validxStateOverride) Slot() primitives.Slot {
-	return v.slot
-}
-
-func (v *validxStateOverride) Version() int {
-	// Return Fulu version (6) as default for tests
-	return 6
-}
-
-func (v *validxStateOverride) Validators() []*ethpb.Validator {
-	// Return all validators in the map as a slice
-	maxIdx := primitives.ValidatorIndex(0)
-	for idx := range v.vals {
-		if idx > maxIdx {
-			maxIdx = idx
-		}
-	}
-	// Ensure we have at least 64 validators for a valid beacon state
-	numValidators := maxIdx + 1
-	if numValidators < 64 {
-		numValidators = 64
-	}
-	validators := make([]*ethpb.Validator, numValidators)
-	for i := range validators {
-		if val, ok := v.vals[primitives.ValidatorIndex(i)]; ok {
-			validators[i] = val
-		} else {
-			// Default validator for indices we don't care about
-			validators[i] = &ethpb.Validator{
-				ActivationEpoch:  0,
-				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-			}
-		}
-	}
-	return validators
-}
-
-func (v *validxStateOverride) RandaoMixAtIndex(idx uint64) ([]byte, error) {
-	// Return a zero mix for simplicity in tests
-	return make([]byte, 32), nil
-}
-
-func (v *validxStateOverride) NumValidators() int {
-	return len(v.Validators())
-}
-
-func (v *validxStateOverride) ValidatorAtIndexReadOnly(idx primitives.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	validators := v.Validators()
-	if idx >= primitives.ValidatorIndex(len(validators)) {
-		return nil, fmt.Errorf("validator index %d out of range", idx)
-	}
-	return state_native.NewValidator(validators[idx])
-}
-
-func (v *validxStateOverride) IsNil() bool {
-	return false
-}
-
-func (v *validxStateOverride) LatestBlockHeader() *ethpb.BeaconBlockHeader {
-	// Return a minimal block header for tests
-	return &ethpb.BeaconBlockHeader{
-		Slot:          v.slot,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}
-}
-
-func (v *validxStateOverride) HashTreeRoot(ctx context.Context) ([32]byte, error) {
-	// Return a zero hash for tests
-	return [32]byte{}, nil
-}
-
-func (v *validxStateOverride) UpdateStateRootAtIndex(idx uint64, stateRoot [32]byte) error {
-	// No-op for mock - we don't track state roots
-	return nil
-}
-
-func (v *validxStateOverride) SetLatestBlockHeader(val *ethpb.BeaconBlockHeader) error {
-	// No-op for mock - we don't track block headers
-	return nil
-}
-
-func (v *validxStateOverride) ReadFromEveryValidator(f func(idx int, val state.ReadOnlyValidator) error) error {
-	validators := v.Validators()
-	for i, val := range validators {
-		rov, err := state_native.NewValidator(val)
-		if err != nil {
-			return err
-		}
-		if err := f(i, rov); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 type mockProposerCache struct {
 	ComputeProposerCB func(ctx context.Context, root [32]byte, slot primitives.Slot, pst state.BeaconState) (primitives.ValidatorIndex, error)
 	ProposerCB        func(c *forkchoicetypes.Checkpoint, slot primitives.Slot) (primitives.ValidatorIndex, bool)

beacon-chain/verification/data_column.go

@@ -1,16 +1,13 @@
 package verification
 
 import (
-	"bytes"
 	"context"
 	"crypto/sha256"
 	"fmt"
 	"strings"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -69,12 +66,6 @@ var (
 	errBadTopic       = errors.New("topic is not of the one expected")
 )
 
-type LazyHeadStateProvider struct {
-	HeadStateProvider
-}
-
-var _ HeadStateProvider = &LazyHeadStateProvider{}
-
 type (
 	RODataColumnsVerifier struct {
 		*sharedResources
@@ -271,14 +262,14 @@ func (dv *RODataColumnsVerifier) ValidProposerSignature(ctx context.Context) (er
 		if _, err, _ = dv.sg.Do(signatureData.concat(), func() (any, error) {
 			columnVerificationProposerSignatureCache.WithLabelValues("miss").Inc()
 
-			// Retrieve a state compatible with the data column for verification.
-			verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
+			// Retrieve the parent state.
+			parentState, err := dv.state(ctx, dataColumn.ParentRoot())
 			if err != nil {
-				return nil, columnErrBuilder(errors.Wrap(err, "verifying state"))
+				return nil, columnErrBuilder(errors.Wrap(err, "parent state"))
 			}
 
 			// Full verification, which will subsequently be cached for anything sharing the signature cache.
-			if err = dv.sc.VerifySignature(signatureData, verifyingState); err != nil {
+			if err = dv.sc.VerifySignature(signatureData, parentState); err != nil {
 				return nil, columnErrBuilder(errors.Wrap(err, "verify signature"))
 			}
 
@@ -291,61 +282,6 @@ func (dv *RODataColumnsVerifier) ValidProposerSignature(ctx context.Context) (er
 	return nil
 }
 
-// getVerifyingState returns a state that is compatible with the column sidecar and can be used to verify signature and proposer index.
-// The returned state is guaranteed to be at the same epoch as the data column's epoch, and have the same randao mix and active
-// validator indices as the data column's parent state advanced to the data column's slot.
-func (dv *RODataColumnsVerifier) getVerifyingState(ctx context.Context, dataColumn blocks.RODataColumn) (state.ReadOnlyBeaconState, error) {
-	headRoot, err := dv.hsp.HeadRoot(ctx)
-	if err != nil {
-		return nil, err
-	}
-	parentRoot := dataColumn.ParentRoot()
-	dataColumnSlot := dataColumn.Slot()
-	dataColumnEpoch := slots.ToEpoch(dataColumnSlot)
-	headSlot := dv.hsp.HeadSlot()
-	headEpoch := slots.ToEpoch(headSlot)
-
-	// Use head if it's the parent
-	if bytes.Equal(parentRoot[:], headRoot) {
-		// If they are in the same epoch, then we can return the head state directly
-		if dataColumnEpoch == headEpoch {
-			return dv.hsp.HeadStateReadOnly(ctx)
-		}
-		// Otherwise, we need to process the head state to the data column's slot
-		headState, err := dv.hsp.HeadState(ctx)
-		if err != nil {
-			return nil, err
-		}
-		return transition.ProcessSlotsUsingNextSlotCache(ctx, headState, headRoot, dataColumnSlot)
-	}
-
-	// If head and data column are in the same epoch and head is compatible with the parent's target, then use head
-	if dataColumnEpoch == headEpoch {
-		headTarget, err := dv.fc.TargetRootForEpoch(bytesutil.ToBytes32(headRoot), dataColumnEpoch)
-		if err != nil {
-			return nil, err
-		}
-		parentTarget, err := dv.fc.TargetRootForEpoch(parentRoot, dataColumnEpoch)
-		if err != nil {
-			return nil, err
-		}
-		if bytes.Equal(headTarget[:], parentTarget[:]) {
-			return dv.hsp.HeadStateReadOnly(ctx)
-		}
-	}
-
-	// Otherwise retrieve the parent state and advance it to the data column's slot
-	parentState, err := dv.sr.StateByRoot(ctx, parentRoot)
-	if err != nil {
-		return nil, err
-	}
-	parentEpoch := slots.ToEpoch(parentState.Slot())
-	if dataColumnEpoch == parentEpoch {
-		return parentState, nil
-	}
-	return transition.ProcessSlotsUsingNextSlotCache(ctx, parentState, parentRoot[:], dataColumnSlot)
-}
-
 func (dv *RODataColumnsVerifier) SidecarParentSeen(parentSeen func([fieldparams.RootLength]byte) bool) (err error) {
 	if ok, err := dv.results.cached(RequireSidecarParentSeen); ok {
 		return err
@@ -545,27 +481,23 @@ func (dv *RODataColumnsVerifier) SidecarProposerExpected(ctx context.Context) (e
 			parentRoot := dataColumn.ParentRoot()
 			// Ensure the expensive index computation is only performed once for
 			// concurrent requests for the same signature data.
-			idxAny, err, _ := dv.sg.Do(concatRootSlot(parentRoot, dataColumnSlot), func() (any, error) {
-				verifyingState, err := dv.getVerifyingState(ctx, dataColumn)
+			if _, err, _ := dv.sg.Do(concatRootSlot(parentRoot, dataColumnSlot), func() (any, error) {
+				// Retrieve the parent state.
+				parentState, err := dv.state(ctx, parentRoot)
 				if err != nil {
-					return nil, columnErrBuilder(errors.Wrap(err, "verifying state"))
+					return nil, columnErrBuilder(errors.Wrap(err, "parent state"))
 				}
 
-				idx, err = helpers.BeaconProposerIndexAtSlot(ctx, verifyingState, dataColumnSlot)
+				// Compute the proposer index.
+				idx, err = dv.pc.ComputeProposer(ctx, parentRoot, dataColumnSlot, parentState)
 				if err != nil {
 					return nil, columnErrBuilder(errors.Wrap(err, "compute proposer"))
 				}
 
-				return idx, nil
-			})
-			if err != nil {
+				return nil, nil
+			}); err != nil {
 				return err
 			}
-
-			var ok bool
-			if idx, ok = idxAny.(primitives.ValidatorIndex); !ok {
-				return columnErrBuilder(errors.New("type assertion to ValidatorIndex failed"))
-			}
 		}
 
 		if idx != dataColumn.ProposerIndex() {
@@ -576,6 +508,25 @@ func (dv *RODataColumnsVerifier) SidecarProposerExpected(ctx context.Context) (e
 	return nil
 }
 
+// state retrieves the state of the corresponding root from the cache if possible, else retrieves it from the state by rooter.
+func (dv *RODataColumnsVerifier) state(ctx context.Context, root [fieldparams.RootLength]byte) (state.BeaconState, error) {
+	// If the parent root is already in the cache, return it.
+	if st, ok := dv.stateByRoot[root]; ok {
+		return st, nil
+	}
+
+	// Retrieve the parent state from the state by rooter.
+	st, err := dv.sr.StateByRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrap(err, "state by root")
+	}
+
+	// Store the parent state in the cache.
+	dv.stateByRoot[root] = st
+
+	return st, nil
+}
+
 func columnToSignatureData(d blocks.RODataColumn) signatureData {
 	return signatureData{
 		Root:      d.BlockRoot(),

beacon-chain/verification/data_column_test.go

@@ -1,8 +1,8 @@
 package verification
 
 import (
+	"context"
 	"reflect"
-	"sync"
 	"testing"
 	"time"
 
@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v7/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
@@ -328,7 +329,7 @@ func TestValidProposerSignature(t *testing.T) {
 			svcbError:       nil,
 			vscbShouldError: false,
 			vscbError:       nil,
-			stateByRooter:   sbrForValOverrideWithT(t, firstColumn.ProposerIndex(), validator),
+			stateByRooter:   sbrForValOverride(firstColumn.ProposerIndex(), validator),
 			isError:         false,
 		},
 		{
@@ -346,7 +347,7 @@ func TestValidProposerSignature(t *testing.T) {
 			svcbError:       nil,
 			vscbShouldError: false,
 			vscbError:       errors.New("signature, not so good!"),
-			stateByRooter:   sbrForValOverrideWithT(t, firstColumn.ProposerIndex(), validator),
+			stateByRooter:   sbrForValOverride(firstColumn.ProposerIndex(), validator),
 			isError:         true,
 		},
 	}
@@ -376,12 +377,8 @@ func TestValidProposerSignature(t *testing.T) {
 
 			initializer := Initializer{
 				shared: &sharedResources{
-					sc:  signatureCache,
-					sr:  tc.stateByRooter,
-					hsp: &mockHeadStateProvider{},
-					fc: &mockForkchoicer{
-						TargetRootForEpochCB: fcReturnsTargetRoot([fieldparams.RootLength]byte{}),
-					},
+					sc: signatureCache,
+					sr: tc.stateByRooter,
 				},
 			}
 
@@ -798,7 +795,18 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 	parentRoot := [fieldparams.RootLength]byte{}
 	columns := GenerateTestDataColumns(t, parentRoot, columnSlot, blobCount)
 	firstColumn := columns[0]
-	ctx := t.Context()
+
+	newColumns := GenerateTestDataColumns(t, parentRoot, 2*params.BeaconConfig().SlotsPerEpoch, blobCount)
+	firstNewColumn := newColumns[0]
+
+	validator := &ethpb.Validator{}
+
+	commonComputeProposerCB := func(_ context.Context, root [fieldparams.RootLength]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
+		require.Equal(t, firstColumn.ParentRoot(), root)
+		require.Equal(t, firstColumn.Slot(), slot)
+		return firstColumn.ProposerIndex(), nil
+	}
+
 	testCases := []struct {
 		name          string
 		stateByRooter StateByRooter
@@ -830,7 +838,66 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 				ProposerCB: pcReturnsNotFound(),
 			},
 			columns: columns,
-			error:   "verifying state",
+			error:   "state by root",
+		},
+		{
+			name:          "Not cached, proposer matches",
+			stateByRooter: sbrForValOverride(firstColumn.ProposerIndex(), validator),
+			proposerCache: &mockProposerCache{
+				ProposerCB:        pcReturnsNotFound(),
+				ComputeProposerCB: commonComputeProposerCB,
+			},
+			columns: columns,
+		},
+		{
+			name:          "Not cached, proposer matches",
+			stateByRooter: sbrForValOverride(firstColumn.ProposerIndex(), validator),
+			proposerCache: &mockProposerCache{
+				ProposerCB:        pcReturnsNotFound(),
+				ComputeProposerCB: commonComputeProposerCB,
+			},
+			columns: columns,
+		},
+		{
+			name:          "Not cached, proposer matches for next epoch",
+			stateByRooter: sbrForValOverride(firstNewColumn.ProposerIndex(), validator),
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsNotFound(),
+				ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
+					require.Equal(t, firstNewColumn.ParentRoot(), root)
+					require.Equal(t, firstNewColumn.Slot(), slot)
+					return firstColumn.ProposerIndex(), nil
+				},
+			},
+			columns: newColumns,
+		},
+		{
+			name:          "Not cached, proposer does not match",
+			stateByRooter: sbrForValOverride(firstColumn.ProposerIndex(), validator),
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsNotFound(),
+				ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
+					require.Equal(t, firstColumn.ParentRoot(), root)
+					require.Equal(t, firstColumn.Slot(), slot)
+					return firstColumn.ProposerIndex() + 1, nil
+				},
+			},
+			columns: columns,
+			error:   errSidecarUnexpectedProposer.Error(),
+		},
+		{
+			name:          "Not cached, ComputeProposer fails",
+			stateByRooter: sbrForValOverride(firstColumn.ProposerIndex(), validator),
+			proposerCache: &mockProposerCache{
+				ProposerCB: pcReturnsNotFound(),
+				ComputeProposerCB: func(_ context.Context, root [32]byte, slot primitives.Slot, _ state.BeaconState) (primitives.ValidatorIndex, error) {
+					require.Equal(t, firstColumn.ParentRoot(), root)
+					require.Equal(t, firstColumn.Slot(), slot)
+					return 0, errors.New("ComputeProposer failed")
+				},
+			},
+			columns: columns,
+			error:   "compute proposer",
 		},
 	}
 
@@ -838,9 +905,8 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			initializer := Initializer{
 				shared: &sharedResources{
-					sr:  tc.stateByRooter,
-					pc:  tc.proposerCache,
-					hsp: &mockHeadStateProvider{},
+					sr: tc.stateByRooter,
+					pc: tc.proposerCache,
 					fc: &mockForkchoicer{
 						TargetRootForEpochCB: fcReturnsTargetRoot([fieldparams.RootLength]byte{}),
 					},
@@ -848,31 +914,20 @@ func TestDataColumnsSidecarProposerExpected(t *testing.T) {
 			}
 
 			verifier := initializer.NewDataColumnsVerifier(tc.columns, GossipDataColumnSidecarRequirements)
-			var wg sync.WaitGroup
-
-			var err1, err2 error
-			wg.Go(func() {
-				err1 = verifier.SidecarProposerExpected(ctx)
-			})
-			wg.Go(func() {
-				err2 = verifier.SidecarProposerExpected(ctx)
-			})
-			wg.Wait()
+			err := verifier.SidecarProposerExpected(t.Context())
 
 			require.Equal(t, true, verifier.results.executed(RequireSidecarProposerExpected))
 
 			if len(tc.error) > 0 {
-				require.ErrorContains(t, tc.error, err1)
-				require.ErrorContains(t, tc.error, err2)
+				require.ErrorContains(t, tc.error, err)
 				require.NotNil(t, verifier.results.result(RequireSidecarProposerExpected))
 				return
 			}
 
-			require.NoError(t, err1)
-			require.NoError(t, err2)
+			require.NoError(t, err)
 			require.NoError(t, verifier.results.result(RequireSidecarProposerExpected))
 
-			err := verifier.SidecarProposerExpected(ctx)
+			err = verifier.SidecarProposerExpected(t.Context())
 			require.NoError(t, err)
 		})
 	}

beacon-chain/verification/initializer.go

@@ -33,16 +33,6 @@ type StateByRooter interface {
 	StateByRoot(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 }
 
-// HeadStateProvider describes a type that can provide access to the current head state and related methods.
-// This interface matches blockchain.HeadFetcher but is defined here to avoid import cycles
-// (blockchain package imports verification package).
-type HeadStateProvider interface {
-	HeadRoot(ctx context.Context) ([]byte, error)
-	HeadSlot() primitives.Slot
-	HeadState(ctx context.Context) (state.BeaconState, error)
-	HeadStateReadOnly(ctx context.Context) (state.ReadOnlyBeaconState, error)
-}
-
 // sharedResources provides access to resources that are required by different verification types.
 // for example, sidecar verification and block verification share the block signature verification cache.
 type sharedResources struct {
@@ -51,7 +41,6 @@ type sharedResources struct {
 	sc    signatureCache
 	pc    proposerCache
 	sr    StateByRooter
-	hsp   HeadStateProvider
 	ic    *inclusionProofCache
 	sg    singleflight.Group
 }
@@ -107,15 +96,14 @@ func WithForkLookup(fl forkLookup) InitializerOption {
 }
 
 // NewInitializerWaiter creates an InitializerWaiter which can be used to obtain an Initializer once async dependencies are ready.
-func NewInitializerWaiter(cw startup.ClockWaiter, fc Forkchoicer, sr StateByRooter, hsp HeadStateProvider, opts ...InitializerOption) *InitializerWaiter {
+func NewInitializerWaiter(cw startup.ClockWaiter, fc Forkchoicer, sr StateByRooter, opts ...InitializerOption) *InitializerWaiter {
 	pc := newPropCache()
 	// signature cache is initialized in WaitForInitializer, since we need the genesis validators root, which can be obtained from startup.Clock.
 	shared := &sharedResources{
-		fc:  fc,
-		pc:  pc,
-		sr:  sr,
-		hsp: hsp,
-		ic:  newInclusionProofCache(defaultInclusionProofCacheSize),
+		fc: fc,
+		pc: pc,
+		sr: sr,
+		ic: newInclusionProofCache(defaultInclusionProofCacheSize),
 	}
 	iw := &InitializerWaiter{cw: cw, ini: &Initializer{shared: shared}}
 	for _, o := range opts {

beacon-chain/verification/initializer_test.go

@@ -18,7 +18,7 @@ func TestInitializerWaiter(t *testing.T) {
 	cs := startup.NewClockSynchronizer()
 	require.NoError(t, cs.SetClock(c))
 
-	w := NewInitializerWaiter(cs, &mockForkchoicer{}, &mockStateByRooter{}, &mockHeadStateProvider{})
+	w := NewInitializerWaiter(cs, &mockForkchoicer{}, &mockStateByRooter{})
 	ini, err := w.WaitForInitializer(ctx)
 	require.NoError(t, err)
 	csc, ok := ini.shared.sc.(*sigCache)

changelog/bastin_upgrade-v6-to-v7.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Upgrade Prysm v6 to v7.

changelog/manu-flight.md

@@ -1,2 +0,0 @@
-### Fixed 
-- `SidecarProposerExpected`: Use the correct value of proposer index in the singleflight group.

changelog/potuz_use_head_datacolumn.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Use head state readonly when possible to validate data column sidecars.

consensus-types/hdiff/fuzz_test.go

@@ -26,12 +26,12 @@ func FuzzNewHdiff(f *testing.F) {
 	sizes := []uint64{8, 16, 32}
 	for _, size := range sizes {
 		source, _ := util.DeterministicGenesisStateElectra(f, size)
-
+		
 		// Create various realistic target states
 		scenarios := []string{"slot_change", "balance_change", "validator_change", "multiple_changes"}
 		for _, scenario := range scenarios {
 			target := source.Copy()
-
+			
 			switch scenario {
 			case "slot_change":
 				_ = target.SetSlot(source.Slot() + 1)
@@ -58,20 +58,20 @@ func FuzzNewHdiff(f *testing.F) {
 					_ = target.SetValidators(validators)
 				}
 			}
-
+			
 			validDiff, err := Diff(source, target)
 			if err == nil {
 				f.Add(validDiff.StateDiff, validDiff.ValidatorDiffs, validDiff.BalancesDiff)
 			}
 		}
 	}
-
+	
 	f.Fuzz(func(t *testing.T, stateDiff, validatorDiffs, balancesDiff []byte) {
 		// Limit input sizes to reasonable bounds
 		if len(stateDiff) > 5000 || len(validatorDiffs) > 5000 || len(balancesDiff) > 5000 {
 			return
 		}
-
+		
 		// Bound historical roots length in stateDiff (if it contains snappy-compressed data)
 		// The historicalRootsLength is read after snappy decompression, but we can still
 		// limit the compressed input size to prevent extreme decompression ratios
@@ -79,7 +79,7 @@ func FuzzNewHdiff(f *testing.F) {
 			// Limit stateDiff to prevent potential memory bombs from snappy decompression
 			stateDiff = stateDiff[:maxFuzzStateDiffSize]
 		}
-
+		
 		// Bound validator count in validatorDiffs
 		if len(validatorDiffs) >= 8 {
 			count := binary.LittleEndian.Uint64(validatorDiffs[0:8])
@@ -88,7 +88,7 @@ func FuzzNewHdiff(f *testing.F) {
 				binary.LittleEndian.PutUint64(validatorDiffs[0:8], boundedCount)
 			}
 		}
-
+		
 		// Bound balance count in balancesDiff
 		if len(balancesDiff) >= 8 {
 			count := binary.LittleEndian.Uint64(balancesDiff[0:8])
@@ -97,13 +97,13 @@ func FuzzNewHdiff(f *testing.F) {
 				binary.LittleEndian.PutUint64(balancesDiff[0:8], boundedCount)
 			}
 		}
-
+		
 		input := HdiffBytes{
 			StateDiff:      stateDiff,
 			ValidatorDiffs: validatorDiffs,
 			BalancesDiff:   balancesDiff,
 		}
-
+		
 		// Test parsing - should not panic even with corrupted but bounded data
 		_, err := newHdiff(input)
 		_ = err // Expected to fail with corrupted data
@@ -118,30 +118,30 @@ func FuzzNewStateDiff(f *testing.F) {
 				t.Errorf("newStateDiff panicked: %v", r)
 			}
 		}()
-
+		
 		// Bound validator count to reasonable range
 		validators := uint64(validatorCount%32 + 8) // 8-39 validators
 		if slotDelta > 100 {
 			slotDelta = slotDelta % 100
 		}
-
+		
 		// Generate random source state
 		source, _ := util.DeterministicGenesisStateElectra(t, validators)
 		target := source.Copy()
-
+		
 		// Apply random slot change
 		_ = target.SetSlot(source.Slot() + primitives.Slot(slotDelta))
-
+		
 		// Apply random balance changes
 		if len(balanceData) >= 8 {
 			balances := target.Balances()
 			numChanges := int(binary.LittleEndian.Uint64(balanceData[:8])) % len(balances)
 			for i := 0; i < numChanges && i*8+8 < len(balanceData); i++ {
 				idx := i % len(balances)
-				delta := int64(binary.LittleEndian.Uint64(balanceData[i*8+8 : (i+1)*8+8]))
+				delta := int64(binary.LittleEndian.Uint64(balanceData[i*8+8:(i+1)*8+8]))
 				// Keep delta reasonable
 				delta = delta % oneEthInGwei // Max 1 ETH change
-
+				
 				if delta < 0 && uint64(-delta) > balances[idx] {
 					balances[idx] = 0
 				} else if delta < 0 {
@@ -152,7 +152,7 @@ func FuzzNewStateDiff(f *testing.F) {
 			}
 			_ = target.SetBalances(balances)
 		}
-
+		
 		// Apply random validator changes
 		if len(validatorData) > 0 {
 			validators := target.Validators()
@@ -165,20 +165,20 @@ func FuzzNewStateDiff(f *testing.F) {
 			}
 			_ = target.SetValidators(validators)
 		}
-
-		// Create diff between source and target
+		
+		// Create diff between source and target  
 		diff, err := Diff(source, target)
 		if err != nil {
 			return // Skip if diff creation fails
 		}
-
+		
 		// Test newStateDiff with the valid serialized diff from StateDiff field
 		reconstructed, err := newStateDiff(diff.StateDiff)
 		if err != nil {
 			t.Errorf("newStateDiff failed on valid diff: %v", err)
 			return
 		}
-
+		
 		// Basic validation that reconstruction worked
 		if reconstructed == nil {
 			t.Error("newStateDiff returned nil without error")
@@ -194,23 +194,23 @@ func FuzzNewValidatorDiffs(f *testing.F) {
 				t.Errorf("newValidatorDiffs panicked: %v", r)
 			}
 		}()
-
+		
 		// Bound validator count to reasonable range
 		validators := uint64(validatorCount%16 + 4) // 4-19 validators
-
+		
 		// Generate random source state
 		source, _ := util.DeterministicGenesisStateElectra(t, validators)
 		target := source.Copy()
-
+		
 		// Apply random validator changes based on changeData
 		if len(changeData) > 0 {
 			vals := target.Validators()
 			numChanges := int(changeData[0]) % len(vals)
-
+			
 			for i := 0; i < numChanges && i < len(changeData)-1; i++ {
 				idx := i % len(vals)
 				changeType := changeData[i+1] % 4
-
+				
 				switch changeType {
 				case 0: // Change effective balance
 					vals[idx].EffectiveBalance += oneEthInGwei
@@ -224,20 +224,20 @@ func FuzzNewValidatorDiffs(f *testing.F) {
 			}
 			_ = target.SetValidators(vals)
 		}
-
+		
 		// Create diff between source and target
 		diff, err := Diff(source, target)
 		if err != nil {
 			return // Skip if diff creation fails
 		}
-
+		
 		// Test newValidatorDiffs with the valid serialized diff
 		reconstructed, err := newValidatorDiffs(diff.ValidatorDiffs)
 		if err != nil {
 			t.Errorf("newValidatorDiffs failed on valid diff: %v", err)
 			return
 		}
-
+		
 		// Basic validation that reconstruction worked
 		if reconstructed == nil {
 			t.Error("newValidatorDiffs returned nil without error")
@@ -253,25 +253,25 @@ func FuzzNewBalancesDiff(f *testing.F) {
 				t.Errorf("newBalancesDiff panicked: %v", r)
 			}
 		}()
-
+		
 		// Bound balance count to reasonable range
 		numBalances := int(balanceCount%32 + 8) // 8-39 balances
-
+		
 		// Generate simple source state
 		source, _ := util.DeterministicGenesisStateElectra(t, uint64(numBalances))
 		target := source.Copy()
-
+		
 		// Apply random balance changes based on balanceData
 		if len(balanceData) >= 8 {
 			balances := target.Balances()
 			numChanges := int(binary.LittleEndian.Uint64(balanceData[:8])) % numBalances
-
+			
 			for i := 0; i < numChanges && i*8+8 < len(balanceData); i++ {
 				idx := i % numBalances
-				delta := int64(binary.LittleEndian.Uint64(balanceData[i*8+8 : (i+1)*8+8]))
+				delta := int64(binary.LittleEndian.Uint64(balanceData[i*8+8:(i+1)*8+8]))
 				// Keep delta reasonable
 				delta = delta % oneEthInGwei // Max 1 ETH change
-
+				
 				if delta < 0 && uint64(-delta) > balances[idx] {
 					balances[idx] = 0
 				} else if delta < 0 {
@@ -282,20 +282,20 @@ func FuzzNewBalancesDiff(f *testing.F) {
 			}
 			_ = target.SetBalances(balances)
 		}
-
+		
 		// Create diff between source and target to get BalancesDiff
 		diff, err := Diff(source, target)
 		if err != nil {
 			return // Skip if diff creation fails
 		}
-
+		
 		// Test newBalancesDiff with the valid serialized diff
 		reconstructed, err := newBalancesDiff(diff.BalancesDiff)
 		if err != nil {
 			t.Errorf("newBalancesDiff failed on valid diff: %v", err)
 			return
 		}
-
+		
 		// Basic validation that reconstruction worked
 		if reconstructed == nil {
 			t.Error("newBalancesDiff returned nil without error")
@@ -307,13 +307,13 @@ func FuzzNewBalancesDiff(f *testing.F) {
 func FuzzApplyDiff(f *testing.F) {
 	// Test with realistic state variations, not random data
 	ctx := context.Background()
-
+	
 	// Add seed corpus with various valid scenarios
 	sizes := []uint64{8, 16, 32, 64}
 	for _, size := range sizes {
 		source, _ := util.DeterministicGenesisStateElectra(f, size)
 		target := source.Copy()
-
+		
 		// Different types of realistic changes
 		scenarios := []func(){
 			func() { _ = target.SetSlot(source.Slot() + 1) }, // Slot change
@@ -332,29 +332,29 @@ func FuzzApplyDiff(f *testing.F) {
 				}
 			},
 		}
-
+		
 		for _, scenario := range scenarios {
 			testTarget := source.Copy()
 			scenario()
-
+			
 			validDiff, err := Diff(source, testTarget)
 			if err == nil {
 				f.Add(validDiff.StateDiff, validDiff.ValidatorDiffs, validDiff.BalancesDiff)
 			}
 		}
 	}
-
+	
 	f.Fuzz(func(t *testing.T, stateDiff, validatorDiffs, balancesDiff []byte) {
 		// Only test with reasonable sized inputs
 		if len(stateDiff) > 10000 || len(validatorDiffs) > 10000 || len(balancesDiff) > 10000 {
 			return
 		}
-
+		
 		// Bound historical roots length in stateDiff (same as FuzzNewHdiff)
 		if len(stateDiff) > maxFuzzStateDiffSize {
 			stateDiff = stateDiff[:maxFuzzStateDiffSize]
 		}
-
+		
 		// Bound validator count in validatorDiffs
 		if len(validatorDiffs) >= 8 {
 			count := binary.LittleEndian.Uint64(validatorDiffs[0:8])
@@ -363,7 +363,7 @@ func FuzzApplyDiff(f *testing.F) {
 				binary.LittleEndian.PutUint64(validatorDiffs[0:8], boundedCount)
 			}
 		}
-
+		
 		// Bound balance count in balancesDiff
 		if len(balancesDiff) >= 8 {
 			count := binary.LittleEndian.Uint64(balancesDiff[0:8])
@@ -372,16 +372,16 @@ func FuzzApplyDiff(f *testing.F) {
 				binary.LittleEndian.PutUint64(balancesDiff[0:8], boundedCount)
 			}
 		}
-
+		
 		// Create fresh source state for each test
 		source, _ := util.DeterministicGenesisStateElectra(t, 8)
-
+		
 		diff := HdiffBytes{
 			StateDiff:      stateDiff,
 			ValidatorDiffs: validatorDiffs,
 			BalancesDiff:   balancesDiff,
 		}
-
+		
 		// Apply diff - errors are expected for fuzzed data
 		_, err := ApplyDiff(ctx, source, diff)
 		_ = err // Expected to fail with invalid data
@@ -393,24 +393,24 @@ func FuzzReadPendingAttestation(f *testing.F) {
 	// Add edge cases - this function is particularly vulnerable
 	f.Add([]byte{})
 	f.Add([]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}) // 8 bytes
-	f.Add(make([]byte, 200))                                      // Larger than expected
-
+	f.Add(make([]byte, 200)) // Larger than expected
+	
 	// Add a case with large reported length
 	largeLength := make([]byte, 8)
 	binary.LittleEndian.PutUint64(largeLength, 0xFFFFFFFF) // Large bits length
 	f.Add(largeLength)
-
+	
 	f.Fuzz(func(t *testing.T, data []byte) {
 		defer func() {
 			if r := recover(); r != nil {
 				t.Errorf("readPendingAttestation panicked: %v", r)
 			}
 		}()
-
+		
 		// Make a copy since the function modifies the slice
 		dataCopy := make([]byte, len(data))
 		copy(dataCopy, data)
-
+		
 		// Bound the bits length by modifying the first 8 bytes if they exist
 		if len(dataCopy) >= 8 {
 			// Read the bits length and bound it to maxFuzzValidators
@@ -420,7 +420,7 @@ func FuzzReadPendingAttestation(f *testing.F) {
 				binary.LittleEndian.PutUint64(dataCopy[0:8], boundedLength)
 			}
 		}
-
+		
 		_, err := readPendingAttestation(&dataCopy)
 		_ = err
 	})
@@ -497,14 +497,14 @@ func FuzzComputeLPS(f *testing.F) {
 	f.Add("1,1,1")
 	f.Add("1,2,3,4")
 	f.Add("")
-
+	
 	f.Fuzz(func(t *testing.T, patternStr string) {
 		defer func() {
 			if r := recover(); r != nil {
 				t.Errorf("computeLPS panicked: %v", r)
 			}
 		}()
-
+		
 		// Parse comma-separated string into int slice
 		var pattern []int
 		if patternStr != "" {
@@ -514,14 +514,14 @@ func FuzzComputeLPS(f *testing.F) {
 				}
 			}
 		}
-
+		
 		// Convert to pointer slice
 		patternPtrs := make([]*int, len(pattern))
 		for i := range pattern {
 			val := pattern[i]
 			patternPtrs[i] = &val
 		}
-
+		
 		integerEquals := func(a, b *int) bool {
 			if a == nil && b == nil {
 				return true
@@ -531,14 +531,14 @@ func FuzzComputeLPS(f *testing.F) {
 			}
 			return *a == *b
 		}
-
+		
 		result := computeLPS(patternPtrs, integerEquals)
-
+		
 		// Verify result length matches input
 		if len(result) != len(pattern) {
 			t.Errorf("computeLPS returned wrong length: got %d, expected %d", len(result), len(pattern))
 		}
-
+		
 		// Verify all LPS values are non-negative and within bounds
 		for i, lps := range result {
 			if lps < 0 || lps > i {
@@ -556,40 +556,40 @@ func FuzzDiffToBalances(f *testing.F) {
 				t.Errorf("diffToBalances panicked: %v", r)
 			}
 		}()
-
+		
 		// Convert byte data to balance arrays
 		var sourceBalances, targetBalances []uint64
-
+		
 		// Parse source balances (8 bytes per uint64)
 		for i := 0; i+7 < len(sourceData) && len(sourceBalances) < 100; i += 8 {
 			balance := binary.LittleEndian.Uint64(sourceData[i : i+8])
 			sourceBalances = append(sourceBalances, balance)
 		}
-
+		
 		// Parse target balances
 		for i := 0; i+7 < len(targetData) && len(targetBalances) < 100; i += 8 {
 			balance := binary.LittleEndian.Uint64(targetData[i : i+8])
 			targetBalances = append(targetBalances, balance)
 		}
-
+		
 		// Create states with the provided balances
 		source, _ := util.DeterministicGenesisStateElectra(t, 1)
 		target, _ := util.DeterministicGenesisStateElectra(t, 1)
-
+		
 		if len(sourceBalances) > 0 {
 			_ = source.SetBalances(sourceBalances)
 		}
 		if len(targetBalances) > 0 {
 			_ = target.SetBalances(targetBalances)
 		}
-
+		
 		result, err := diffToBalances(source, target)
-
+		
 		// If no error, verify result consistency
 		if err == nil && len(result) > 0 {
 			// Result length should match target length
 			if len(result) != len(target.Balances()) {
-				t.Errorf("diffToBalances result length mismatch: got %d, expected %d",
+				t.Errorf("diffToBalances result length mismatch: got %d, expected %d", 
 					len(result), len(target.Balances()))
 			}
 		}
@@ -604,21 +604,21 @@ func FuzzValidatorsEqual(f *testing.F) {
 				t.Errorf("validatorsEqual panicked: %v", r)
 			}
 		}()
-
+		
 		// Create two validators and fuzz their fields
 		if len(data) < 16 {
 			return
 		}
-
+		
 		source, _ := util.DeterministicGenesisStateElectra(t, 2)
 		validators := source.Validators()
 		if len(validators) < 2 {
 			return
 		}
-
+		
 		val1 := validators[0]
 		val2 := validators[1]
-
+		
 		// Modify validator fields based on fuzz data
 		if len(data) > 0 && data[0]%2 == 0 {
 			val2.EffectiveBalance = val1.EffectiveBalance + uint64(data[0])
@@ -626,11 +626,11 @@ func FuzzValidatorsEqual(f *testing.F) {
 		if len(data) > 1 && data[1]%2 == 0 {
 			val2.Slashed = !val1.Slashed
 		}
-
+		
 		// Create ReadOnlyValidator wrappers if needed
 		// Since validatorsEqual expects ReadOnlyValidator interface,
 		// we'll skip this test for now as it requires state wrapper implementation
 		_ = val1
 		_ = val2
 	})
-}
+}

consensus-types/hdiff/property_test.go

@@ -21,11 +21,11 @@ func FuzzPropertyRoundTrip(f *testing.F) {
 		if slotDelta > 32 { // Max one epoch
 			slotDelta = slotDelta % 32
 		}
-
+		
 		// Convert byte data to realistic deltas and changes
 		var balanceDeltas []int64
 		var validatorChanges []bool
-
+		
 		// Parse balance deltas - limit to realistic amounts (8 bytes per int64)
 		for i := 0; i+7 < len(balanceData) && len(balanceDeltas) < 20; i += 8 {
 			delta := int64(binary.LittleEndian.Uint64(balanceData[i : i+8]))
@@ -38,27 +38,27 @@ func FuzzPropertyRoundTrip(f *testing.F) {
 			}
 			balanceDeltas = append(balanceDeltas, delta)
 		}
-
+		
 		// Parse validator changes (1 byte per bool) - limit to small number
 		for i := 0; i < len(validatorData) && len(validatorChanges) < 10; i++ {
 			validatorChanges = append(validatorChanges, validatorData[i]%2 == 0)
 		}
-
+		
 		ctx := t.Context()
-
+		
 		// Create source state with reasonable size
 		validatorCount := uint64(len(validatorChanges) + 8) // Minimum 8 validators
 		if validatorCount > 64 {
 			validatorCount = 64 // Cap at 64 for performance
 		}
 		source, _ := util.DeterministicGenesisStateElectra(t, validatorCount)
-
+		
 		// Create target state with modifications
 		target := source.Copy()
-
+		
 		// Apply slot change
 		_ = target.SetSlot(source.Slot() + primitives.Slot(slotDelta))
-
+		
 		// Apply realistic balance changes
 		if len(balanceDeltas) > 0 {
 			balances := target.Balances()
@@ -85,7 +85,7 @@ func FuzzPropertyRoundTrip(f *testing.F) {
 			}
 			_ = target.SetBalances(balances)
 		}
-
+		
 		// Apply realistic validator changes
 		if len(validatorChanges) > 0 {
 			validators := target.Validators()
@@ -100,24 +100,24 @@ func FuzzPropertyRoundTrip(f *testing.F) {
 			}
 			_ = target.SetValidators(validators)
 		}
-
+		
 		// Create diff
 		diff, err := Diff(source, target)
 		if err != nil {
 			// If diff creation fails, that's acceptable for malformed inputs
 			return
 		}
-
+		
 		// Apply diff
 		result, err := ApplyDiff(ctx, source, diff)
 		if err != nil {
 			// If diff application fails, that's acceptable
 			return
 		}
-
+		
 		// Verify round-trip property: source + diff = target
 		require.Equal(t, target.Slot(), result.Slot())
-
+		
 		// Verify balance consistency
 		targetBalances := target.Balances()
 		resultBalances := result.Balances()
@@ -125,7 +125,7 @@ func FuzzPropertyRoundTrip(f *testing.F) {
 		for i := range targetBalances {
 			require.Equal(t, targetBalances[i], resultBalances[i], "Balance mismatch at index %d", i)
 		}
-
+		
 		// Verify validator consistency
 		targetVals := target.Validators()
 		resultVals := result.Validators()
@@ -142,16 +142,16 @@ func FuzzPropertyResourceBounds(f *testing.F) {
 	f.Fuzz(func(t *testing.T, validatorCount uint8, slotDelta uint8, changeCount uint8) {
 		// Use realistic parameters
 		validators := uint64(validatorCount%64 + 8) // 8-71 validators
-		slots := uint64(slotDelta % 32)             // 0-31 slots
+		slots := uint64(slotDelta % 32)              // 0-31 slots
 		changes := int(changeCount % 10)            // 0-9 changes
-
+		
 		// Create realistic states
 		source, _ := util.DeterministicGenesisStateElectra(t, validators)
 		target := source.Copy()
-
+		
 		// Apply realistic changes
 		_ = target.SetSlot(source.Slot() + primitives.Slot(slots))
-
+		
 		if changes > 0 {
 			validatorList := target.Validators()
 			for i := 0; i < changes && i < len(validatorList); i++ {
@@ -159,21 +159,21 @@ func FuzzPropertyResourceBounds(f *testing.F) {
 			}
 			_ = target.SetValidators(validatorList)
 		}
-
+		
 		// Operations should complete quickly
 		start := time.Now()
 		diff, err := Diff(source, target)
 		duration := time.Since(start)
-
+		
 		if err == nil {
 			// Should be fast
 			require.Equal(t, true, duration < time.Second, "Diff creation too slow: %v", duration)
-
+			
 			// Apply should also be fast
 			start = time.Now()
 			_, err = ApplyDiff(t.Context(), source, diff)
 			duration = time.Since(start)
-
+			
 			if err == nil {
 				require.Equal(t, true, duration < time.Second, "Diff application too slow: %v", duration)
 			}
@@ -190,13 +190,13 @@ func FuzzPropertyDiffEfficiency(f *testing.F) {
 		if numChanges > 10 {
 			numChanges = numChanges % 10
 		}
-
+		
 		// Create states with small differences
 		source, _ := util.DeterministicGenesisStateElectra(t, 64)
 		target := source.Copy()
-
+		
 		_ = target.SetSlot(source.Slot() + primitives.Slot(slotDelta))
-
+		
 		// Make a few small changes
 		if numChanges > 0 {
 			validators := target.Validators()
@@ -205,24 +205,24 @@ func FuzzPropertyDiffEfficiency(f *testing.F) {
 			}
 			_ = target.SetValidators(validators)
 		}
-
+		
 		// Create diff
 		diff, err := Diff(source, target)
 		if err != nil {
 			return
 		}
-
+		
 		// For small changes, diff should be much smaller than full state
 		sourceSSZ, err := source.MarshalSSZ()
 		if err != nil {
 			return
 		}
-
+		
 		diffSize := len(diff.StateDiff) + len(diff.ValidatorDiffs) + len(diff.BalancesDiff)
-
+		
 		// Diff should be smaller than full state for small changes
 		if numChanges <= 5 && slotDelta <= 10 {
-			require.Equal(t, true, diffSize < len(sourceSSZ)/2,
+			require.Equal(t, true, diffSize < len(sourceSSZ)/2, 
 				"Diff size %d should be less than half of state size %d", diffSize, len(sourceSSZ))
 		}
 	})
@@ -239,10 +239,10 @@ func FuzzPropertyBalanceConservation(f *testing.F) {
 			change := rawChange % (maxSafeBalance / 2) // Divide by 2 to allow for addition/subtraction
 			balanceChanges = append(balanceChanges, change)
 		}
-
+		
 		source, _ := util.DeterministicGenesisStateElectra(t, uint64(len(balanceChanges)+10))
 		originalBalances := source.Balances()
-
+		
 		// Ensure initial balances are within safe range for int64 casting
 		for i, balance := range originalBalances {
 			if balance > maxSafeBalance {
@@ -250,23 +250,23 @@ func FuzzPropertyBalanceConservation(f *testing.F) {
 			}
 		}
 		_ = source.SetBalances(originalBalances)
-
+		
 		// Calculate total before
 		var totalBefore uint64
 		for _, balance := range originalBalances {
 			totalBefore += balance
 		}
-
+		
 		// Apply balance changes via diff system
 		target := source.Copy()
 		targetBalances := target.Balances()
-
+		
 		var totalDelta int64
 		for i, delta := range balanceChanges {
 			if i >= len(targetBalances) {
 				break
 			}
-
+			
 			// Prevent underflow
 			if delta < 0 && uint64(-delta) > targetBalances[i] {
 				totalDelta -= int64(targetBalances[i]) // Actually lost amount (negative)
@@ -287,25 +287,25 @@ func FuzzPropertyBalanceConservation(f *testing.F) {
 			}
 		}
 		_ = target.SetBalances(targetBalances)
-
+		
 		// Apply through diff system
 		diff, err := Diff(source, target)
 		if err != nil {
 			return
 		}
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		if err != nil {
 			return
 		}
-
+		
 		// Calculate total after
 		resultBalances := result.Balances()
 		var totalAfter uint64
 		for _, balance := range resultBalances {
 			totalAfter += balance
 		}
-
+		
 		// Verify conservation (accounting for intended changes)
 		expectedTotal := totalBefore
 		if totalDelta >= 0 {
@@ -317,9 +317,9 @@ func FuzzPropertyBalanceConservation(f *testing.F) {
 				expectedTotal = 0
 			}
 		}
-
-		require.Equal(t, expectedTotal, totalAfter,
-			"Balance conservation violated: before=%d, delta=%d, expected=%d, actual=%d",
+		
+		require.Equal(t, expectedTotal, totalAfter, 
+			"Balance conservation violated: before=%d, delta=%d, expected=%d, actual=%d", 
 			totalBefore, totalDelta, expectedTotal, totalAfter)
 	})
 }
@@ -329,24 +329,24 @@ func FuzzPropertyMonotonicSlot(f *testing.F) {
 	f.Fuzz(func(t *testing.T, slotDelta uint64) {
 		source, _ := util.DeterministicGenesisStateElectra(t, 16)
 		target := source.Copy()
-
+		
 		targetSlot := source.Slot() + primitives.Slot(slotDelta)
 		_ = target.SetSlot(targetSlot)
-
+		
 		diff, err := Diff(source, target)
 		if err != nil {
 			return
 		}
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		if err != nil {
 			return
 		}
-
+		
 		// Slot should never decrease
-		require.Equal(t, true, result.Slot() >= source.Slot(),
+		require.Equal(t, true, result.Slot() >= source.Slot(), 
 			"Slot decreased from %d to %d", source.Slot(), result.Slot())
-
+		
 		// Slot should match target
 		require.Equal(t, targetSlot, result.Slot())
 	})
@@ -360,10 +360,10 @@ func FuzzPropertyValidatorIndices(f *testing.F) {
 		for i := 0; i < len(changeData) && len(changes) < 20; i++ {
 			changes = append(changes, changeData[i]%2 == 0)
 		}
-
+		
 		source, _ := util.DeterministicGenesisStateElectra(t, uint64(len(changes)+5))
 		target := source.Copy()
-
+		
 		// Apply changes
 		validators := target.Validators()
 		for i, shouldChange := range changes {
@@ -375,21 +375,21 @@ func FuzzPropertyValidatorIndices(f *testing.F) {
 			}
 		}
 		_ = target.SetValidators(validators)
-
+		
 		diff, err := Diff(source, target)
 		if err != nil {
 			return
 		}
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		if err != nil {
 			return
 		}
-
+		
 		// Validator count should not decrease
 		require.Equal(t, true, len(result.Validators()) >= len(source.Validators()),
 			"Validator count decreased from %d to %d", len(source.Validators()), len(result.Validators()))
-
+		
 		// Public keys should be preserved for existing validators
 		sourceVals := source.Validators()
 		resultVals := result.Validators()
@@ -400,4 +400,4 @@ func FuzzPropertyValidatorIndices(f *testing.F) {
 			}
 		}
 	})
-}
+}

consensus-types/hdiff/security_test.go

@@ -13,39 +13,39 @@ import (
 // TestIntegerOverflowProtection tests protection against balance overflow attacks
 func TestIntegerOverflowProtection(t *testing.T) {
 	source, _ := util.DeterministicGenesisStateElectra(t, 8)
-
+	
 	// Test balance overflow in diffToBalances - use realistic values
 	t.Run("balance_diff_overflow", func(t *testing.T) {
 		target := source.Copy()
 		balances := target.Balances()
-
+		
 		// Set high but realistic balance values (32 ETH in Gwei = 32e9)
 		balances[0] = 32000000000 // 32 ETH
 		balances[1] = 64000000000 // 64 ETH
 		_ = target.SetBalances(balances)
-
+		
 		// This should work fine with realistic values
 		diffs, err := diffToBalances(source, target)
 		require.NoError(t, err)
-
+		
 		// Verify the diffs are reasonable
 		require.Equal(t, true, len(diffs) > 0, "Should have balance diffs")
 	})
-
+	
 	// Test reasonable balance changes
 	t.Run("realistic_balance_changes", func(t *testing.T) {
 		// Create realistic balance changes (slashing, rewards)
 		balancesDiff := []int64{1000000000, -500000000, 2000000000} // 1 ETH gain, 0.5 ETH loss, 2 ETH gain
-
+		
 		// Apply to state with normal balances
 		testSource := source.Copy()
 		normalBalances := []uint64{32000000000, 32000000000, 32000000000} // 32 ETH each
 		_ = testSource.SetBalances(normalBalances)
-
+		
 		// This should work fine
 		result, err := applyBalancesDiff(testSource, balancesDiff)
 		require.NoError(t, err)
-
+		
 		resultBalances := result.Balances()
 		require.Equal(t, uint64(33000000000), resultBalances[0]) // 33 ETH
 		require.Equal(t, uint64(31500000000), resultBalances[1]) // 31.5 ETH
@@ -59,7 +59,7 @@ func TestReasonablePerformance(t *testing.T) {
 		// Test with a large but realistic validator set
 		source, _ := util.DeterministicGenesisStateElectra(t, 1000) // 1000 validators
 		target := source.Copy()
-
+		
 		// Make realistic changes
 		_ = target.SetSlot(source.Slot() + 32) // One epoch
 		validators := target.Validators()
@@ -67,31 +67,31 @@ func TestReasonablePerformance(t *testing.T) {
 			validators[i].EffectiveBalance += 1000000000 // 1 ETH change
 		}
 		_ = target.SetValidators(validators)
-
+		
 		// Should complete quickly
 		start := time.Now()
 		diff, err := Diff(source, target)
 		duration := time.Since(start)
-
+		
 		require.NoError(t, err)
 		require.Equal(t, true, duration < time.Second, "Diff creation took too long: %v", duration)
 		require.Equal(t, true, len(diff.StateDiff) > 0, "Should have state diff")
 	})
-
+	
 	t.Run("realistic_diff_application", func(t *testing.T) {
 		// Test applying diffs to large states
 		source, _ := util.DeterministicGenesisStateElectra(t, 500)
 		target := source.Copy()
 		_ = target.SetSlot(source.Slot() + 1)
-
+		
 		// Create and apply diff
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		start := time.Now()
 		result, err := ApplyDiff(t.Context(), source, diff)
 		duration := time.Since(start)
-
+		
 		require.NoError(t, err)
 		require.Equal(t, target.Slot(), result.Slot())
 		require.Equal(t, true, duration < time.Second, "Diff application took too long: %v", duration)
@@ -103,30 +103,30 @@ func TestStateTransitionValidation(t *testing.T) {
 	t.Run("validator_slashing_scenario", func(t *testing.T) {
 		source, _ := util.DeterministicGenesisStateElectra(t, 10)
 		target := source.Copy()
-
+		
 		// Simulate validator slashing (realistic scenario)
 		validators := target.Validators()
 		validators[0].Slashed = true
 		validators[0].EffectiveBalance = 0 // Slashed validator loses balance
 		_ = target.SetValidators(validators)
-
+		
 		// This should work fine
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		require.NoError(t, err)
 		require.Equal(t, true, result.Validators()[0].Slashed)
 		require.Equal(t, uint64(0), result.Validators()[0].EffectiveBalance)
 	})
-
+	
 	t.Run("epoch_transition_scenario", func(t *testing.T) {
 		source, _ := util.DeterministicGenesisStateElectra(t, 64)
 		target := source.Copy()
-
+		
 		// Simulate epoch transition with multiple changes
 		_ = target.SetSlot(source.Slot() + 32) // One epoch
-
+		
 		// Some validators get rewards, others get penalties
 		balances := target.Balances()
 		for i := 0; i < len(balances); i++ {
@@ -139,31 +139,31 @@ func TestStateTransitionValidation(t *testing.T) {
 			}
 		}
 		_ = target.SetBalances(balances)
-
+		
 		// This should work smoothly
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		require.NoError(t, err)
 		require.Equal(t, target.Slot(), result.Slot())
 	})
-
+	
 	t.Run("consistent_state_root", func(t *testing.T) {
 		// Test that diffs preserve state consistency
 		source, _ := util.DeterministicGenesisStateElectra(t, 32)
 		target := source.Copy()
-
+		
 		// Make minimal changes
 		_ = target.SetSlot(source.Slot() + 1)
-
+		
 		// Diff and apply should be consistent
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		result, err := ApplyDiff(t.Context(), source, diff)
 		require.NoError(t, err)
-
+		
 		// Result should match target
 		require.Equal(t, target.Slot(), result.Slot())
 		require.Equal(t, len(target.Validators()), len(result.Validators()))
@@ -177,73 +177,73 @@ func TestSerializationRoundTrip(t *testing.T) {
 		// Test that serialization and deserialization are consistent
 		source, _ := util.DeterministicGenesisStateElectra(t, 16)
 		target := source.Copy()
-
+		
 		// Make changes
 		_ = target.SetSlot(source.Slot() + 5)
 		validators := target.Validators()
 		validators[0].EffectiveBalance += 1000000000
 		_ = target.SetValidators(validators)
-
+		
 		// Create diff
 		diff1, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		// Deserialize and re-serialize
 		hdiff, err := newHdiff(diff1)
 		require.NoError(t, err)
-
+		
 		diff2 := hdiff.serialize()
-
+		
 		// Apply both diffs - should get same result
 		result1, err := ApplyDiff(t.Context(), source, diff1)
 		require.NoError(t, err)
-
+		
 		result2, err := ApplyDiff(t.Context(), source, diff2)
 		require.NoError(t, err)
-
+		
 		require.Equal(t, result1.Slot(), result2.Slot())
 		require.Equal(t, result1.Validators()[0].EffectiveBalance, result2.Validators()[0].EffectiveBalance)
 	})
-
+	
 	t.Run("empty_diff_handling", func(t *testing.T) {
 		// Test that empty diffs are handled correctly
 		source, _ := util.DeterministicGenesisStateElectra(t, 8)
 		target := source.Copy() // No changes
-
+		
 		// Should create minimal diff
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		// Apply should work and return equivalent state
 		result, err := ApplyDiff(t.Context(), source, diff)
 		require.NoError(t, err)
-
+		
 		require.Equal(t, source.Slot(), result.Slot())
 		require.Equal(t, len(source.Validators()), len(result.Validators()))
 	})
-
+	
 	t.Run("compression_efficiency", func(t *testing.T) {
 		// Test that compression is working effectively
 		source, _ := util.DeterministicGenesisStateElectra(t, 100)
 		target := source.Copy()
-
+		
 		// Make small changes
 		_ = target.SetSlot(source.Slot() + 1)
 		validators := target.Validators()
 		validators[0].EffectiveBalance += 1000000000
 		_ = target.SetValidators(validators)
-
+		
 		// Create diff
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		// Get full state size
 		fullStateSSZ, err := target.MarshalSSZ()
 		require.NoError(t, err)
-
+		
 		// Diff should be much smaller than full state
 		diffSize := len(diff.StateDiff) + len(diff.ValidatorDiffs) + len(diff.BalancesDiff)
-		require.Equal(t, true, diffSize < len(fullStateSSZ)/2,
+		require.Equal(t, true, diffSize < len(fullStateSSZ)/2, 
 			"Diff should be smaller than full state: diff=%d, full=%d", diffSize, len(fullStateSSZ))
 	})
 }
@@ -254,7 +254,7 @@ func TestKMPSecurity(t *testing.T) {
 		// Test with nil pointers in the pattern/text
 		pattern := []*int{nil, nil, nil}
 		text := []*int{nil, nil, nil, nil, nil}
-
+		
 		equals := func(a, b *int) bool {
 			if a == nil && b == nil {
 				return true
@@ -264,29 +264,29 @@ func TestKMPSecurity(t *testing.T) {
 			}
 			return *a == *b
 		}
-
+		
 		// Should not panic - result can be any integer
 		result := kmpIndex(len(pattern), text, equals)
 		_ = result // Any result is valid, just ensure no panic
 	})
-
+	
 	t.Run("empty_pattern_edge_case", func(t *testing.T) {
 		var pattern []*int
 		text := []*int{new(int), new(int)}
-
+		
 		equals := func(a, b *int) bool { return a == b }
-
+		
 		result := kmpIndex(0, text, equals)
 		require.Equal(t, 0, result, "Empty pattern should return 0")
 		_ = pattern // Silence unused variable warning
 	})
-
+	
 	t.Run("realistic_pattern_performance", func(t *testing.T) {
 		// Test with realistic sizes to ensure good performance
 		realisticSize := 100 // More realistic for validator arrays
 		pattern := make([]*int, realisticSize)
 		text := make([]*int, realisticSize*2)
-
+		
 		// Create realistic pattern
 		for i := range pattern {
 			val := i % 10 // More variation
@@ -296,7 +296,7 @@ func TestKMPSecurity(t *testing.T) {
 			val := i % 10
 			text[i] = &val
 		}
-
+		
 		equals := func(a, b *int) bool {
 			if a == nil && b == nil {
 				return true
@@ -306,13 +306,13 @@ func TestKMPSecurity(t *testing.T) {
 			}
 			return *a == *b
 		}
-
+		
 		start := time.Now()
 		result := kmpIndex(len(pattern), text, equals)
 		duration := time.Since(start)
-
+		
 		// Should complete quickly with realistic inputs
-		require.Equal(t, true, duration < time.Second,
+		require.Equal(t, true, duration < time.Second, 
 			"KMP took too long: %v", duration)
 		_ = result // Any result is valid, just ensure performance is good
 	})
@@ -324,18 +324,18 @@ func TestConcurrencySafety(t *testing.T) {
 		source, _ := util.DeterministicGenesisStateElectra(t, 32)
 		target := source.Copy()
 		_ = target.SetSlot(source.Slot() + 1)
-
+		
 		const numGoroutines = 10
 		const iterations = 100
-
+		
 		var wg sync.WaitGroup
 		errors := make(chan error, numGoroutines*iterations)
-
+		
 		for i := 0; i < numGoroutines; i++ {
 			wg.Add(1)
 			go func(workerID int) {
 				defer wg.Done()
-
+				
 				for j := 0; j < iterations; j++ {
 					_, err := Diff(source, target)
 					if err != nil {
@@ -344,34 +344,34 @@ func TestConcurrencySafety(t *testing.T) {
 				}
 			}(i)
 		}
-
+		
 		wg.Wait()
 		close(errors)
-
+		
 		// Check for any errors
 		for err := range errors {
 			t.Error(err)
 		}
 	})
-
+	
 	t.Run("concurrent_diff_application", func(t *testing.T) {
 		ctx := t.Context()
 		source, _ := util.DeterministicGenesisStateElectra(t, 16)
 		target := source.Copy()
 		_ = target.SetSlot(source.Slot() + 5)
-
+		
 		diff, err := Diff(source, target)
 		require.NoError(t, err)
-
+		
 		const numGoroutines = 10
 		var wg sync.WaitGroup
 		errors := make(chan error, numGoroutines)
-
+		
 		for i := 0; i < numGoroutines; i++ {
 			wg.Add(1)
 			go func(workerID int) {
 				defer wg.Done()
-
+				
 				// Each goroutine needs its own copy of the source state
 				localSource := source.Copy()
 				_, err := ApplyDiff(ctx, localSource, diff)
@@ -380,13 +380,13 @@ func TestConcurrencySafety(t *testing.T) {
 				}
 			}(i)
 		}
-
+		
 		wg.Wait()
 		close(errors)
-
+		
 		// Check for any errors
 		for err := range errors {
 			t.Error(err)
 		}
 	})
-}
+}

proto/engine/v1/engine.ssz.go

@@ -2,7 +2,7 @@
 package enginev1
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
@@ -3072,7 +3072,7 @@ func (w *Withdrawal) UnmarshalSSZ(buf []byte) error {
 	w.Index = ssz.UnmarshallUint64(buf[0:8])
 
 	// Field (1) 'ValidatorIndex'
-	w.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	w.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'Address'
 	if cap(w.Address) == 0 {

proto/eth/v1/gateway.ssz.go

@@ -2,7 +2,7 @@
 package v1
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
@@ -182,7 +182,7 @@ func (a *AggregateAttestationAndProof) UnmarshalSSZ(buf []byte) error {
 	var o1 uint64
 
 	// Field (0) 'AggregatorIndex'
-	a.AggregatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	a.AggregatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Offset (1) 'Aggregate'
 	if o1 = ssz.ReadOffset(buf[8:12]); o1 > size {
@@ -412,10 +412,10 @@ func (a *AttestationData) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	a.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	a.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Index'
-	a.Index = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[8:16]))
+	a.Index = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'BeaconBlockRoot'
 	if cap(a.BeaconBlockRoot) == 0 {
@@ -515,7 +515,7 @@ func (c *Checkpoint) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Epoch'
-	c.Epoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
+	c.Epoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Root'
 	if cap(c.Root) == 0 {
@@ -612,10 +612,10 @@ func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1582,10 +1582,10 @@ func (v *VoluntaryExit) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Epoch'
-	v.Epoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
+	v.Epoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ValidatorIndex'
-	v.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	v.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	return err
 }
@@ -1837,10 +1837,10 @@ func (b *BeaconBlockHeader) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -2400,16 +2400,16 @@ func (v *Validator) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'ActivationEligibilityEpoch'
-	v.ActivationEligibilityEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[89:97]))
+	v.ActivationEligibilityEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[89:97]))
 
 	// Field (5) 'ActivationEpoch'
-	v.ActivationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[97:105]))
+	v.ActivationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[97:105]))
 
 	// Field (6) 'ExitEpoch'
-	v.ExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[105:113]))
+	v.ExitEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[105:113]))
 
 	// Field (7) 'WithdrawableEpoch'
-	v.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[113:121]))
+	v.WithdrawableEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[113:121]))
 
 	return err
 }

proto/prysm/v1alpha1/altair.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
@@ -172,10 +172,10 @@ func (b *BeaconBlockAltair) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1160,7 +1160,7 @@ func (b *BeaconStateAltair) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -1713,7 +1713,7 @@ func (s *SyncAggregatorSelectionData) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	s.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	s.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'SubcommitteeIndex'
 	s.SubcommitteeIndex = ssz.UnmarshallUint64(buf[8:16])
@@ -2001,7 +2001,7 @@ func (l *LightClientUpdateAltair) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (6) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25360:25368]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25360:25368]))
 
 	return err
 }
@@ -2176,7 +2176,7 @@ func (l *LightClientFinalityUpdateAltair) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[576:584]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[576:584]))
 
 	return err
 }
@@ -2291,7 +2291,7 @@ func (l *LightClientOptimisticUpdateAltair) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[272:280]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[272:280]))
 
 	return err
 }
@@ -2432,7 +2432,7 @@ func (s *SyncCommitteeMessage) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	s.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	s.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'BlockRoot'
 	if cap(s.BlockRoot) == 0 {
@@ -2441,7 +2441,7 @@ func (s *SyncCommitteeMessage) UnmarshalSSZ(buf []byte) error {
 	s.BlockRoot = append(s.BlockRoot, buf[8:40]...)
 
 	// Field (2) 'ValidatorIndex'
-	s.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[40:48]))
+	s.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Signature'
 	if cap(s.Signature) == 0 {
@@ -2613,7 +2613,7 @@ func (c *ContributionAndProof) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'AggregatorIndex'
-	c.AggregatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	c.AggregatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Contribution'
 	if c.Contribution == nil {
@@ -2714,7 +2714,7 @@ func (s *SyncCommitteeContribution) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	s.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	s.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'BlockRoot'
 	if cap(s.BlockRoot) == 0 {

proto/prysm/v1alpha1/bellatrix.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -173,10 +173,10 @@ func (b *BeaconBlockBellatrix) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -919,10 +919,10 @@ func (b *BlindedBeaconBlockBellatrix) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1775,7 +1775,7 @@ func (b *BeaconStateBellatrix) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {

proto/prysm/v1alpha1/capella.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -173,10 +173,10 @@ func (b *BeaconBlockCapella) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -976,10 +976,10 @@ func (b *BlindedBeaconBlockCapella) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -2230,7 +2230,7 @@ func (b *BeaconStateCapella) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -2386,7 +2386,7 @@ func (b *BeaconStateCapella) UnmarshalSSZ(buf []byte) error {
 	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
 
 	// Offset (27) 'HistoricalSummaries'
 	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
@@ -3128,7 +3128,7 @@ func (l *LightClientUpdateCapella) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (6) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25144:25152]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25144:25152]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -3347,7 +3347,7 @@ func (l *LightClientFinalityUpdateCapella) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[360:368]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[360:368]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -3505,7 +3505,7 @@ func (l *LightClientOptimisticUpdateCapella) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[164:172]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[164:172]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -3829,7 +3829,7 @@ func (b *BLSToExecutionChange) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'ValidatorIndex'
-	b.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	b.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'FromBlsPubkey'
 	if cap(b.FromBlsPubkey) == 0 {

proto/prysm/v1alpha1/deneb.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -591,10 +591,10 @@ func (b *BeaconBlockDeneb) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1454,10 +1454,10 @@ func (b *BlindedBeaconBlockDeneb) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -3024,7 +3024,7 @@ func (b *BeaconStateDeneb) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -3180,7 +3180,7 @@ func (b *BeaconStateDeneb) UnmarshalSSZ(buf []byte) error {
 	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
 
 	// Offset (27) 'HistoricalSummaries'
 	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
@@ -3993,7 +3993,7 @@ func (l *LightClientUpdateDeneb) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (6) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25144:25152]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25144:25152]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -4212,7 +4212,7 @@ func (l *LightClientFinalityUpdateDeneb) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[360:368]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[360:368]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -4370,7 +4370,7 @@ func (l *LightClientOptimisticUpdateDeneb) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[164:172]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[164:172]))
 
 	// Field (0) 'AttestedHeader'
 	{

proto/prysm/v1alpha1/electra.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -163,7 +163,7 @@ func (a *AggregateAttestationAndProofElectra) UnmarshalSSZ(buf []byte) error {
 	var o1 uint64
 
 	// Field (0) 'AggregatorIndex'
-	a.AggregatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	a.AggregatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Offset (1) 'Aggregate'
 	if o1 = ssz.ReadOffset(buf[8:12]); o1 > size {
@@ -425,10 +425,10 @@ func (s *SingleAttestation) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'CommitteeId'
-	s.CommitteeId = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[0:8]))
+	s.CommitteeId = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'AttesterIndex'
-	s.AttesterIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	s.AttesterIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'Data'
 	if s.Data == nil {
@@ -1405,10 +1405,10 @@ func (b *BeaconBlockElectra) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -2307,10 +2307,10 @@ func (b *BlindedBeaconBlockElectra) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -3672,7 +3672,7 @@ func (b *BeaconStateElectra) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -3828,7 +3828,7 @@ func (b *BeaconStateElectra) UnmarshalSSZ(buf []byte) error {
 	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
 
 	// Offset (27) 'HistoricalSummaries'
 	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
@@ -3839,19 +3839,19 @@ func (b *BeaconStateElectra) UnmarshalSSZ(buf []byte) error {
 	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736653:2736661])
 
 	// Field (29) 'DepositBalanceToConsume'
-	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736661:2736669]))
+	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736661:2736669]))
 
 	// Field (30) 'ExitBalanceToConsume'
-	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736669:2736677]))
+	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736669:2736677]))
 
 	// Field (31) 'EarliestExitEpoch'
-	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736677:2736685]))
+	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736677:2736685]))
 
 	// Field (32) 'ConsolidationBalanceToConsume'
-	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736685:2736693]))
+	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736685:2736693]))
 
 	// Field (33) 'EarliestConsolidationEpoch'
-	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
+	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
 
 	// Offset (34) 'PendingDeposits'
 	if o34 = ssz.ReadOffset(buf[2736701:2736705]); o34 > size || o27 > o34 {
@@ -4510,7 +4510,7 @@ func (p *PendingDeposit) UnmarshalSSZ(buf []byte) error {
 	p.Signature = append(p.Signature, buf[88:184]...)
 
 	// Field (4) 'Slot'
-	p.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[184:192]))
+	p.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[184:192]))
 
 	return err
 }
@@ -4591,13 +4591,13 @@ func (p *PendingPartialWithdrawal) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Index'
-	p.Index = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	p.Index = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Amount'
 	p.Amount = ssz.UnmarshallUint64(buf[8:16])
 
 	// Field (2) 'WithdrawableEpoch'
-	p.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[16:24]))
+	p.WithdrawableEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[16:24]))
 
 	return err
 }
@@ -4657,10 +4657,10 @@ func (p *PendingConsolidation) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'SourceIndex'
-	p.SourceIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	p.SourceIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'TargetIndex'
-	p.TargetIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	p.TargetIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	return err
 }
@@ -4981,7 +4981,7 @@ func (l *LightClientUpdateElectra) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (6) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25208:25216]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[25208:25216]))
 
 	// Field (0) 'AttestedHeader'
 	{
@@ -5200,7 +5200,7 @@ func (l *LightClientFinalityUpdateElectra) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'SignatureSlot'
-	l.SignatureSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[392:400]))
+	l.SignatureSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[392:400]))
 
 	// Field (0) 'AttestedHeader'
 	{

proto/prysm/v1alpha1/fulu.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -700,10 +700,10 @@ func (b *BlindedBeaconBlockFulu) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1159,7 +1159,7 @@ func (b *BeaconStateFulu) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -1315,7 +1315,7 @@ func (b *BeaconStateFulu) UnmarshalSSZ(buf []byte) error {
 	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736641:2736649]))
 
 	// Offset (27) 'HistoricalSummaries'
 	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
@@ -1326,19 +1326,19 @@ func (b *BeaconStateFulu) UnmarshalSSZ(buf []byte) error {
 	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736653:2736661])
 
 	// Field (29) 'DepositBalanceToConsume'
-	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736661:2736669]))
+	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736661:2736669]))
 
 	// Field (30) 'ExitBalanceToConsume'
-	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736669:2736677]))
+	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736669:2736677]))
 
 	// Field (31) 'EarliestExitEpoch'
-	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736677:2736685]))
+	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736677:2736685]))
 
 	// Field (32) 'ConsolidationBalanceToConsume'
-	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736685:2736693]))
+	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736685:2736693]))
 
 	// Field (33) 'EarliestConsolidationEpoch'
-	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
+	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736693:2736701]))
 
 	// Offset (34) 'PendingDeposits'
 	if o34 = ssz.ReadOffset(buf[2736701:2736705]); o34 > size || o27 > o34 {
@@ -2429,7 +2429,7 @@ func (s *StatusV2) UnmarshalSSZ(buf []byte) error {
 	s.FinalizedRoot = append(s.FinalizedRoot, buf[4:36]...)
 
 	// Field (2) 'FinalizedEpoch'
-	s.FinalizedEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
+	s.FinalizedEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
 
 	// Field (3) 'HeadRoot'
 	if cap(s.HeadRoot) == 0 {
@@ -2438,10 +2438,10 @@ func (s *StatusV2) UnmarshalSSZ(buf []byte) error {
 	s.HeadRoot = append(s.HeadRoot, buf[44:76]...)
 
 	// Field (4) 'HeadSlot'
-	s.HeadSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[76:84]))
+	s.HeadSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[76:84]))
 
 	// Field (5) 'EarliestAvailableSlot'
-	s.EarliestAvailableSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[84:92]))
+	s.EarliestAvailableSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[84:92]))
 
 	return err
 }

proto/prysm/v1alpha1/gloas.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -102,13 +102,13 @@ func (e *ExecutionPayloadBid) UnmarshalSSZ(buf []byte) error {
 	e.GasLimit = ssz.UnmarshallUint64(buf[116:124])
 
 	// Field (5) 'BuilderIndex'
-	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[124:132]))
+	e.BuilderIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[124:132]))
 
 	// Field (6) 'Slot'
-	e.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[132:140]))
+	e.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[132:140]))
 
 	// Field (7) 'Value'
-	e.Value = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[140:148]))
+	e.Value = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[140:148]))
 
 	// Field (8) 'BlobKzgCommitmentsRoot'
 	if cap(e.BlobKzgCommitmentsRoot) == 0 {
@@ -311,7 +311,7 @@ func (p *PayloadAttestationData) UnmarshalSSZ(buf []byte) error {
 	p.BeaconBlockRoot = append(p.BeaconBlockRoot, buf[0:32]...)
 
 	// Field (1) 'Slot'
-	p.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[32:40]))
+	p.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[32:40]))
 
 	// Field (2) 'PayloadPresent'
 	p.PayloadPresent, err = ssz.DecodeBool(buf[40:41])
@@ -505,7 +505,7 @@ func (p *PayloadAttestationMessage) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'ValidatorIndex'
-	p.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	p.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Data'
 	if p.Data == nil {
@@ -615,10 +615,10 @@ func (b *BeaconBlockGloas) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1812,7 +1812,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -1971,7 +1971,7 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736809:2736817])
 
 	// Field (26) 'NextWithdrawalValidatorIndex'
-	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736817:2736825]))
+	b.NextWithdrawalValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[2736817:2736825]))
 
 	// Offset (27) 'HistoricalSummaries'
 	if o27 = ssz.ReadOffset(buf[2736825:2736829]); o27 > size || o21 > o27 {
@@ -1982,19 +1982,19 @@ func (b *BeaconStateGloas) UnmarshalSSZ(buf []byte) error {
 	b.DepositRequestsStartIndex = ssz.UnmarshallUint64(buf[2736829:2736837])
 
 	// Field (29) 'DepositBalanceToConsume'
-	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736837:2736845]))
+	b.DepositBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736837:2736845]))
 
 	// Field (30) 'ExitBalanceToConsume'
-	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736845:2736853]))
+	b.ExitBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736845:2736853]))
 
 	// Field (31) 'EarliestExitEpoch'
-	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736853:2736861]))
+	b.EarliestExitEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736853:2736861]))
 
 	// Field (32) 'ConsolidationBalanceToConsume'
-	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736861:2736869]))
+	b.ConsolidationBalanceToConsume = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[2736861:2736869]))
 
 	// Field (33) 'EarliestConsolidationEpoch'
-	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736869:2736877]))
+	b.EarliestConsolidationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[2736869:2736877]))
 
 	// Offset (34) 'PendingDeposits'
 	if o34 = ssz.ReadOffset(buf[2736877:2736881]); o34 > size || o27 > o34 {
@@ -2721,7 +2721,7 @@ func (b *BuilderPendingPayment) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Weight'
-	b.Weight = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[0:8]))
+	b.Weight = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Withdrawal'
 	if b.Withdrawal == nil {
@@ -2804,13 +2804,13 @@ func (b *BuilderPendingWithdrawal) UnmarshalSSZ(buf []byte) error {
 	b.FeeRecipient = append(b.FeeRecipient, buf[0:20]...)
 
 	// Field (1) 'Amount'
-	b.Amount = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[20:28]))
+	b.Amount = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Gwei(ssz.UnmarshallUint64(buf[20:28]))
 
 	// Field (2) 'BuilderIndex'
-	b.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[28:36]))
+	b.BuilderIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[28:36]))
 
 	// Field (3) 'WithdrawableEpoch'
-	b.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
+	b.WithdrawableEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
 
 	return err
 }
@@ -2961,7 +2961,7 @@ func (d *DataColumnSidecarGloas) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'Slot'
-	d.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[20:28]))
+	d.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[20:28]))
 
 	// Field (5) 'BeaconBlockRoot'
 	if cap(d.BeaconBlockRoot) == 0 {
@@ -3218,7 +3218,7 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'BuilderIndex'
-	e.BuilderIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	e.BuilderIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (3) 'BeaconBlockRoot'
 	if cap(e.BeaconBlockRoot) == 0 {
@@ -3227,7 +3227,7 @@ func (e *ExecutionPayloadEnvelope) UnmarshalSSZ(buf []byte) error {
 	e.BeaconBlockRoot = append(e.BeaconBlockRoot, buf[16:48]...)
 
 	// Field (4) 'Slot'
-	e.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[48:56]))
+	e.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[48:56]))
 
 	// Offset (5) 'BlobKzgCommitments'
 	if o5 = ssz.ReadOffset(buf[56:60]); o5 > size || o1 > o5 {

proto/prysm/v1alpha1/non-core.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	v1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
@@ -458,7 +458,7 @@ func (b *BeaconBlocksByRangeRequest) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'StartSlot'
-	b.StartSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.StartSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Count'
 	b.Count = ssz.UnmarshallUint64(buf[8:16])
@@ -786,7 +786,7 @@ func (b *BlobSidecarsByRangeRequest) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'StartSlot'
-	b.StartSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.StartSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Count'
 	b.Count = ssz.UnmarshallUint64(buf[8:16])
@@ -863,7 +863,7 @@ func (d *DataColumnSidecarsByRangeRequest) UnmarshalSSZ(buf []byte) error {
 	var o2 uint64
 
 	// Field (0) 'StartSlot'
-	d.StartSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	d.StartSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Count'
 	d.Count = ssz.UnmarshallUint64(buf[8:16])

proto/prysm/v1alpha1/phase0.ssz.go

@@ -2,7 +2,7 @@
 package eth
 
 import (
-	github_com_OffchainLabs_prysm_v7_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	github_com_OffchainLabs_prysm_v6_consensus_types_primitives "github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
@@ -162,7 +162,7 @@ func (a *AggregateAttestationAndProof) UnmarshalSSZ(buf []byte) error {
 	var o1 uint64
 
 	// Field (0) 'AggregatorIndex'
-	a.AggregatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	a.AggregatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Offset (1) 'Aggregate'
 	if o1 = ssz.ReadOffset(buf[8:12]); o1 > size {
@@ -412,10 +412,10 @@ func (a *AttestationData) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	a.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	a.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'CommitteeIndex'
-	a.CommitteeIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[8:16]))
+	a.CommitteeIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.CommitteeIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'BeaconBlockRoot'
 	if cap(a.BeaconBlockRoot) == 0 {
@@ -515,7 +515,7 @@ func (c *Checkpoint) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Epoch'
-	c.Epoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
+	c.Epoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Root'
 	if cap(c.Root) == 0 {
@@ -721,10 +721,10 @@ func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error {
 	var o4 uint64
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -1558,10 +1558,10 @@ func (b *BeaconBlockHeader) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ProposerIndex'
-	b.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	b.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	// Field (2) 'ParentRoot'
 	if cap(b.ParentRoot) == 0 {
@@ -2100,10 +2100,10 @@ func (v *VoluntaryExit) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Epoch'
-	v.Epoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
+	v.Epoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'ValidatorIndex'
-	v.ValidatorIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
+	v.ValidatorIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[8:16]))
 
 	return err
 }
@@ -2183,7 +2183,7 @@ func (f *Fork) UnmarshalSSZ(buf []byte) error {
 	f.CurrentVersion = append(f.CurrentVersion, buf[4:8]...)
 
 	// Field (2) 'Epoch'
-	f.Epoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[8:16]))
+	f.Epoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[8:16]))
 
 	return err
 }
@@ -2298,16 +2298,16 @@ func (v *Validator) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (4) 'ActivationEligibilityEpoch'
-	v.ActivationEligibilityEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[89:97]))
+	v.ActivationEligibilityEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[89:97]))
 
 	// Field (5) 'ActivationEpoch'
-	v.ActivationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[97:105]))
+	v.ActivationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[97:105]))
 
 	// Field (6) 'ExitEpoch'
-	v.ExitEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[105:113]))
+	v.ExitEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[105:113]))
 
 	// Field (7) 'WithdrawableEpoch'
-	v.WithdrawableEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[113:121]))
+	v.WithdrawableEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[113:121]))
 
 	return err
 }
@@ -2737,7 +2737,7 @@ func (b *BeaconState) UnmarshalSSZ(buf []byte) error {
 	b.GenesisValidatorsRoot = append(b.GenesisValidatorsRoot, buf[8:40]...)
 
 	// Field (2) 'Slot'
-	b.Slot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
+	b.Slot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[40:48]))
 
 	// Field (3) 'Fork'
 	if b.Fork == nil {
@@ -3301,10 +3301,10 @@ func (p *PendingAttestation) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (2) 'InclusionDelay'
-	p.InclusionDelay = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[132:140]))
+	p.InclusionDelay = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[132:140]))
 
 	// Field (3) 'ProposerIndex'
-	p.ProposerIndex = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[140:148]))
+	p.ProposerIndex = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[140:148]))
 
 	// Field (0) 'AggregationBits'
 	{
@@ -3898,7 +3898,7 @@ func (s *Status) UnmarshalSSZ(buf []byte) error {
 	s.FinalizedRoot = append(s.FinalizedRoot, buf[4:36]...)
 
 	// Field (2) 'FinalizedEpoch'
-	s.FinalizedEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
+	s.FinalizedEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[36:44]))
 
 	// Field (3) 'HeadRoot'
 	if cap(s.HeadRoot) == 0 {
@@ -3907,7 +3907,7 @@ func (s *Status) UnmarshalSSZ(buf []byte) error {
 	s.HeadRoot = append(s.HeadRoot, buf[44:76]...)
 
 	// Field (4) 'HeadSlot'
-	s.HeadSlot = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[76:84]))
+	s.HeadSlot = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Slot(ssz.UnmarshallUint64(buf[76:84]))
 
 	return err
 }
@@ -4008,7 +4008,7 @@ func (e *ENRForkID) UnmarshalSSZ(buf []byte) error {
 	e.NextForkVersion = append(e.NextForkVersion, buf[4:8]...)
 
 	// Field (2) 'NextForkEpoch'
-	e.NextForkEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[8:16]))
+	e.NextForkEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[8:16]))
 
 	return err
 }
@@ -4083,7 +4083,7 @@ func (v *ValidatorIdentity) UnmarshalSSZ(buf []byte) error {
 	}
 
 	// Field (0) 'Index'
-	v.Index = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
+	v.Index = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.ValidatorIndex(ssz.UnmarshallUint64(buf[0:8]))
 
 	// Field (1) 'Pubkey'
 	if cap(v.Pubkey) == 0 {
@@ -4092,7 +4092,7 @@ func (v *ValidatorIdentity) UnmarshalSSZ(buf []byte) error {
 	v.Pubkey = append(v.Pubkey, buf[8:56]...)
 
 	// Field (2) 'ActivationEpoch'
-	v.ActivationEpoch = github_com_OffchainLabs_prysm_v7_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[56:64]))
+	v.ActivationEpoch = github_com_OffchainLabs_prysm_v6_consensus_types_primitives.Epoch(ssz.UnmarshallUint64(buf[56:64]))
 
 	return err
 }

testing/spectest/shared/common/forkchoice/builder.go

@@ -41,7 +41,7 @@ func NewBuilder(t testing.TB, initialState state.BeaconState, initialBlock inter
 	getFork := func(targetEpoch primitives.Epoch) (*ethpb.Fork, error) {
 		return initialState.Fork(), nil
 	}
-	bvw := verification.NewInitializerWaiter(cw, fc, sg, service, verification.WithForkLookup(getFork))
+	bvw := verification.NewInitializerWaiter(cw, fc, sg, verification.WithForkLookup(getFork))
 	return &Builder{
 		service:  service,
 		execMock: execMock,

testing/util/deneb.go

@@ -58,10 +58,9 @@ func WithDenebSlot(slot primitives.Slot) DenebBlockGeneratorOption {
 
 func GenerateTestDenebBlockWithSidecar(t *testing.T, parent [32]byte, slot primitives.Slot, nblobs int, opts ...DenebBlockGeneratorOption) (blocks.ROBlock, []blocks.ROBlob) {
 	g := &denebBlockGenerator{
-		parent:   parent,
-		slot:     slot,
-		nblobs:   nblobs,
-		proposer: 3, // Anything else than zero not to fallback to the default uin64 value.
+		parent: parent,
+		slot:   slot,
+		nblobs: nblobs,
 	}
 	for _, o := range opts {
 		o(g)