Prefer checkpoint cache and NSC over head

beacon-chain/blockchain/process_attestation_helpers.go

@@ -92,10 +92,6 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 // getAttPreState retrieves the att pre state by either from the cache or the DB.
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (state.ReadOnlyBeaconState, error) {
-	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
-	if st := s.getRecentPreState(ctx, c); st != nil {
-		return st, nil
-	}
 	// Use a multilock to allow scoped holding of a mutex by a checkpoint root + epoch
 	// allowing us to behave smarter in terms of how this function is used concurrently.
 	epochKey := strconv.FormatUint(uint64(c.Epoch), 10 /* base 10 */)
@@ -128,6 +124,10 @@ func (s *Service) getAttPreState(ctx context.Context, c *ethpb.Checkpoint) (stat
 		}
 		return cachedState, nil
 	}
+	// If the attestation is recent and canonical we can use the head state to compute the shuffling.
+	if st := s.getRecentPreState(ctx, c); st != nil {
+		return st, nil
+	}
 
 	// Do not process attestations for old non viable checkpoints otherwise
 	ok, err := s.cfg.ForkChoiceStore.IsViableForCheckpoint(&forkchoicetypes.Checkpoint{Root: [32]byte(c.Root), Epoch: c.Epoch})

beacon-chain/core/gloas/BUILD.bazel

@@ -11,7 +11,6 @@ go_library(
         "payload_attestation.go",
         "pending_payment.go",
         "proposer_slashing.go",
-        "upgrade.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
     visibility = ["//visibility:public"],
@@ -21,7 +20,6 @@ go_library(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time: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:go_default_library",
@@ -51,13 +49,11 @@ go_test(
         "payload_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",
-        "upgrade_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/testing:go_default_library",

beacon-chain/core/gloas/upgrade.go

@@ -1,170 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	"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/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// UpgradeToGloas returns the Gloas state based on the generic input state.
-// https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/fork.md#upgrading-the-state
-func UpgradeToGloas(beaconState state.BeaconState) (state.BeaconState, error) {
-	s, err := ConvertToGloas(beaconState)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert to gloas")
-	}
-	return s, nil
-}
-
-func ConvertToGloas(beaconState state.BeaconState) (state.BeaconState, error) {
-	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSyncCommittee, err := beaconState.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	wi, err := beaconState.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	vi, err := beaconState.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	summaries, err := beaconState.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	depositRequestsStartIndex, err := beaconState.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	depositBalanceToConsume, err := beaconState.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	exitBalanceToConsume, err := beaconState.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	earliestExitEpoch, err := beaconState.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	consolidationBalanceToConsume, err := beaconState.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	earliestConsolidationEpoch, err := beaconState.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pendingDeposits, err := beaconState.PendingDeposits()
-	if err != nil {
-		return nil, err
-	}
-	pendingPartialWithdrawals, err := beaconState.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pendingConsolidations, err := beaconState.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-	pl, err := beaconState.ProposerLookahead()
-	if err != nil {
-		return nil, err
-	}
-	var proposerLookahead []uint64
-	for _, v := range pl {
-		proposerLookahead = append(proposerLookahead, uint64(v))
-	}
-	cfg := params.BeaconConfig()
-	executionPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-	for i := range executionPayloadAvailability {
-		executionPayloadAvailability[i] = 0xFF
-	}
-	s := &ethpb.BeaconStateGloas{
-		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
-		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
-		Slot:                  beaconState.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: beaconState.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().GloasForkVersion,
-			Epoch:           time.CurrentEpoch(beaconState),
-		},
-		LatestBlockHeader:           beaconState.LatestBlockHeader(),
-		BlockRoots:                  beaconState.BlockRoots(),
-		StateRoots:                  beaconState.StateRoots(),
-		HistoricalRoots:             beaconState.HistoricalRoots(),
-		Eth1Data:                    beaconState.Eth1Data(),
-		Eth1DataVotes:               beaconState.Eth1DataVotes(),
-		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
-		Validators:                  beaconState.Validators(),
-		Balances:                    beaconState.Balances(),
-		RandaoMixes:                 beaconState.RandaoMixes(),
-		Slashings:                   beaconState.Slashings(),
-		PreviousEpochParticipation:  prevEpochParticipation,
-		CurrentEpochParticipation:   currentEpochParticipation,
-		JustificationBits:           beaconState.JustificationBits(),
-		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
-		InactivityScores:            inactivityScores,
-		CurrentSyncCommittee:        currentSyncCommittee,
-		NextSyncCommittee:           nextSyncCommittee,
-
-		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-			ParentBlockHash: make([]byte, 32),
-			ParentBlockRoot: make([]byte, 32),
-			BlockHash:       payloadHeader.BlockHash(),
-			PrevRandao:      make([]byte, 32),
-			FeeRecipient:    make([]byte, 20),
-		},
-		NextWithdrawalIndex:           wi,
-		NextWithdrawalValidatorIndex:  vi,
-		HistoricalSummaries:           summaries,
-		DepositRequestsStartIndex:     depositRequestsStartIndex,
-		DepositBalanceToConsume:       depositBalanceToConsume,
-		ExitBalanceToConsume:          exitBalanceToConsume,
-		EarliestExitEpoch:             earliestExitEpoch,
-		ConsolidationBalanceToConsume: consolidationBalanceToConsume,
-		EarliestConsolidationEpoch:    earliestConsolidationEpoch,
-		PendingDeposits:               pendingDeposits,
-		PendingPartialWithdrawals:     pendingPartialWithdrawals,
-		PendingConsolidations:         pendingConsolidations,
-		ProposerLookahead:             proposerLookahead,
-
-		Builders:                     make([]*ethpb.Builder, 0),
-		NextWithdrawalBuilderIndex:   primitives.BuilderIndex(0),
-		ExecutionPayloadAvailability: executionPayloadAvailability,
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		BuilderPendingWithdrawals:    make([]*ethpb.BuilderPendingWithdrawal, 0),
-		LatestBlockHash:              payloadHeader.BlockHash(),
-		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
-	}
-	return state_native.InitializeFromProtoUnsafeGloas(s)
-}

beacon-chain/core/gloas/upgrade_test.go

@@ -1,190 +0,0 @@
-package gloas_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func TestUpgradeToGloas(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateFulu(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetHistoricalRoots([][]byte{{1}}))
-	vals := st.Validators()
-	vals[0].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-	vals[1].WithdrawalCredentials = []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}
-	require.NoError(t, st.SetValidators(vals))
-	bals := st.Balances()
-	bals[1] = params.BeaconConfig().MinActivationBalance + 1000
-	require.NoError(t, st.SetBalances(bals))
-	executionPayloadHeader, err := st.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	protoHeader, ok := executionPayloadHeader.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
-	require.Equal(t, true, ok)
-	protoHeader.BlockHash = bytes.Repeat([]byte{7}, 32)
-	newHeader, err := blocks.WrappedExecutionPayloadHeaderDeneb(protoHeader)
-	require.NoError(t, err)
-	require.NoError(t, st.SetLatestExecutionPayloadHeader(newHeader))
-
-	preForkState := st.Copy()
-	mSt, err := gloas.UpgradeToGloas(st)
-	require.NoError(t, err)
-
-	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
-	require.Equal(t, preForkState.Slot(), mSt.Slot())
-
-	f := mSt.Fork()
-	require.DeepSSZEqual(t, &ethpb.Fork{
-		PreviousVersion: st.Fork().CurrentVersion,
-		CurrentVersion:  params.BeaconConfig().GloasForkVersion,
-		Epoch:           time.CurrentEpoch(st),
-	}, f)
-
-	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
-	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
-	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
-
-	hr1 := preForkState.HistoricalRoots()
-	hr2 := mSt.HistoricalRoots()
-	require.DeepEqual(t, hr1, hr2)
-
-	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
-	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
-	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
-	require.DeepSSZEqual(t, preForkState.Validators(), mSt.Validators())
-	require.DeepSSZEqual(t, preForkState.Balances(), mSt.Balances())
-	require.DeepSSZEqual(t, preForkState.RandaoMixes(), mSt.RandaoMixes())
-	require.DeepSSZEqual(t, preForkState.Slashings(), mSt.Slashings())
-
-	numValidators := mSt.NumValidators()
-
-	p, err := mSt.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-
-	p, err = mSt.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-
-	require.DeepSSZEqual(t, preForkState.JustificationBits(), mSt.JustificationBits())
-	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), mSt.PreviousJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), mSt.CurrentJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), mSt.FinalizedCheckpoint())
-
-	s, err := mSt.InactivityScores()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
-
-	csc, err := mSt.CurrentSyncCommittee()
-	require.NoError(t, err)
-	psc, err := preForkState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, csc)
-
-	nsc, err := mSt.NextSyncCommittee()
-	require.NoError(t, err)
-	psc, err = preForkState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, nsc)
-
-	ph, err := st.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	blockHash := ph.BlockHash()
-	executionPayloadBid, err := mSt.LatestExecutionPayloadBid()
-	require.NoError(t, err)
-	newBlockHash := executionPayloadBid.BlockHash()
-
-	require.DeepSSZEqual(t, blockHash, newBlockHash[:])
-
-	nwi, err := mSt.NextWithdrawalIndex()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), nwi)
-
-	lwvi, err := mSt.NextWithdrawalValidatorIndex()
-	require.NoError(t, err)
-	require.Equal(t, primitives.ValidatorIndex(0), lwvi)
-
-	summaries, err := mSt.HistoricalSummaries()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(summaries))
-
-	preDepositRequestsStartIndex, err := preForkState.DepositRequestsStartIndex()
-	require.NoError(t, err)
-	postDepositRequestsStartIndex, err := mSt.DepositRequestsStartIndex()
-	require.NoError(t, err)
-	require.Equal(t, preDepositRequestsStartIndex, postDepositRequestsStartIndex)
-
-	preDepositBalanceToConsume, err := preForkState.DepositBalanceToConsume()
-	require.NoError(t, err)
-	postDepositBalanceToConsume, err := mSt.DepositBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, preDepositBalanceToConsume, postDepositBalanceToConsume)
-
-	preExitBalanceToConsume, err := preForkState.ExitBalanceToConsume()
-	require.NoError(t, err)
-	postExitBalanceToConsume, err := mSt.ExitBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, preExitBalanceToConsume, postExitBalanceToConsume)
-
-	preEarliestExitEpoch, err := preForkState.EarliestExitEpoch()
-	require.NoError(t, err)
-	postEarliestExitEpoch, err := mSt.EarliestExitEpoch()
-	require.NoError(t, err)
-	require.Equal(t, preEarliestExitEpoch, postEarliestExitEpoch)
-
-	preConsolidationBalanceToConsume, err := preForkState.ConsolidationBalanceToConsume()
-	require.NoError(t, err)
-	postConsolidationBalanceToConsume, err := mSt.ConsolidationBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, preConsolidationBalanceToConsume, postConsolidationBalanceToConsume)
-
-	preEarliesConsolidationEoch, err := preForkState.EarliestConsolidationEpoch()
-	require.NoError(t, err)
-	postEarliestConsolidationEpoch, err := mSt.EarliestConsolidationEpoch()
-	require.NoError(t, err)
-	require.Equal(t, preEarliesConsolidationEoch, postEarliestConsolidationEpoch)
-
-	prePendingDeposits, err := preForkState.PendingDeposits()
-	require.NoError(t, err)
-	postPendingDeposits, err := mSt.PendingDeposits()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, prePendingDeposits, postPendingDeposits)
-
-	prePendingPartialWithdrawals, err := preForkState.PendingPartialWithdrawals()
-	require.NoError(t, err)
-	postPendingPartialWithdrawals, err := mSt.PendingPartialWithdrawals()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, prePendingPartialWithdrawals, postPendingPartialWithdrawals)
-
-	prePendingConsolidations, err := preForkState.PendingConsolidations()
-	require.NoError(t, err)
-	postPendingConsolidations, err := mSt.PendingConsolidations()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, prePendingConsolidations, postPendingConsolidations)
-
-	_, err = mSt.Builder(0)
-	require.ErrorContains(t, "out of bounds", err)
-
-	for i := primitives.Slot(0); i < params.BeaconConfig().SlotsPerHistoricalRoot; i++ {
-		available, err := mSt.ExecutionPayloadAvailability(i)
-		require.NoError(t, err)
-		require.Equal(t, uint64(1), available)
-	}
-
-	bpp, err := mSt.BuilderPendingPayments()
-	require.NoError(t, err)
-	require.Equal(t, int(2*params.BeaconConfig().SlotsPerEpoch), len(bpp))
-
-	nbh, err := mSt.LatestBlockHash()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, blockHash, nbh[:])
-}

beacon-chain/core/time/slot_epoch.go

@@ -108,15 +108,6 @@ func CanUpgradeToFulu(slot primitives.Slot) bool {
 	return epochStart && fuluEpoch
 }
 
-// CanUpgradeToGloas returns true if the input `slot` can upgrade to Gloas.
-// Spec code:
-// If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == GLOAS_FORK_EPOCH
-func CanUpgradeToGloas(slot primitives.Slot) bool {
-	epochStart := slots.IsEpochStart(slot)
-	gloasEpoch := slots.ToEpoch(slot) == params.BeaconConfig().GloasForkEpoch
-	return epochStart && gloasEpoch
-}
-
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/transition/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/requests:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/transition/transition.go

@@ -17,7 +17,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/epoch/precompute"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/execution"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/fulu"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/features"
@@ -403,15 +402,6 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToGloas(slot) {
-		state, err = gloas.UpgradeToGloas(state)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return nil, err
-		}
-		upgraded = true
-	}
-
 	if upgraded {
 		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
 	}

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

@@ -83,7 +83,6 @@ func TestGetSpec(t *testing.T) {
 	config.ElectraForkEpoch = 107
 	config.FuluForkVersion = []byte("FuluForkVersion")
 	config.FuluForkEpoch = 109
-	config.GloasForkVersion = []byte("GloasForkVersion")
 	config.GloasForkEpoch = 110
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
@@ -222,7 +221,7 @@ func TestGetSpec(t *testing.T) {
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), &resp))
 	data, ok := resp.Data.(map[string]any)
 	require.Equal(t, true, ok)
-	assert.Equal(t, 193, len(data))
+	assert.Equal(t, 192, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -302,8 +301,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x"+hex.EncodeToString([]byte("FuluForkVersion")), v)
 			case "FULU_FORK_EPOCH":
 				assert.Equal(t, "109", v)
-			case "GLOAS_FORK_VERSION":
-				assert.Equal(t, "0x"+hex.EncodeToString([]byte("GloasForkVersion")), v)
 			case "GLOAS_FORK_EPOCH":
 				assert.Equal(t, "110", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":

changelog/bastin_gloas-state-upgrade.md

@@ -1,4 +0,0 @@
-### Added
-
-- Gloas Fork Version.
-- Gloas State Upgrade `UpgradeToGloas()`.

changelog/potuz_prefer_cached_over_head.md

@@ -0,0 +1,2 @@
+### Changed
+- Prefer the cached epoch transition states and the NSC ones over head state for attestation verification. 

config/params/config.go

@@ -192,7 +192,6 @@ type BeaconChainConfig struct {
 	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for electra.
 	FuluForkVersion      []byte           `yaml:"FULU_FORK_VERSION" spec:"true"`      // FuluForkVersion is used to represent the fork version for fulu.
 	FuluForkEpoch        primitives.Epoch `yaml:"FULU_FORK_EPOCH" spec:"true"`        // FuluForkEpoch is used to represent the assigned fork epoch for fulu.
-	GloasForkVersion     []byte           `yaml:"GLOAS_FORK_VERSION" spec:"true"`     // GloasForkVersion is used to represent the fork version for gloas.
 	GloasForkEpoch       primitives.Epoch `yaml:"GLOAS_FORK_EPOCH" spec:"true"`       // GloasForkEpoch is used to represent the assigned fork epoch for gloas.
 
 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.

config/params/interop.go

@@ -13,7 +13,6 @@ func InteropConfig() *BeaconChainConfig {
 	c.DenebForkVersion = []byte{4, 0, 0, 235}
 	c.ElectraForkVersion = []byte{5, 0, 0, 235}
 	c.FuluForkVersion = []byte{6, 0, 0, 235}
-	c.GloasForkVersion = []byte{7, 0, 0, 235}
 
 	c.InitializeForkSchedule()
 	return c

config/params/loader.go

@@ -225,7 +225,6 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("FULU_FORK_EPOCH: %d", cfg.FuluForkEpoch),
 		fmt.Sprintf("FULU_FORK_VERSION: %#x", cfg.FuluForkVersion),
 		fmt.Sprintf("GLOAS_FORK_EPOCH: %d", cfg.GloasForkEpoch),
-		fmt.Sprintf("GLOAS_FORK_VERSION: %#x", cfg.GloasForkVersion),
 		fmt.Sprintf("EPOCHS_PER_SUBNET_SUBSCRIPTION: %d", cfg.EpochsPerSubnetSubscription),
 		fmt.Sprintf("ATTESTATION_SUBNET_EXTRA_BITS: %d", cfg.AttestationSubnetExtraBits),
 		fmt.Sprintf("ATTESTATION_SUBNET_PREFIX_BITS: %d", cfg.AttestationSubnetPrefixBits),

config/params/loader_test.go

@@ -184,7 +184,6 @@ func assertEqualConfigs(t *testing.T, name string, fields []string, expected, ac
 	assert.DeepEqual(t, expected.DenebForkVersion, actual.DenebForkVersion, "%s: DenebForkVersion", name)
 	assert.DeepEqual(t, expected.ElectraForkVersion, actual.ElectraForkVersion, "%s: ElectraForkVersion", name)
 	assert.DeepEqual(t, expected.FuluForkVersion, actual.FuluForkVersion, "%s: FuluForkVersion", name)
-	assert.DeepEqual(t, expected.GloasForkVersion, actual.GloasForkVersion, "%s: GloasForkVersion", name)
 
 	assertYamlFieldsMatch(t, name, fields, expected, actual)
 }

config/params/mainnet_config.go

@@ -241,7 +241,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
 	FuluForkVersion:      []byte{6, 0, 0, 0},
 	FuluForkEpoch:        mainnetFuluForkEpoch,
-	GloasForkVersion:     []byte{7, 0, 0, 0},
 	GloasForkEpoch:       mainnetGloasForkEpoch,
 
 	// New values introduced in Altair hard fork 1.

config/params/minimal_config.go

@@ -103,7 +103,6 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ElectraForkEpoch = math.MaxUint64
 	minimalConfig.FuluForkVersion = []byte{6, 0, 0, 1}
 	minimalConfig.FuluForkEpoch = math.MaxUint64
-	minimalConfig.GloasForkVersion = []byte{7, 0, 0, 1}
 	minimalConfig.GloasForkEpoch = minimalConfig.FarFutureEpoch
 
 	minimalConfig.SyncCommitteeSize = 32