editing error handling

beacon-chain/core/altair/BUILD.bazel

@@ -20,7 +20,6 @@ go_library(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -17,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/attestation"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/pkg/errors"
 )
 
@@ -77,12 +75,7 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	beaconState, err = gloas.UpdatePendingPaymentWeight(beaconState, att, indices, participatedFlags)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to update pending payment weight")
-	}
-
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -112,9 +105,7 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool,
-	totalBalance uint64,
-	att ethpb.Att) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -308,40 +299,6 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
-
-	// Spec v1.7.0-alpha pseudocode:
-	//
-	//	# [New in Gloas:EIP7732]
-	//	if is_attestation_same_slot(state, data):
-	//	    assert data.index == 0
-	//	    payload_matches = True
-	//	else:
-	//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
-	//	    payload_index = state.execution_payload_availability[slot_index]
-	//	    payload_matches = data.index == payload_index
-	//
-	//	# [Modified in Gloas:EIP7732]
-	//	is_matching_head = is_matching_target and head_root_matches and payload_matches
-	var matchingPayload bool
-	if beaconState.Version() >= version.Gloas {
-		sameSlot, err := gloas.SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to get same slot attestation status")
-		}
-		if sameSlot {
-			if data.CommitteeIndex != 0 {
-				return nil, fmt.Errorf("committee index %d for same slot attestation must be 0", data.CommitteeIndex)
-			}
-			matchingPayload = true
-		} else {
-			executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(data.Slot)
-			if err != nil {
-				return nil, errors.Wrap(err, "failed to get execution payload availability status")
-			}
-			matchingPayload = executionPayloadAvail == uint64(data.CommitteeIndex)
-		}
-		matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
-	}
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,9 +1,7 @@
 package altair_test
 
 import (
-	"bytes"
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -558,7 +556,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -777,67 +775,11 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
-		{
-			name: "gloas same-slot committee index non-zero errors",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1, // invalid for same-slot
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay:           1,
-			participationIndices: nil,
-		},
-		{
-			name: "gloas payload availability matches committee index",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				// Same prev root to make SameSlotAttestation false and use payload availability.
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay: 1,
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
-		if test.participationIndices == nil {
-			require.ErrorContains(t, "committee index", err)
-			continue
-		}
 		require.NoError(t, err)
-		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
-			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
-		}
+		require.DeepEqual(t, test.participationIndices, flagIndices)
 	}
 }
 
@@ -916,61 +858,3 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
-
-func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	blockRoots[0] = targetRoot
-	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
-	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
-	byteIndex := idx / 8
-	bitIndex := idx % 8
-	if availabilityBit == 1 {
-		execPayloadAvailability[byteIndex] |= 1 << bitIndex
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Root: checkpointRoot}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return beaconState
-}

beacon-chain/core/altair/deposit.go

@@ -3,6 +3,7 @@ package altair
 import (
 	"context"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
@@ -23,7 +24,7 @@ func ProcessPreGenesisDeposits(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit")
 	}
-	beaconState, err = helpers.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
+	beaconState, err = blocks.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -36,7 +37,7 @@ func ProcessDeposits(
 	beaconState state.BeaconState,
 	deposits []*ethpb.Deposit,
 ) (state.BeaconState, error) {
-	allSignaturesVerified, err := helpers.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +82,7 @@ func ProcessDeposits(
 //	  signature=deposit.data.signature,
 //	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
-	if err := helpers.VerifyDeposit(beaconState, deposit); err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
 		}
@@ -121,7 +122,7 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSi
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
 		if !allSignaturesVerified {
-			valid, err := helpers.IsValidDepositSignature(data)
+			valid, err := blocks.IsValidDepositSignature(data)
 			if err != nil {
 				return nil, err
 			}

beacon-chain/core/blocks/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "attestation.go",
         "attester_slashing.go",
+        "deposit.go",
         "error.go",
         "eth1_data.go",
         "exit.go",
@@ -33,6 +34,8 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//container/trie:go_default_library",
+        "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -59,6 +62,7 @@ go_test(
         "attester_slashing_test.go",
         "block_operations_fuzz_test.go",
         "block_regression_test.go",
+        "deposit_test.go",
         "eth1_data_test.go",
         "exit_test.go",
         "exports_test.go",
@@ -87,6 +91,7 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",

beacon-chain/core/blocks/attestation.go

@@ -111,16 +111,7 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		// Spec v1.7.0-alpha pseudocode:
-		//
-		//	# [Modified in Gloas:EIP7732]
-		//	assert data.index < 2
-		//
-		if beaconState.Version() >= version.Gloas {
-			if att.GetData().CommitteeIndex >= 2 {
-				return fmt.Errorf("incorrect committee index %d", att.GetData().CommitteeIndex)
-			}
-		} else if att.GetData().CommitteeIndex != 0 {
+		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
 

beacon-chain/core/blocks/attestation_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"bytes"
 	"context"
 	"testing"
 
@@ -315,75 +314,6 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
-func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
-	cfg := params.BeaconConfig()
-	stateSlot := cfg.MinAttestationInclusionDelay + 1
-
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
-
-	gloasStateProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
-	require.NoError(t, err)
-
-	committeeBits := bitfield.NewBitvector64()
-	committeeBits.SetBitAt(0, true)
-	aggBits := bitfield.NewBitlist(1)
-	aggBits.SetBitAt(0, true)
-
-	att := &ethpb.AttestationElectra{
-		Data: &ethpb.AttestationData{
-			Slot:            0,
-			CommitteeIndex:  2, // invalid for Gloas (must be <2)
-			BeaconBlockRoot: blockRoots[0],
-			Source:          justified,
-			Target:          justified,
-		},
-		AggregationBits: aggBits,
-		CommitteeBits:   committeeBits,
-		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
-	}
-
-	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-	assert.ErrorContains(t, "incorrect committee index 2", err)
-}
-
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
@@ -653,7 +583,6 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 }
 
 func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) {
-	helpers.ClearCache()
 	ctx := t.Context()
 	numOfValidators := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(4))
 	validators := make([]*ethpb.Validator, numOfValidators)
@@ -661,25 +590,17 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	require.NoError(t, err)
 	for i := range validators {
 		validators[i] = &ethpb.Validator{
-			ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-			PublicKey:                  keys[i].PublicKey().Marshal(),
-			WithdrawalCredentials:      make([]byte, 32),
-			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             keys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
 		}
 	}
-	balances := make([]uint64, numOfValidators)
-	for i := range balances {
-		balances[i] = uint64(params.BeaconConfig().MaxEffectiveBalance)
-	}
 
 	t.Run("pre-Electra", func(t *testing.T) {
 		st, err := util.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, st.SetSlot(5))
 		require.NoError(t, st.SetValidators(validators))
-		require.NoError(t, st.SetBalances(balances))
 
 		comm1, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 		require.NoError(t, err)
@@ -729,7 +650,6 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 		require.NoError(t, err)
 		require.NoError(t, st.SetSlot(5))
 		require.NoError(t, st.SetValidators(validators))
-		require.NoError(t, st.SetBalances(balances))
 
 		comm1, err := helpers.BeaconCommitteeFromState(t.Context(), st, 1 /*slot*/, 0 /*committeeIndex*/)
 		require.NoError(t, err)

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -3,7 +3,6 @@ package blocks
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -319,7 +318,7 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		err = helpers.VerifyDeposit(s, deposit)
+		err = VerifyDeposit(s, deposit)
 		_ = err
 		fuzz.FreeMemory(i)
 	}

beacon-chain/core/blocks/deposit.go

@@ -1,4 +1,4 @@
-package helpers
+package blocks
 
 import (
 	"context"

beacon-chain/core/blocks/deposit_test.go

@@ -1,9 +1,9 @@
-package helpers_test
+package blocks_test
 
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -45,7 +45,7 @@ func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := helpers.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -68,7 +68,7 @@ func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := helpers.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
+	verified, err := blocks.BatchVerifyDepositsSignatures(t.Context(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }
@@ -99,7 +99,7 @@ func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
 	})
 	require.NoError(t, err)
 	want := "deposit root did not verify"
-	err = helpers.VerifyDeposit(beaconState, deposit)
+	err = blocks.VerifyDeposit(beaconState, deposit)
 	require.ErrorContains(t, want, err)
 }
 
@@ -123,7 +123,7 @@ func TestIsValidDepositSignature_Ok(t *testing.T) {
 	require.NoError(t, err)
 	sig := sk.Sign(sr[:])
 	depositData.Signature = sig.Marshal()
-	valid, err := helpers.IsValidDepositSignature(depositData)
+	valid, err := blocks.IsValidDepositSignature(depositData)
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 }
@@ -163,7 +163,7 @@ func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
 	sig2 := sk2.Sign(sr2[:])
 	pendingDeposit2.Signature = sig2.Marshal()
 
-	verified, err := helpers.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
 	require.NoError(t, err)
 	require.Equal(t, true, verified)
 }
@@ -174,7 +174,7 @@ func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
 		WithdrawalCredentials: make([]byte, 32),
 		Signature:             make([]byte, 96),
 	}
-	verified, err := helpers.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit})
+	verified, err := blocks.BatchVerifyPendingDepositsSignatures(t.Context(), []*ethpb.PendingDeposit{pendingDeposit})
 	require.NoError(t, err)
 	require.Equal(t, false, verified)
 }

beacon-chain/core/electra/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",

beacon-chain/core/electra/deposits.go

@@ -3,6 +3,7 @@ package electra
 import (
 	"context"
 
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -36,7 +37,7 @@ func ProcessDeposits(
 	defer span.End()
 	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
 	// individual deposits with signature verification enabled.
-	allSignaturesVerified, err := helpers.BatchVerifyDepositsSignatures(ctx, deposits)
+	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
 	}
@@ -81,7 +82,7 @@ func ProcessDeposits(
 //	  signature=deposit.data.signature,
 //	 )
 func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
-	if err := helpers.VerifyDeposit(beaconState, deposit); err != nil {
+	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
 		}
@@ -376,7 +377,7 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 		return nil
 	}
 
-	allSignaturesVerified, err := helpers.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
+	allSignaturesVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
 	if err != nil {
 		return errors.Wrap(err, "batch signature verification failed")
 	}
@@ -385,7 +386,7 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 		validSig := allSignaturesVerified
 
 		if !allSignaturesVerified {
-			validSig, err = helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+			validSig, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
 				PublicKey:             bytesutil.SafeCopyBytes(pd.PublicKey),
 				WithdrawalCredentials: bytesutil.SafeCopyBytes(pd.WithdrawalCredentials),
 				Amount:                pd.Amount,
@@ -440,7 +441,7 @@ func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *eth
 	defer span.End()
 	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(deposit.PublicKey))
 	if !ok {
-		verified, err := helpers.IsValidDepositSignature(&ethpb.Deposit_Data{
+		verified, err := blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
 			PublicKey:             bytesutil.SafeCopyBytes(deposit.PublicKey),
 			WithdrawalCredentials: bytesutil.SafeCopyBytes(deposit.WithdrawalCredentials),
 			Amount:                deposit.Amount,

beacon-chain/core/gloas/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "attestation.go",
         "bid.go",
         "pending_payment.go",
         "proposer_slashing.go",
@@ -22,7 +21,6 @@ go_library(
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -31,7 +29,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "attestation_test.go",
         "bid_test.go",
         "pending_payment_test.go",
         "proposer_slashing_test.go",

beacon-chain/core/gloas/attestation.go

@@ -1,153 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// SameSlotAttestation checks if the attestation is for the same slot as the block root in the state.
-// Spec v1.7.0-alpha pseudocode:
-//
-//	is_attestation_same_slot(state, data):
-//	    if data.slot == 0:
-//	        return True
-//
-//	    blockroot = data.beacon_block_root
-//	    slot_blockroot = get_block_root_at_slot(state, data.slot)
-//	    prev_blockroot = get_block_root_at_slot(state, Slot(data.slot - 1))
-//
-//	    return blockroot == slot_blockroot and blockroot != prev_blockroot
-func SameSlotAttestation(state state.ReadOnlyBeaconState, blockRoot [32]byte, slot primitives.Slot) (bool, error) {
-	if slot == 0 {
-		return true, nil
-	}
-
-	blockRootAtSlot, err := helpers.BlockRootAtSlot(state, slot)
-	if err != nil {
-		return false, errors.Wrapf(err, "block root at slot %d", slot)
-	}
-	matchingBlockRoot := bytes.Equal(blockRoot[:], blockRootAtSlot)
-
-	blockRootAtPrevSlot, err := helpers.BlockRootAtSlot(state, slot-1)
-	if err != nil {
-		return false, errors.Wrapf(err, "block root at slot %d", slot-1)
-	}
-	matchingPrevBlockRoot := bytes.Equal(blockRoot[:], blockRootAtPrevSlot)
-
-	return matchingBlockRoot && !matchingPrevBlockRoot, nil
-}
-
-// UpdatePendingPaymentWeight updates the builder pending payment weight based on attestation participation.
-// Spec v1.7.0-alpha pseudocode:
-//
-//	if data.target.epoch == get_current_epoch(state):
-//	    current_epoch_target = True
-//	    epoch_participation = state.current_epoch_participation
-//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH]
-//	else:
-//	    current_epoch_target = False
-//	    epoch_participation = state.previous_epoch_participation
-//	    payment = state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH]
-//
-//	proposer_reward_numerator = 0
-//	for index in get_attesting_indices(state, attestation):
-//	    will_set_new_flag = False
-//	    for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//	        if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//	            epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//	            proposer_reward_numerator += get_base_reward(state, index) * weight
-//	            # [New in Gloas:EIP7732]
-//	            will_set_new_flag = True
-//	    if (
-//	        will_set_new_flag
-//	        and is_attestation_same_slot(state, data)
-//	        and payment.withdrawal.amount > 0
-//	    ):
-//	        payment.weight += state.validators[index].effective_balance
-//	if current_epoch_target:
-//	    state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH] = payment
-//	else:
-//	    state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH] = payment
-func UpdatePendingPaymentWeight(beaconState state.BeaconState, att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) (state.BeaconState, error) {
-	if beaconState.Version() < version.Gloas {
-		return beaconState, nil
-	}
-
-	data := att.GetData()
-	epoch := slots.ToEpoch(beaconState.Slot())
-
-	isSameSlot, err := SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-	if err != nil {
-		return nil, errors.Wrap(err, "check same-slot attestation")
-	}
-	if !isSameSlot {
-		return beaconState, nil
-	}
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	var (
-		paymentSlot        primitives.Slot
-		payment            *ethpb.BuilderPendingPayment
-		epochParticipation []byte
-	)
-	if data.Target.Epoch == epoch {
-		paymentSlot = slotsPerEpoch + (data.Slot % slotsPerEpoch)
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, errors.Wrapf(err, "get builder pending payment at slot %d", paymentSlot)
-		}
-		epochParticipation, err = beaconState.CurrentEpochParticipation()
-		if err != nil {
-			return nil, errors.Wrap(err, "get current epoch participation")
-		}
-	} else {
-		paymentSlot = data.Slot % slotsPerEpoch
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, errors.Wrapf(err, "get builder pending payment at slot %d", paymentSlot)
-		}
-		epochParticipation, err = beaconState.PreviousEpochParticipation()
-		if err != nil {
-			return nil, errors.Wrap(err, "get previous epoch participation")
-		}
-	}
-	if payment.Withdrawal.Amount == 0 {
-		return beaconState, nil
-	}
-
-	cfg := params.BeaconConfig()
-	flagIndices := []uint8{cfg.TimelySourceFlagIndex, cfg.TimelyTargetFlagIndex, cfg.TimelyHeadFlagIndex}
-	for _, idx := range indices {
-		if idx >= uint64(len(epochParticipation)) {
-			return nil, errors.Errorf("index %d exceeds participation length %d", idx, len(epochParticipation))
-		}
-		participation := epochParticipation[idx]
-		for _, f := range flagIndices {
-			if !participatedFlags[f] {
-				continue
-			}
-			if participation&(1<<f) == 0 {
-				validator, err := beaconState.ValidatorAtIndex(primitives.ValidatorIndex(idx))
-				if err != nil {
-					return nil, errors.Wrapf(err, "validator at index %d", idx)
-				}
-				payment.Weight += primitives.Gwei(validator.EffectiveBalance)
-				break
-			}
-		}
-	}
-
-	if err := beaconState.SetBuilderPendingPayment(paymentSlot, payment); err != nil {
-		return nil, errors.Wrapf(err, "set builder pending payment at slot %d", paymentSlot)
-	}
-
-	return beaconState, nil
-}

beacon-chain/core/gloas/attestation_test.go

@@ -1,286 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	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"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x11}, 32)
-	}
-
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x22}, 32)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  stateSlot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x33}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x44}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x44}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{},
-		Balances:                     []uint64{},
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestSameSlotAttestation(t *testing.T) {
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-	rootC := bytes.Repeat([]byte{0xCC}, 32)
-
-	tests := []struct {
-		name      string
-		stateSlot primitives.Slot
-		slot      primitives.Slot
-		blockRoot []byte
-		roots     map[primitives.Slot][]byte
-		want      bool
-	}{
-		{
-			name:      "slot zero always true",
-			stateSlot: 1,
-			slot:      0,
-			blockRoot: rootA,
-			roots:     map[primitives.Slot][]byte{},
-			want:      true,
-		},
-		{
-			name:      "matching current different previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: true,
-		},
-		{
-			name:      "matching current same previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootA,
-			},
-			want: false,
-		},
-		{
-			name:      "non matching current",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootC,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			state := buildStateWithBlockRoots(t, tt.stateSlot, tt.roots)
-			var rootArr [32]byte
-			copy(rootArr[:], tt.blockRoot)
-
-			got, err := SameSlotAttestation(state, rootArr, tt.slot)
-			require.NoError(t, err)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func buildStateForPaymentTest(t *testing.T, stateSlot primitives.Slot, paymentIdx int, amount primitives.Gwei, weight primitives.Gwei, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-
-	validator := &ethpb.Validator{
-		PublicKey:             bytes.Repeat([]byte{0x01}, 48),
-		WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x02}, 31)...),
-		EffectiveBalance:      cfg.MinActivationBalance,
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-	payments[paymentIdx] = &ethpb.BuilderPendingPayment{
-		Weight: weight,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       amount,
-		},
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x33}, 32),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{validator},
-		Balances:                     []uint64{cfg.MinActivationBalance},
-		CurrentEpochParticipation:    []byte{0},
-		PreviousEpochParticipation:   []byte{0},
-		BuilderPendingPayments:       payments,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
-			Epoch:           0,
-		},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestUpdatePendingPaymentWeight(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := cfg.SlotsPerEpoch
-	slot := primitives.Slot(4)
-	stateSlot := slot + 1
-	currentEpoch := slots.ToEpoch(stateSlot)
-
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-
-	tests := []struct {
-		name          string
-		targetEpoch   primitives.Epoch
-		blockRoot     []byte
-		initialAmount primitives.Gwei
-		initialWeight primitives.Gwei
-		wantWeight    primitives.Gwei
-	}{
-		{
-			name:          "same slot current epoch adds weight",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 10,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-		{
-			name:          "same slot zero amount no weight change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 0,
-			initialWeight: 5,
-			wantWeight:    5,
-		},
-		{
-			name:          "non matching block root no change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootB,
-			initialAmount: 10,
-			initialWeight: 7,
-			wantWeight:    7,
-		},
-		{
-			name:          "previous epoch target uses earlier slot",
-			targetEpoch:   currentEpoch - 1,
-			blockRoot:     rootA,
-			initialAmount: 20,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var paymentIdx int
-			if tt.targetEpoch == currentEpoch {
-				paymentIdx = int(slotsPerEpoch + (slot % slotsPerEpoch))
-			} else {
-				paymentIdx = int(slot % slotsPerEpoch)
-			}
-			state := buildStateForPaymentTest(t, stateSlot, paymentIdx, tt.initialAmount, tt.initialWeight, map[primitives.Slot][]byte{
-				slot:     tt.blockRoot,
-				slot - 1: rootB,
-			})
-
-			att := &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					Slot:            slot,
-					CommitteeIndex:  0,
-					BeaconBlockRoot: tt.blockRoot,
-					Source:          &ethpb.Checkpoint{},
-					Target: &ethpb.Checkpoint{
-						Epoch: tt.targetEpoch,
-					},
-				},
-			}
-
-			participatedFlags := map[uint8]bool{
-				cfg.TimelySourceFlagIndex: true,
-				cfg.TimelyTargetFlagIndex: true,
-				cfg.TimelyHeadFlagIndex:   true,
-			}
-			indices := []uint64{0}
-
-			gotState, err := UpdatePendingPaymentWeight(state, att, indices, participatedFlags)
-			require.NoError(t, err)
-
-			payment, err := gotState.BuilderPendingPayment(uint64(paymentIdx))
-			require.NoError(t, err)
-			require.Equal(t, tt.wantWeight, payment.Weight)
-		})
-	}
-}

beacon-chain/core/helpers/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "attestation.go",
         "beacon_committee.go",
         "block.go",
-        "deposit.go",
         "genesis.go",
         "legacy.go",
         "log.go",
@@ -24,7 +23,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -33,7 +31,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//container/trie:go_default_library",
-        "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -57,7 +54,6 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
-        "deposit_test.go",
         "legacy_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
@@ -76,7 +72,6 @@ go_test(
     tags = ["CI_race_detection"],
     deps = [
         "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -85,8 +80,6 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
-        "//container/trie:go_default_library",
-        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

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

@@ -8,7 +8,6 @@ import (
 	"io"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api"
@@ -26,7 +25,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v7/network/httputil"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -1044,112 +1042,27 @@ func (s *Server) GetBlockRoot(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockRoot")
 	defer span.End()
 
-	var err error
-	var root []byte
 	blockID := r.PathValue("block_id")
 	if blockID == "" {
 		httputil.HandleError(w, "block_id is required in URL params", http.StatusBadRequest)
 		return
 	}
-	switch blockID {
-	case "head":
-		root, err = s.ChainInfoFetcher.HeadRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not retrieve head root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		if root == nil {
-			httputil.HandleError(w, "No head root was found", http.StatusNotFound)
-			return
-		}
-	case "finalized":
-		finalized := s.ChainInfoFetcher.FinalizedCheckpt()
-		root = finalized.Root
-	case "genesis":
-		blk, err := s.BeaconDB.GenesisBlock(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not retrieve genesis block: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		if err := blocks.BeaconBlockIsNil(blk); err != nil {
-			httputil.HandleError(w, "Could not find genesis block: "+err.Error(), http.StatusNotFound)
-			return
-		}
-		blkRoot, err := blk.Block().HashTreeRoot()
-		if err != nil {
-			httputil.HandleError(w, "Could not hash genesis block: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		root = blkRoot[:]
-	default:
-		isHex := strings.HasPrefix(blockID, "0x")
-		if isHex {
-			blockIDBytes, err := hexutil.Decode(blockID)
-			if err != nil {
-				httputil.HandleError(w, "Could not decode block ID into bytes: "+err.Error(), http.StatusBadRequest)
-				return
-			}
-			if len(blockIDBytes) != fieldparams.RootLength {
-				httputil.HandleError(w, fmt.Sprintf("Block ID has length %d instead of %d", len(blockIDBytes), fieldparams.RootLength), http.StatusBadRequest)
-				return
-			}
-			blockID32 := bytesutil.ToBytes32(blockIDBytes)
-			blk, err := s.BeaconDB.Block(ctx, blockID32)
-			if err != nil {
-				httputil.HandleError(w, fmt.Sprintf("Could not retrieve block for block root %#x: %v", blockID, err), http.StatusInternalServerError)
-				return
-			}
-			if err := blocks.BeaconBlockIsNil(blk); err != nil {
-				httputil.HandleError(w, "Could not find block: "+err.Error(), http.StatusNotFound)
-				return
-			}
-			root = blockIDBytes
-		} else {
-			slot, err := strconv.ParseUint(blockID, 10, 64)
-			if err != nil {
-				httputil.HandleError(w, "Could not parse block ID: "+err.Error(), http.StatusBadRequest)
-				return
-			}
-			hasRoots, roots, err := s.BeaconDB.BlockRootsBySlot(ctx, primitives.Slot(slot))
-			if err != nil {
-				httputil.HandleError(w, fmt.Sprintf("Could not retrieve blocks for slot %d: %v", slot, err), http.StatusInternalServerError)
-				return
-			}
-
-			if !hasRoots {
-				httputil.HandleError(w, "Could not find any blocks with given slot", http.StatusNotFound)
-				return
-			}
-			root = roots[0][:]
-			if len(roots) == 1 {
-				break
-			}
-			for _, blockRoot := range roots {
-				canonical, err := s.ChainInfoFetcher.IsCanonical(ctx, blockRoot)
-				if err != nil {
-					httputil.HandleError(w, "Could not determine if block root is canonical: "+err.Error(), http.StatusInternalServerError)
-					return
-				}
-				if canonical {
-					root = blockRoot[:]
-					break
-				}
-			}
-		}
+	root, err := s.Blocker.BlockRoot(ctx, []byte(blockID))
+	if !shared.WriteBlockRootFetchError(w, err) {
+		return
 	}
 
-	b32Root := bytesutil.ToBytes32(root)
-	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, b32Root)
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
 	if err != nil {
 		httputil.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 	response := &structs.BlockRootResponse{
 		Data: &structs.BlockRoot{
-			Root: hexutil.Encode(root),
+			Root: hexutil.Encode(root[:]),
 		},
 		ExecutionOptimistic: isOptimistic,
-		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, b32Root),
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, root),
 	}
 	httputil.WriteJson(w, response)
 }

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

@@ -2509,6 +2509,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 
 		root, err := genBlk.Block.HashTreeRoot()
@@ -2524,7 +2528,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "bad formatting",
 				blockID:  map[string]string{"block_id": "3bad0"},
-				wantErr:  "Could not parse block ID",
+				wantErr:  "Invalid block ID",
 				wantCode: http.StatusBadRequest,
 			},
 			{
@@ -2572,7 +2576,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "non-existent root",
 				blockID:  map[string]string{"block_id": hexutil.Encode(bytesutil.PadTo([]byte("hi there"), 32))},
-				wantErr:  "Could not find block",
+				wantErr:  "Block not found",
 				wantCode: http.StatusNotFound,
 			},
 			{
@@ -2585,7 +2589,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "no block",
 				blockID:  map[string]string{"block_id": "105"},
-				wantErr:  "Could not find any blocks with given slot",
+				wantErr:  "Block not found",
 				wantCode: http.StatusNotFound,
 			},
 		}
@@ -2633,6 +2637,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 
 		request := httptest.NewRequest(http.MethodGet, url, nil)
@@ -2668,6 +2676,10 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
+			Blocker: &lookup.BeaconDbBlocker{
+				BeaconDB:         beaconDB,
+				ChainInfoFetcher: mockChainFetcher,
+			},
 		}
 		t.Run("true", func(t *testing.T) {
 			request := httptest.NewRequest(http.MethodGet, url, nil)

beacon-chain/rpc/eth/shared/errors.go

@@ -26,21 +26,30 @@ func WriteStateFetchError(w http.ResponseWriter, err error) {
 	httputil.HandleError(w, "Could not get state: "+err.Error(), http.StatusInternalServerError)
 }
 
-// WriteBlockFetchError writes an appropriate error based on the supplied argument.
-// The argument error should be a result of fetching block.
-func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock, err error) bool {
+// writeBlockIdError handles common block ID lookup errors.
+// Returns true if an error was handled and written to the response, false if no error.
+func writeBlockIdError(w http.ResponseWriter, err error, fallbackMsg string) bool {
+	if err == nil {
+		return false
+	}
 	var blockNotFoundErr *lookup.BlockNotFoundError
 	if errors.As(err, &blockNotFoundErr) {
 		httputil.HandleError(w, "Block not found: "+blockNotFoundErr.Error(), http.StatusNotFound)
-		return false
+		return true
 	}
 	var invalidBlockIdErr *lookup.BlockIdParseError
 	if errors.As(err, &invalidBlockIdErr) {
 		httputil.HandleError(w, "Invalid block ID: "+invalidBlockIdErr.Error(), http.StatusBadRequest)
-		return false
+		return true
 	}
-	if err != nil {
-		httputil.HandleError(w, "Could not get block from block ID: "+err.Error(), http.StatusInternalServerError)
+	httputil.HandleError(w, fallbackMsg+err.Error(), http.StatusInternalServerError)
+	return true
+}
+
+// WriteBlockFetchError writes an appropriate error based on the supplied argument.
+// The argument error should be a result of fetching block.
+func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBeaconBlock, err error) bool {
+	if writeBlockIdError(w, err, "Could not get block from block ID: ") {
 		return false
 	}
 	if err = blocks.BeaconBlockIsNil(blk); err != nil {
@@ -49,3 +58,10 @@ func WriteBlockFetchError(w http.ResponseWriter, blk interfaces.ReadOnlySignedBe
 	}
 	return true
 }
+
+// WriteBlockRootFetchError writes an appropriate error based on the supplied argument.
+// The argument error should be a result of fetching block root.
+// Returns true if no error occurred, false otherwise.
+func WriteBlockRootFetchError(w http.ResponseWriter, err error) bool {
+	return !writeBlockIdError(w, err, "Could not get block root from block ID: ")
+}

beacon-chain/rpc/eth/shared/errors_test.go

@@ -105,3 +105,59 @@ func TestWriteBlockFetchError(t *testing.T) {
 		})
 	}
 }
+
+// TestWriteBlockRootFetchError tests the WriteBlockRootFetchError function
+// to ensure that the correct error message and code are written to the response
+// and that the function returns the correct boolean value.
+func TestWriteBlockRootFetchError(t *testing.T) {
+	cases := []struct {
+		name            string
+		err             error
+		expectedMessage string
+		expectedCode    int
+		expectedReturn  bool
+	}{
+		{
+			name:           "Nil error should return true",
+			err:            nil,
+			expectedReturn: true,
+		},
+		{
+			name:            "BlockNotFoundError should return 404",
+			err:             lookup.NewBlockNotFoundError("block not found at slot 123"),
+			expectedMessage: "Block not found",
+			expectedCode:    http.StatusNotFound,
+			expectedReturn:  false,
+		},
+		{
+			name:            "BlockIdParseError should return 400",
+			err:             &lookup.BlockIdParseError{},
+			expectedMessage: "Invalid block ID",
+			expectedCode:    http.StatusBadRequest,
+			expectedReturn:  false,
+		},
+		{
+			name:            "Generic error should return 500",
+			err:             errors.New("database connection failed"),
+			expectedMessage: "Could not get block root from block ID",
+			expectedCode:    http.StatusInternalServerError,
+			expectedReturn:  false,
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			writer := httptest.NewRecorder()
+			result := WriteBlockRootFetchError(writer, c.err)
+
+			assert.Equal(t, c.expectedReturn, result, "incorrect return value")
+			if !c.expectedReturn {
+				assert.Equal(t, c.expectedCode, writer.Code, "incorrect status code")
+				assert.StringContains(t, c.expectedMessage, writer.Body.String(), "incorrect error message")
+
+				e := &httputil.DefaultJsonError{}
+				assert.NoError(t, json.Unmarshal(writer.Body.Bytes(), e), "failed to unmarshal response")
+			}
+		})
+	}
+}

beacon-chain/rpc/lookup/blocker.go

@@ -60,6 +60,7 @@ func (e BlockIdParseError) Error() string {
 // Blocker is responsible for retrieving blocks.
 type Blocker interface {
 	Block(ctx context.Context, id []byte) (interfaces.ReadOnlySignedBeaconBlock, error)
+	BlockRoot(ctx context.Context, id []byte) ([fieldparams.RootLength]byte, error)
 	BlobSidecars(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError)
 	Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([][]byte, *core.RpcError)
 	DataColumns(ctx context.Context, id string, indices []int) ([]blocks.VerifiedRODataColumn, *core.RpcError)
@@ -225,6 +226,19 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 	return blk, nil
 }
 
+// BlockRoot returns the block root for a given identifier. The identifier can be one of:
+//   - "head" (canonical head in node's view)
+//   - "genesis"
+//   - "finalized"
+//   - "justified"
+//   - <slot>
+//   - <hex encoded block root with '0x' prefix>
+//   - <block root>
+func (p *BeaconDbBlocker) BlockRoot(ctx context.Context, id []byte) ([fieldparams.RootLength]byte, error) {
+	root, _, err := p.resolveBlockID(ctx, string(id))
+	return root, err
+}
+
 // blobsContext holds common information needed for blob retrieval
 type blobsContext struct {
 	root        [fieldparams.RootLength]byte

beacon-chain/rpc/lookup/blocker_test.go

@@ -168,6 +168,111 @@ func TestGetBlock(t *testing.T) {
 	}
 }
 
+func TestBlockRoot(t *testing.T) {
+	beaconDB := testDB.SetupDB(t)
+	ctx := t.Context()
+
+	genBlk, blkContainers := testutil.FillDBWithBlocks(ctx, t, beaconDB)
+	canonicalRoots := make(map[[32]byte]bool)
+
+	for _, bContr := range blkContainers {
+		canonicalRoots[bytesutil.ToBytes32(bContr.BlockRoot)] = true
+	}
+	headBlock := blkContainers[len(blkContainers)-1]
+
+	wsb, err := blocks.NewSignedBeaconBlock(headBlock.Block.(*ethpb.BeaconBlockContainer_Phase0Block).Phase0Block)
+	require.NoError(t, err)
+
+	fetcher := &BeaconDbBlocker{
+		BeaconDB: beaconDB,
+		ChainInfoFetcher: &mockChain.ChainService{
+			DB:                         beaconDB,
+			Block:                      wsb,
+			Root:                       headBlock.BlockRoot,
+			FinalizedCheckPoint:        &ethpb.Checkpoint{Root: blkContainers[64].BlockRoot},
+			CurrentJustifiedCheckPoint: &ethpb.Checkpoint{Root: blkContainers[32].BlockRoot},
+			CanonicalRoots:             canonicalRoots,
+		},
+	}
+
+	genesisRoot, err := genBlk.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		blockID []byte
+		want    [32]byte
+		wantErr bool
+	}{
+		{
+			name:    "slot",
+			blockID: []byte("30"),
+			want:    bytesutil.ToBytes32(blkContainers[30].BlockRoot),
+		},
+		{
+			name:    "bad formatting",
+			blockID: []byte("3bad0"),
+			wantErr: true,
+		},
+		{
+			name:    "head",
+			blockID: []byte("head"),
+			want:    bytesutil.ToBytes32(headBlock.BlockRoot),
+		},
+		{
+			name:    "finalized",
+			blockID: []byte("finalized"),
+			want:    bytesutil.ToBytes32(blkContainers[64].BlockRoot),
+		},
+		{
+			name:    "justified",
+			blockID: []byte("justified"),
+			want:    bytesutil.ToBytes32(blkContainers[32].BlockRoot),
+		},
+		{
+			name:    "genesis",
+			blockID: []byte("genesis"),
+			want:    genesisRoot,
+		},
+		{
+			name:    "genesis root",
+			blockID: genesisRoot[:],
+			want:    genesisRoot,
+		},
+		{
+			name:    "root",
+			blockID: blkContainers[20].BlockRoot,
+			want:    bytesutil.ToBytes32(blkContainers[20].BlockRoot),
+		},
+		{
+			name:    "hex root",
+			blockID: []byte(hexutil.Encode(blkContainers[20].BlockRoot)),
+			want:    bytesutil.ToBytes32(blkContainers[20].BlockRoot),
+		},
+		{
+			name:    "non-existent root",
+			blockID: bytesutil.PadTo([]byte("hi there"), 32),
+			wantErr: true,
+		},
+		{
+			name:    "no block at slot",
+			blockID: []byte("105"),
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := fetcher.BlockRoot(ctx, tt.blockID)
+			if tt.wantErr {
+				assert.NotEqual(t, err, nil, "no error has been returned")
+				return
+			}
+			require.NoError(t, err)
+			assert.DeepEqual(t, tt.want, result)
+		})
+	}
+}
+
 func TestBlobsErrorHandling(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig().Copy()

beacon-chain/rpc/testutil/mock_blocker.go

@@ -15,6 +15,7 @@ import (
 // MockBlocker is a fake implementation of lookup.Blocker.
 type MockBlocker struct {
 	BlockToReturn            interfaces.ReadOnlySignedBeaconBlock
+	RootToReturn             [32]byte
 	ErrorToReturn            error
 	SlotBlockMap             map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock
 	RootBlockMap             map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
@@ -39,6 +40,14 @@ func (m *MockBlocker) Block(_ context.Context, b []byte) (interfaces.ReadOnlySig
 	return m.SlotBlockMap[primitives.Slot(slotNumber)], nil
 }
 
+// BlockRoot --
+func (m *MockBlocker) BlockRoot(_ context.Context, _ []byte) ([32]byte, error) {
+	if m.ErrorToReturn != nil {
+		return [32]byte{}, m.ErrorToReturn
+	}
+	return m.RootToReturn, nil
+}
+
 // BlobSidecars --
 func (*MockBlocker) BlobSidecars(_ context.Context, _ string, _ ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
 	return nil, &core.RpcError{}

beacon-chain/state/interfaces_gloas.go

@@ -20,7 +20,5 @@ type readOnlyGloasFields interface {
 	IsActiveBuilder(primitives.BuilderIndex) (bool, error)
 	CanBuilderCoverBid(primitives.BuilderIndex, primitives.Gwei) (bool, error)
 	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error)
 	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-	ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error)
 }

beacon-chain/state/state-native/getters_gloas.go

@@ -147,36 +147,3 @@ func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment,
 
 	return b.builderPendingPaymentsVal(), nil
 }
-
-// BuilderPendingPayment returns the builder pending payment for the given index.
-func (b *BeaconState) BuilderPendingPayment(index uint64) (*ethpb.BuilderPendingPayment, error) {
-	if b.version < version.Gloas {
-		return nil, errNotSupported("BuilderPendingPayment", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if index >= uint64(len(b.builderPendingPayments)) {
-		return nil, fmt.Errorf("builder pending payment index %d out of range (len=%d)", index, len(b.builderPendingPayments))
-	}
-	return ethpb.CopyBuilderPendingPayment(b.builderPendingPayments[index]), nil
-}
-
-// ExecutionPayloadAvailability returns the execution payload availability bit for the given slot.
-func (b *BeaconState) ExecutionPayloadAvailability(slot primitives.Slot) (uint64, error) {
-	if b.version < version.Gloas {
-		return 0, errNotSupported("ExecutionPayloadAvailability", b.version)
-	}
-
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	slotIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := slotIndex / 8
-	bitIndex := slotIndex % 8
-
-	bit := (b.executionPayloadAvailability[byteIndex] >> bitIndex) & 1
-
-	return uint64(bit), nil
-}

beacon-chain/state/state-native/getters_gloas_test.go

@@ -166,77 +166,3 @@ func TestBuilderPendingPayments_UnsupportedVersion(t *testing.T) {
 	_, err = st.BuilderPendingPayments()
 	require.ErrorContains(t, "BuilderPendingPayments", err)
 }
-
-func TestBuilderPendingPayment_ReturnsCopy(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	payments := make([]*ethpb.BuilderPendingPayment, 2*slotsPerEpoch)
-	target := uint64(slotsPerEpoch + 1)
-	payments[target] = &ethpb.BuilderPendingPayment{Weight: 10}
-
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-		BuilderPendingPayments: payments,
-	})
-	require.NoError(t, err)
-
-	payment, err := st.BuilderPendingPayment(target)
-	require.NoError(t, err)
-
-	// mutate returned copy
-	payment.Weight = 99
-
-	original, err := st.BuilderPendingPayment(target)
-	require.NoError(t, err)
-	require.Equal(t, uint64(10), uint64(original.Weight))
-}
-
-func TestBuilderPendingPayment_UnsupportedVersion(t *testing.T) {
-	stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-	require.NoError(t, err)
-	st := stIface.(*state_native.BeaconState)
-
-	_, err = st.BuilderPendingPayment(0)
-	require.ErrorContains(t, "BuilderPendingPayment", err)
-}
-
-func TestBuilderPendingPayment_OutOfRange(t *testing.T) {
-	stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-		BuilderPendingPayments: []*ethpb.BuilderPendingPayment{},
-	})
-	require.NoError(t, err)
-
-	_, err = stIface.BuilderPendingPayment(0)
-	require.ErrorContains(t, "out of range", err)
-}
-
-func TestExecutionPayloadAvailability(t *testing.T) {
-	t.Run("unsupported version", func(t *testing.T) {
-		stIface, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{})
-		require.NoError(t, err)
-		st := stIface.(*state_native.BeaconState)
-
-		_, err = st.ExecutionPayloadAvailability(0)
-		require.ErrorContains(t, "ExecutionPayloadAvailability", err)
-	})
-
-	t.Run("reads expected bit", func(t *testing.T) {
-		// Ensure the backing slice is large enough.
-		availability := make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8)
-
-		// Pick a slot and set its corresponding bit.
-		slot := primitives.Slot(9) // byteIndex=1, bitIndex=1
-		availability[1] = 0b00000010
-
-		stIface, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{
-			ExecutionPayloadAvailability: availability,
-		})
-		require.NoError(t, err)
-
-		bit, err := stIface.ExecutionPayloadAvailability(slot)
-		require.NoError(t, err)
-		require.Equal(t, uint64(1), bit)
-
-		otherBit, err := stIface.ExecutionPayloadAvailability(8)
-		require.NoError(t, err)
-		require.Equal(t, uint64(0), otherBit)
-	})
-}

beacon-chain/state/testing/BUILD.bazel

@@ -16,7 +16,7 @@ go_library(
         "//beacon-chain/state:__subpackages__",
     ],
     deps = [
-        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",

beacon-chain/state/testing/generators.go

@@ -3,7 +3,7 @@ package testing
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -31,7 +31,7 @@ func GeneratePendingDeposit(t *testing.T, key common.SecretKey, amount uint64, w
 		Amount:                dm.Amount,
 		Signature:             sig.Marshal(),
 	}
-	valid, err := helpers.IsValidDepositSignature(depositData)
+	valid, err := blocks.IsValidDepositSignature(depositData)
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 	return &ethpb.PendingDeposit{

changelog/james-prysm_blocker-for-block-root.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- optmizing /eth/v1/beacon/blocks/{block_id}/root endpoint by reusing blocker lookup instead of duplicated logic.

changelog/t_gloas-process-attestations.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added process attestation for gloas

changelog/terencechain_move-deposit-to-helpers.md

@@ -1,2 +0,0 @@
-### Ignored
-- Move deposit helpers from `beacon-chain/core/blocks` to `beacon-chain/core/helpers` (refactor only).

specrefs/functions.yml

@@ -4230,7 +4230,7 @@
   sources:
     - file: beacon-chain/core/electra/deposits.go
       search: func IsValidDepositSignature(
-    - file: beacon-chain/core/helpers/deposit.go
+    - file: beacon-chain/core/blocks/deposit.go
       search: func IsValidDepositSignature(
   spec: |
     <spec fn="is_valid_deposit_signature" fork="electra" hash="7347b754">

testing/spectest/mainnet/BUILD.bazel

@@ -201,7 +201,6 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_header_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",

testing/spectest/mainnet/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package mainnet
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMainnet_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "mainnet")
-}

testing/spectest/minimal/BUILD.bazel

@@ -207,7 +207,6 @@ go_test(
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
         "gloas__epoch_processing__process_builder_pending_payments_test.go",
-        "gloas__operations__attestation_test.go",
         "gloas__operations__execution_payload_bid_test.go",
         "gloas__operations__proposer_slashing_test.go",
         "gloas__sanity__slots_test.go",

testing/spectest/minimal/gloas__operations__attestation_test.go

@@ -1,11 +0,0 @@
-package minimal
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
-)
-
-func TestMinimal_Gloas_Operations_Attestation(t *testing.T) {
-	operations.RunAttestationTest(t, "minimal")
-}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     testonly = True,
     srcs = [
-        "attestation.go",
         "execution_payload_bid.go",
         "helpers.go",
         "proposer_slashing.go",
@@ -12,7 +11,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//consensus-types/blocks:go_default_library",

testing/spectest/shared/gloas/operations/attestation.go

@@ -1,26 +0,0 @@
-package operations
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
-)
-
-func blockWithAttestation(attestationSSZ []byte) (interfaces.SignedBeaconBlock, error) {
-	att := &ethpb.AttestationElectra{}
-	if err := att.UnmarshalSSZ(attestationSSZ); err != nil {
-		return nil, err
-	}
-	b := &ethpb.BeaconBlockGloas{}
-	b.Body = &ethpb.BeaconBlockBodyGloas{Attestations: []*ethpb.AttestationElectra{att}}
-	return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockGloas{Block: b})
-}
-
-func RunAttestationTest(t *testing.T, config string) {
-	common.RunAttestationTest(t, config, version.String(version.Gloas), blockWithAttestation, altair.ProcessAttestationsNoVerifySignature, sszToState)
-}

testing/util/altair.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
@@ -74,7 +75,7 @@ func processPreGenesisDeposits(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit")
 	}
-	beaconState, err = helpers.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
+	beaconState, err = blocks.ActivateValidatorWithEffectiveBalance(beaconState, deposits)
 	if err != nil {
 		return nil, err
 	}