remove priting the prefix field

beacon-chain/core/electra/BUILD.bazel

@@ -14,6 +14,7 @@ go_library(
         "transition.go",
         "upgrade.go",
         "validator.go",
+        "withdrawals.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra",
     visibility = ["//visibility:public"],
@@ -41,6 +42,8 @@ go_library(
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -60,11 +63,13 @@ go_test(
         "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
+        "withdrawals_test.go",
     ],
     data = glob(["testdata/**"]),
     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",
@@ -77,12 +82,16 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/assert:go_default_library",
         "//testing/fuzz:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )

beacon-chain/core/electra/consolidations.go

@@ -3,14 +3,19 @@ package electra
 import (
 	"bytes"
 	"context"
+	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"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"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 )
 
@@ -90,6 +95,217 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 	return nil
 }
 
+// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
+// calls to the beacon state.
+//
+//	def process_consolidation_request(
+//	    state: BeaconState,
+//	    consolidation_request: ConsolidationRequest
+//	) -> None:
+//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
+//	        validator_pubkeys = [v.pubkey for v in state.validators]
+//	        request_source_pubkey = consolidation_request.source_pubkey
+//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	        switch_to_compounding_validator(state, source_index)
+//	        return
+//
+//	    # Verify that source != target, so a consolidation cannot be used as an exit.
+//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
+//	        return
+//	    # If the pending consolidations queue is full, consolidation requests are ignored
+//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
+//	        return
+//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
+//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
+//	        return
+//
+//	    validator_pubkeys = [v.pubkey for v in state.validators]
+//	    # Verify pubkeys exists
+//	    request_source_pubkey = consolidation_request.source_pubkey
+//	    request_target_pubkey = consolidation_request.target_pubkey
+//	    if request_source_pubkey not in validator_pubkeys:
+//	        return
+//	    if request_target_pubkey not in validator_pubkeys:
+//	        return
+//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
+//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
+//	    source_validator = state.validators[source_index]
+//	    target_validator = state.validators[target_index]
+//
+//	    # Verify source withdrawal credentials
+//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
+//	    is_correct_source_address = (
+//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+//	    )
+//	    if not (has_correct_credential and is_correct_source_address):
+//	        return
+//
+//	    # Verify that target has compounding withdrawal credentials
+//	    if not has_compounding_withdrawal_credential(target_validator):
+//	        return
+//
+//	    # Verify the source and the target are active
+//	    current_epoch = get_current_epoch(state)
+//	    if not is_active_validator(source_validator, current_epoch):
+//	        return
+//	    if not is_active_validator(target_validator, current_epoch):
+//	        return
+//	    # Verify exits for source and target have not been initiated
+//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
+//	        return
+//
+//	    # Verify the source has been active long enough
+//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	        return
+//
+//	    # Verify the source has no pending withdrawals in the queue
+//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
+//	        return
+//	    # Initiate source validator exit and append pending consolidation
+//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
+//	        state, source_validator.effective_balance
+//	    )
+//	    source_validator.withdrawable_epoch = Epoch(
+//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+//	    )
+//	    state.pending_consolidations.append(PendingConsolidation(
+//	        source_index=source_index,
+//	        target_index=target_index
+//	    ))
+func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
+	if len(reqs) == 0 || st == nil {
+		return nil
+	}
+	curEpoch := slots.ToEpoch(st.Slot())
+	ffe := params.BeaconConfig().FarFutureEpoch
+	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
+	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
+
+	for _, cr := range reqs {
+		if cr == nil {
+			return errors.New("nil consolidation request")
+		}
+		if ctx.Err() != nil {
+			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
+		}
+		if IsValidSwitchToCompoundingRequest(st, cr) {
+			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
+			if !ok {
+				log.Error("Failed to find source validator index")
+				continue
+			}
+			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
+				log.WithError(err).Error("Failed to switch to compounding validator")
+			}
+			continue
+		}
+		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
+		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
+		if sourcePubkey == targetPubkey {
+			continue
+		}
+
+		if npc, err := st.NumPendingConsolidations(); err != nil {
+			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
+		} else if npc >= pcLimit {
+			continue
+		}
+
+		activeBal, err := helpers.TotalActiveBalance(st)
+		if err != nil {
+			return err
+		}
+		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
+		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
+			continue
+		}
+
+		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
+		if !ok {
+			continue
+		}
+		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
+		if !ok {
+			continue
+		}
+
+		srcV, err := st.ValidatorAtIndex(srcIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
+		}
+
+		roSrcV, err := state_native.NewValidator(srcV)
+		if err != nil {
+			return err
+		}
+
+		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
+		}
+
+		// Verify source withdrawal credentials
+		if !roSrcV.HasExecutionWithdrawalCredentials() {
+			continue
+		}
+		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
+		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
+			continue
+		}
+
+		// Target validator must have their withdrawal credentials set appropriately.
+		if !tgtV.HasCompoundingWithdrawalCredentials() {
+			continue
+		}
+
+		// Both validators must be active.
+		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
+			continue
+		}
+		// Neither validator is exiting.
+		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
+			continue
+		}
+
+		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
+		if overflow {
+			log.Error("Overflow when adding activation epoch and shard committee period")
+			continue
+		}
+		if uint64(curEpoch) < e {
+			continue
+		}
+		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
+		if err != nil {
+			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
+			continue
+		}
+		if hasBal {
+			continue
+		}
+
+		// Initiate the exit of the source validator.
+		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
+		if err != nil {
+			log.WithError(err).Error("Failed to compute consolidation epoch")
+			continue
+		}
+		srcV.ExitEpoch = exitEpoch
+		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
+		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
+			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
+		}
+
+		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
+			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
+		}
+	}
+
+	return nil
+}
+
 // IsValidSwitchToCompoundingRequest returns true if the given consolidation request is valid for switching to compounding.
 //
 // Spec code:

beacon-chain/core/electra/consolidations_test.go

@@ -8,6 +8,8 @@ import (
 	"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"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
@@ -201,6 +203,275 @@ func TestProcessPendingConsolidations(t *testing.T) {
 	}
 }
 
+func TestProcessConsolidationRequests(t *testing.T) {
+	tests := []struct {
+		name     string
+		state    state.BeaconState
+		reqs     []*enginev1.ConsolidationRequest
+		validate func(*testing.T, state.BeaconState)
+		wantErr  bool
+	}{
+		{
+			name: "nil request",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{nil},
+			validate: func(t *testing.T, st state.BeaconState) {
+				require.DeepEqual(t, st, st)
+			},
+			wantErr: true,
+		},
+		{
+			name: "one valid request",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+				}
+				// Validator scenario setup. See comments in reqs section.
+				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
+				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
+				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
+				st.Validators[13].ExitEpoch = 10
+				st.Validators[16].ExitEpoch = 10
+				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
+					{
+						Index:  17,
+						Amount: 100,
+					},
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				// Source doesn't have withdrawal credentials.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+				// Source withdrawal credentials don't match the consolidation address.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)), // Should be 5
+					SourcePubkey:  []byte("val_5"),
+					TargetPubkey:  []byte("val_6"),
+				},
+				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
+					SourcePubkey:  []byte("val_7"),
+					TargetPubkey:  []byte("val_8"),
+				},
+				// Source is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(9)),
+					SourcePubkey:  []byte("val_9"),
+					TargetPubkey:  []byte("val_10"),
+				},
+				// Target is inactive.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(11)),
+					SourcePubkey:  []byte("val_11"),
+					TargetPubkey:  []byte("val_12"),
+				},
+				// Source is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(13)),
+					SourcePubkey:  []byte("val_13"),
+					TargetPubkey:  []byte("val_14"),
+				},
+				// Target is exiting.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(15)),
+					SourcePubkey:  []byte("val_15"),
+					TargetPubkey:  []byte("val_16"),
+				},
+				// Source doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("INVALID"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Target doesn't exist
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("INVALID"),
+				},
+				// Source == target
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_0"),
+					TargetPubkey:  []byte("val_0"),
+				},
+				// Has pending partial withdrawal
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_17"),
+					TargetPubkey:  []byte("val_1"),
+				},
+				// Valid consolidation request. This should be last to ensure invalid requests do
+				// not end the processing early.
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, uint64(1), numPC)
+				pcs, err := st.PendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[0].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[0].TargetIndex)
+
+				// Verify the source validator is exiting.
+				src, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch not updated")
+				require.Equal(t, params.BeaconConfig().MinValidatorWithdrawabilityDelay, src.WithdrawableEpoch-src.ExitEpoch, "source validator withdrawable epoch not set correctly")
+			},
+		},
+		{
+			name: "pending consolidations limit reached",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify no pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// Verify the source validator is not exiting.
+				src, err := st.ValidatorAtIndex(1)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
+			},
+		},
+		{
+			name: "pending consolidations limit reached during processing",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
+				}
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_4"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// The first consolidation was appended.
+				pcs, err := st.PendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, primitives.ValidatorIndex(1), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].SourceIndex)
+				require.Equal(t, primitives.ValidatorIndex(2), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].TargetIndex)
+
+				// Verify the second source validator is not exiting.
+				src, err := st.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
+				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
+			},
+		},
+		{
+			name: "pending consolidations limit reached and compounded consolidation after",
+			state: func() state.BeaconState {
+				st := &eth.BeaconStateElectra{
+					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
+					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
+					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
+				}
+				// To allow compounding consolidation requests.
+				st.Validators[3].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+				s, err := state_native.InitializeFromProtoElectra(st)
+				require.NoError(t, err)
+				return s
+			}(),
+			reqs: []*enginev1.ConsolidationRequest{
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
+					SourcePubkey:  []byte("val_1"),
+					TargetPubkey:  []byte("val_2"),
+				},
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
+					SourcePubkey:  []byte("val_3"),
+					TargetPubkey:  []byte("val_3"),
+				},
+			},
+			validate: func(t *testing.T, st state.BeaconState) {
+				// Verify a pending consolidation is created.
+				numPC, err := st.NumPendingConsolidations()
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
+
+				// Verify that the last consolidation was included
+				src, err := st.ValidatorAtIndex(3)
+				require.NoError(t, err)
+				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, src.WithdrawalCredentials[0], "source validator was not compounded")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := electra.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr {
+				require.NoError(t, err)
+			}
+			if tt.validate != nil {
+				tt.validate(t, tt.state)
+			}
+		})
+	}
+}
+
 func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, 1)
 	t.Run("nil source pubkey", func(t *testing.T) {

beacon-chain/core/electra/deposits.go

@@ -12,6 +12,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/contracts/deposit"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
@@ -535,3 +536,62 @@ func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount
 	validator.EffectiveBalance = min(amount-(amount%params.BeaconConfig().EffectiveBalanceIncrement), maxEffectiveBalance)
 	return validator, nil
 }
+
+// ProcessDepositRequests is a function as part of electra to process execution layer deposits
+func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
+	defer span.End()
+
+	if len(requests) == 0 {
+		return beaconState, nil
+	}
+
+	var err error
+	for _, receipt := range requests {
+		beaconState, err = processDepositRequest(beaconState, receipt)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not apply deposit request")
+		}
+	}
+	return beaconState, nil
+}
+
+// processDepositRequest processes the specific deposit request
+// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
+//
+//	# Set deposit request start index
+//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
+//	    state.deposit_requests_start_index = deposit_request.index
+//
+//	# Create pending deposit
+//	state.pending_deposits.append(PendingDeposit(
+//	    pubkey=deposit_request.pubkey,
+//	    withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	    amount=deposit_request.amount,
+//	    signature=deposit_request.signature,
+//	    slot=state.slot,
+//	))
+func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) (state.BeaconState, error) {
+	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get deposit requests start index")
+	}
+	if request == nil {
+		return nil, errors.New("nil deposit request")
+	}
+	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
+		if err := beaconState.SetDepositRequestsStartIndex(request.Index); err != nil {
+			return nil, errors.Wrap(err, "could not set deposit requests start index")
+		}
+	}
+	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
+		PublicKey:             bytesutil.SafeCopyBytes(request.Pubkey),
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
+		Amount:                request.Amount,
+		Signature:             bytesutil.SafeCopyBytes(request.Signature),
+		Slot:                  beaconState.Slot(),
+	}); err != nil {
+		return nil, errors.Wrap(err, "could not append deposit request")
+	}
+	return beaconState, nil
+}

beacon-chain/core/electra/deposits_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"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"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	stateTesting "github.com/OffchainLabs/prysm/v7/beacon-chain/state/testing"
@@ -14,6 +15,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/crypto/bls"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
@@ -359,6 +361,60 @@ func TestBatchProcessNewPendingDeposits(t *testing.T) {
 	})
 }
 
+func TestProcessDepositRequests(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 1)
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	require.NoError(t, st.SetDepositRequestsStartIndex(1))
+
+	t.Run("empty requests continues", func(t *testing.T) {
+		newSt, err := electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
+		require.NoError(t, err)
+		require.DeepEqual(t, newSt, st)
+	})
+	t.Run("nil request errors", func(t *testing.T) {
+		_, err = electra.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
+		require.ErrorContains(t, "nil deposit request", err)
+	})
+
+	vals := st.Validators()
+	vals[0].PublicKey = sk.PublicKey().Marshal()
+	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+	require.NoError(t, st.SetValidators(vals))
+	bals := st.Balances()
+	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
+	require.NoError(t, st.SetBalances(bals))
+	require.NoError(t, st.SetPendingDeposits(make([]*eth.PendingDeposit, 0))) // reset pbd as the determinitstic state populates this already
+	withdrawalCred := make([]byte, 32)
+	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	depositMessage := &eth.DepositMessage{
+		PublicKey:             sk.PublicKey().Marshal(),
+		Amount:                1000,
+		WithdrawalCredentials: withdrawalCred,
+	}
+	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(depositMessage, domain)
+	require.NoError(t, err)
+	sig := sk.Sign(sr[:])
+	requests := []*enginev1.DepositRequest{
+		{
+			Pubkey:                depositMessage.PublicKey,
+			Index:                 0,
+			WithdrawalCredentials: depositMessage.WithdrawalCredentials,
+			Amount:                depositMessage.Amount,
+			Signature:             sig.Marshal(),
+		},
+	}
+	st, err = electra.ProcessDepositRequests(t.Context(), st, requests)
+	require.NoError(t, err)
+
+	pbd, err := st.PendingDeposits()
+	require.NoError(t, err)
+	require.Equal(t, 1, len(pbd))
+	require.Equal(t, uint64(1000), pbd[0].Amount)
+}
+
 func TestProcessDeposit_Electra_Simple(t *testing.T) {
 	deps, _, err := util.DeterministicDepositsAndKeysSameValidator(3)
 	require.NoError(t, err)

beacon-chain/core/electra/withdrawals.go

@@ -1,4 +1,4 @@
-package requests
+package electra
 
 import (
 	"bytes"
@@ -88,7 +88,7 @@ import (
 //	        withdrawable_epoch=withdrawable_epoch,
 //	    ))
 func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.WithdrawalRequest) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "requests.ProcessWithdrawalRequests")
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
 	if len(wrs) == 0 {

beacon-chain/core/electra/withdrawals_test.go

@@ -1,9 +1,9 @@
-package requests_test
+package electra_test
 
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
@@ -289,7 +289,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := requests.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
+			got, err := electra.ProcessWithdrawalRequests(t.Context(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return

beacon-chain/core/requests/BUILD.bazel

@@ -1,60 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "consolidations.go",
-        "deposits.go",
-        "log.go",
-        "withdrawals.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/validators:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "consolidations_test.go",
-        "deposits_test.go",
-        "withdrawals_test.go",
-    ],
-    deps = [
-        ":go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
-    ],
-)

beacon-chain/core/requests/consolidations.go

@@ -1,365 +0,0 @@
-package requests
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"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"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	prysmMath "github.com/OffchainLabs/prysm/v7/math"
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/ethereum/go-ethereum/common/math"
-	"github.com/pkg/errors"
-)
-
-// ProcessConsolidationRequests implements the spec definition below. This method makes mutating
-// calls to the beacon state.
-//
-//	def process_consolidation_request(
-//	    state: BeaconState,
-//	    consolidation_request: ConsolidationRequest
-//	) -> None:
-//	    if is_valid_switch_to_compounding_request(state, consolidation_request):
-//	        validator_pubkeys = [v.pubkey for v in state.validators]
-//	        request_source_pubkey = consolidation_request.source_pubkey
-//	        source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	        switch_to_compounding_validator(state, source_index)
-//	        return
-//
-//	    # Verify that source != target, so a consolidation cannot be used as an exit.
-//	    if consolidation_request.source_pubkey == consolidation_request.target_pubkey:
-//	        return
-//	    # If the pending consolidations queue is full, consolidation requests are ignored
-//	    if len(state.pending_consolidations) == PENDING_CONSOLIDATIONS_LIMIT:
-//	        return
-//	    # If there is too little available consolidation churn limit, consolidation requests are ignored
-//	    if get_consolidation_churn_limit(state) <= MIN_ACTIVATION_BALANCE:
-//	        return
-//
-//	    validator_pubkeys = [v.pubkey for v in state.validators]
-//	    # Verify pubkeys exists
-//	    request_source_pubkey = consolidation_request.source_pubkey
-//	    request_target_pubkey = consolidation_request.target_pubkey
-//	    if request_source_pubkey not in validator_pubkeys:
-//	        return
-//	    if request_target_pubkey not in validator_pubkeys:
-//	        return
-//	    source_index = ValidatorIndex(validator_pubkeys.index(request_source_pubkey))
-//	    target_index = ValidatorIndex(validator_pubkeys.index(request_target_pubkey))
-//	    source_validator = state.validators[source_index]
-//	    target_validator = state.validators[target_index]
-//
-//	    # Verify source withdrawal credentials
-//	    has_correct_credential = has_execution_withdrawal_credential(source_validator)
-//	    is_correct_source_address = (
-//	        source_validator.withdrawal_credentials[12:] == consolidation_request.source_address
-//	    )
-//	    if not (has_correct_credential and is_correct_source_address):
-//	        return
-//
-//	    # Verify that target has compounding withdrawal credentials
-//	    if not has_compounding_withdrawal_credential(target_validator):
-//	        return
-//
-//	    # Verify the source and the target are active
-//	    current_epoch = get_current_epoch(state)
-//	    if not is_active_validator(source_validator, current_epoch):
-//	        return
-//	    if not is_active_validator(target_validator, current_epoch):
-//	        return
-//	    # Verify exits for source and target have not been initiated
-//	    if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        return
-//
-//	    # Verify the source has been active long enough
-//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
-//	        return
-//
-//	    # Verify the source has no pending withdrawals in the queue
-//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
-//	        return
-//	    # Initiate source validator exit and append pending consolidation
-//	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
-//	        state, source_validator.effective_balance
-//	    )
-//	    source_validator.withdrawable_epoch = Epoch(
-//	        source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-//	    )
-//	    state.pending_consolidations.append(PendingConsolidation(
-//	        source_index=source_index,
-//	        target_index=target_index
-//	    ))
-func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
-	ctx, span := trace.StartSpan(ctx, "requests.ProcessConsolidationRequests")
-	defer span.End()
-
-	if len(reqs) == 0 || st == nil {
-		return nil
-	}
-	curEpoch := slots.ToEpoch(st.Slot())
-	ffe := params.BeaconConfig().FarFutureEpoch
-	minValWithdrawDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
-	pcLimit := params.BeaconConfig().PendingConsolidationsLimit
-
-	for _, cr := range reqs {
-		if cr == nil {
-			return errors.New("nil consolidation request")
-		}
-		if ctx.Err() != nil {
-			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
-		}
-
-		if isValidSwitchToCompoundingRequest(st, cr) {
-			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
-			if !ok {
-				log.Error("Failed to find source validator index")
-				continue
-			}
-			if err := switchToCompoundingValidator(st, srcIdx); err != nil {
-				log.WithError(err).Error("Failed to switch to compounding validator")
-			}
-			continue
-		}
-
-		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
-		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
-		if sourcePubkey == targetPubkey {
-			continue
-		}
-
-		if npc, err := st.NumPendingConsolidations(); err != nil {
-			return fmt.Errorf("failed to fetch number of pending consolidations: %w", err) // This should never happen.
-		} else if npc >= pcLimit {
-			continue
-		}
-
-		activeBal, err := helpers.TotalActiveBalance(st)
-		if err != nil {
-			return err
-		}
-		churnLimit := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-		if churnLimit <= primitives.Gwei(params.BeaconConfig().MinActivationBalance) {
-			continue
-		}
-
-		srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubkey)
-		if !ok {
-			continue
-		}
-		tgtIdx, ok := st.ValidatorIndexByPubkey(targetPubkey)
-		if !ok {
-			continue
-		}
-
-		srcV, err := st.ValidatorAtIndex(srcIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch source validator: %w", err) // This should never happen.
-		}
-
-		roSrcV, err := state_native.NewValidator(srcV)
-		if err != nil {
-			return err
-		}
-
-		tgtV, err := st.ValidatorAtIndexReadOnly(tgtIdx)
-		if err != nil {
-			return fmt.Errorf("failed to fetch target validator: %w", err) // This should never happen.
-		}
-
-		// Verify source withdrawal credentials.
-		if !roSrcV.HasExecutionWithdrawalCredentials() {
-			continue
-		}
-		// Confirm source_validator.withdrawal_credentials[12:] == consolidation_request.source_address.
-		if len(srcV.WithdrawalCredentials) != 32 || len(cr.SourceAddress) != 20 || !bytes.HasSuffix(srcV.WithdrawalCredentials, cr.SourceAddress) {
-			continue
-		}
-
-		// Target validator must have their withdrawal credentials set appropriately.
-		if !tgtV.HasCompoundingWithdrawalCredentials() {
-			continue
-		}
-
-		// Both validators must be active.
-		if !helpers.IsActiveValidator(srcV, curEpoch) || !helpers.IsActiveValidatorUsingTrie(tgtV, curEpoch) {
-			continue
-		}
-		// Neither validator is exiting.
-		if srcV.ExitEpoch != ffe || tgtV.ExitEpoch() != ffe {
-			continue
-		}
-
-		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
-		if overflow {
-			log.Error("Overflow when adding activation epoch and shard committee period")
-			continue
-		}
-		if uint64(curEpoch) < e {
-			continue
-		}
-
-		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
-		if err != nil {
-			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
-			continue
-		}
-		if hasBal {
-			continue
-		}
-
-		exitEpoch, err := computeConsolidationEpochAndUpdateChurn(st, primitives.Gwei(srcV.EffectiveBalance))
-		if err != nil {
-			log.WithError(err).Error("Failed to compute consolidation epoch")
-			continue
-		}
-		srcV.ExitEpoch = exitEpoch
-		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
-		if err := st.UpdateValidatorAtIndex(srcIdx, srcV); err != nil {
-			return fmt.Errorf("failed to update validator: %w", err) // This should never happen.
-		}
-
-		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
-			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
-		}
-	}
-
-	return nil
-}
-
-func isValidSwitchToCompoundingRequest(st state.BeaconState, req *enginev1.ConsolidationRequest) bool {
-	if req.SourcePubkey == nil || req.TargetPubkey == nil {
-		return false
-	}
-
-	if !bytes.Equal(req.SourcePubkey, req.TargetPubkey) {
-		return false
-	}
-
-	srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.SourcePubkey))
-	if !ok {
-		return false
-	}
-	srcV, err := st.ValidatorAtIndexReadOnly(srcIdx)
-	if err != nil {
-		return false
-	}
-
-	sourceAddress := req.SourceAddress
-	withdrawalCreds := srcV.GetWithdrawalCredentials()
-	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
-		return false
-	}
-
-	if !srcV.HasETH1WithdrawalCredentials() {
-		return false
-	}
-
-	curEpoch := slots.ToEpoch(st.Slot())
-	if !helpers.IsActiveValidatorUsingTrie(srcV, curEpoch) {
-		return false
-	}
-
-	if srcV.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-		return false
-	}
-
-	return true
-}
-
-func switchToCompoundingValidator(st state.BeaconState, idx primitives.ValidatorIndex) error {
-	v, err := st.ValidatorAtIndex(idx)
-	if err != nil {
-		return err
-	}
-	if len(v.WithdrawalCredentials) == 0 {
-		return errors.New("validator has no withdrawal credentials")
-	}
-
-	v.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-	if err := st.UpdateValidatorAtIndex(idx, v); err != nil {
-		return err
-	}
-	return queueExcessActiveBalance(st, idx)
-}
-
-func queueExcessActiveBalance(st state.BeaconState, idx primitives.ValidatorIndex) error {
-	bal, err := st.BalanceAtIndex(idx)
-	if err != nil {
-		return err
-	}
-
-	if bal > params.BeaconConfig().MinActivationBalance {
-		if err := st.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
-			return err
-		}
-		excessBalance := bal - params.BeaconConfig().MinActivationBalance
-		val, err := st.ValidatorAtIndexReadOnly(idx)
-		if err != nil {
-			return err
-		}
-		pk := val.PublicKey()
-		return st.AppendPendingDeposit(&eth.PendingDeposit{
-			PublicKey:             pk[:],
-			WithdrawalCredentials: val.GetWithdrawalCredentials(),
-			Amount:                excessBalance,
-			Signature:             common.InfiniteSignature[:],
-			Slot:                  params.BeaconConfig().GenesisSlot,
-		})
-	}
-	return nil
-}
-
-func computeConsolidationEpochAndUpdateChurn(st state.BeaconState, consolidationBalance primitives.Gwei) (primitives.Epoch, error) {
-	earliestEpoch, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return 0, err
-	}
-	earliestConsolidationEpoch := max(earliestEpoch, helpers.ActivationExitEpoch(slots.ToEpoch(st.Slot())))
-
-	activeBal, err := helpers.TotalActiveBalance(st)
-	if err != nil {
-		return 0, err
-	}
-	perEpochConsolidationChurn := helpers.ConsolidationChurnLimit(primitives.Gwei(activeBal))
-
-	var consolidationBalanceToConsume primitives.Gwei
-	if earliestEpoch < earliestConsolidationEpoch {
-		consolidationBalanceToConsume = perEpochConsolidationChurn
-	} else {
-		consolidationBalanceToConsume, err = st.ConsolidationBalanceToConsume()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	if consolidationBalance > consolidationBalanceToConsume {
-		balanceToProcess := consolidationBalance - consolidationBalanceToConsume
-		additionalEpochs, err := prysmMath.Div64(uint64(balanceToProcess-1), uint64(perEpochConsolidationChurn))
-		if err != nil {
-			return 0, err
-		}
-		additionalEpochs++
-		earliestConsolidationEpoch += primitives.Epoch(additionalEpochs)
-		consolidationBalanceToConsume += primitives.Gwei(additionalEpochs) * perEpochConsolidationChurn
-	}
-
-	if err := st.SetConsolidationBalanceToConsume(consolidationBalanceToConsume - consolidationBalance); err != nil {
-		return 0, err
-	}
-	if err := st.SetEarliestConsolidationEpoch(earliestConsolidationEpoch); err != nil {
-		return 0, err
-	}
-
-	return earliestConsolidationEpoch, nil
-}

beacon-chain/core/requests/consolidations_test.go

@@ -1,316 +0,0 @@
-package requests_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
-	"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"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Validator {
-	num := totalBal / primitives.Gwei(params.BeaconConfig().MinActivationBalance)
-	vals := make([]*eth.Validator, num)
-	for i := range vals {
-		wd := make([]byte, 32)
-		wd[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-		wd[31] = byte(i)
-
-		vals[i] = &eth.Validator{
-			ActivationEpoch:       primitives.Epoch(0),
-			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			PublicKey:             fmt.Appendf(nil, "val_%d", i),
-			WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
-			WithdrawalCredentials: wd,
-		}
-	}
-	if totalBal%primitives.Gwei(params.BeaconConfig().MinActivationBalance) != 0 {
-		vals = append(vals, &eth.Validator{
-			ActivationEpoch:  primitives.Epoch(0),
-			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance: uint64(totalBal) % params.BeaconConfig().MinActivationBalance,
-		})
-	}
-	return vals
-}
-
-func TestProcessConsolidationRequests(t *testing.T) {
-	tests := []struct {
-		name     string
-		state    state.BeaconState
-		reqs     []*enginev1.ConsolidationRequest
-		validate func(*testing.T, state.BeaconState)
-		wantErr  bool
-	}{
-		{
-			name: "nil request",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{nil},
-			validate: func(t *testing.T, st state.BeaconState) {
-				require.DeepEqual(t, st, st)
-			},
-			wantErr: true,
-		},
-		{
-			name: "one valid request",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-				}
-				// Validator scenario setup. See comments in reqs section.
-				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
-				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
-				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-				st.Validators[13].ExitEpoch = 10
-				st.Validators[16].ExitEpoch = 10
-				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
-					{
-						Index:  17,
-						Amount: 100,
-					},
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				// Source doesn't have withdrawal credentials.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_4"),
-				},
-				// Source withdrawal credentials don't match the consolidation address.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)), // Should be 5
-					SourcePubkey:  []byte("val_5"),
-					TargetPubkey:  []byte("val_6"),
-				},
-				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
-					SourcePubkey:  []byte("val_7"),
-					TargetPubkey:  []byte("val_8"),
-				},
-				// Source is inactive.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(9)),
-					SourcePubkey:  []byte("val_9"),
-					TargetPubkey:  []byte("val_10"),
-				},
-				// Target is inactive.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(11)),
-					SourcePubkey:  []byte("val_11"),
-					TargetPubkey:  []byte("val_12"),
-				},
-				// Source is exiting.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(13)),
-					SourcePubkey:  []byte("val_13"),
-					TargetPubkey:  []byte("val_14"),
-				},
-				// Target is exiting.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(15)),
-					SourcePubkey:  []byte("val_15"),
-					TargetPubkey:  []byte("val_16"),
-				},
-				// Source doesn't exist
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("INVALID"),
-					TargetPubkey:  []byte("val_0"),
-				},
-				// Target doesn't exist
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_0"),
-					TargetPubkey:  []byte("INVALID"),
-				},
-				// Source == target
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_0"),
-					TargetPubkey:  []byte("val_0"),
-				},
-				// Has pending partial withdrawal
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_17"),
-					TargetPubkey:  []byte("val_1"),
-				},
-				// Valid consolidation request. This should be last to ensure invalid requests do
-				// not end the processing early.
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, uint64(1), numPC)
-				pcs, err := st.PendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, primitives.ValidatorIndex(1), pcs[0].SourceIndex)
-				require.Equal(t, primitives.ValidatorIndex(2), pcs[0].TargetIndex)
-
-				// Verify the source validator is exiting.
-				src, err := st.ValidatorAtIndex(1)
-				require.NoError(t, err)
-				require.NotEqual(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch not updated")
-				require.Equal(t, params.BeaconConfig().MinValidatorWithdrawabilityDelay, src.WithdrawableEpoch-src.ExitEpoch, "source validator withdrawable epoch not set correctly")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify no pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// Verify the source validator is not exiting.
-				src, err := st.ValidatorAtIndex(1)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached during processing",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
-				}
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_4"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// The first consolidation was appended.
-				pcs, err := st.PendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, primitives.ValidatorIndex(1), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].SourceIndex)
-				require.Equal(t, primitives.ValidatorIndex(2), pcs[params.BeaconConfig().PendingConsolidationsLimit-1].TargetIndex)
-
-				// Verify the second source validator is not exiting.
-				src, err := st.ValidatorAtIndex(3)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.ExitEpoch, "source validator exit epoch should not be updated")
-				require.Equal(t, params.BeaconConfig().FarFutureEpoch, src.WithdrawableEpoch, "source validator withdrawable epoch should not be updated")
-			},
-			wantErr: false,
-		},
-		{
-			name: "pending consolidations limit reached and compounded consolidation after",
-			state: func() state.BeaconState {
-				st := &eth.BeaconStateElectra{
-					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
-					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
-					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit),
-				}
-				// To allow compounding consolidation requests.
-				st.Validators[3].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-				s, err := state_native.InitializeFromProtoElectra(st)
-				require.NoError(t, err)
-				return s
-			}(),
-			reqs: []*enginev1.ConsolidationRequest{
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(1)),
-					SourcePubkey:  []byte("val_1"),
-					TargetPubkey:  []byte("val_2"),
-				},
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(3)),
-					SourcePubkey:  []byte("val_3"),
-					TargetPubkey:  []byte("val_3"),
-				},
-			},
-			validate: func(t *testing.T, st state.BeaconState) {
-				// Verify a pending consolidation is created.
-				numPC, err := st.NumPendingConsolidations()
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().PendingConsolidationsLimit, numPC)
-
-				// Verify that the last consolidation was included
-				src, err := st.ValidatorAtIndex(3)
-				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, src.WithdrawalCredentials[0], "source validator was not compounded")
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := requests.ProcessConsolidationRequests(context.TODO(), tt.state, tt.reqs)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr {
-				require.NoError(t, err)
-			}
-			if tt.validate != nil {
-				tt.validate(t, tt.state)
-			}
-		})
-	}
-}

beacon-chain/core/requests/deposits.go

@@ -1,73 +0,0 @@
-package requests
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// ProcessDepositRequests processes execution layer deposits requests.
-func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, reqs []*enginev1.DepositRequest) (state.BeaconState, error) {
-	_, span := trace.StartSpan(ctx, "requests.ProcessDepositRequests")
-	defer span.End()
-
-	if len(reqs) == 0 {
-		return beaconState, nil
-	}
-
-	var err error
-	for _, req := range reqs {
-		beaconState, err = processDepositRequest(beaconState, req)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not apply deposit request")
-		}
-	}
-	return beaconState, nil
-}
-
-// processDepositRequest processes the specific deposit request
-//
-// def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
-//
-//	# Set deposit request start index
-//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
-//	    state.deposit_requests_start_index = deposit_request.index
-//
-//	# Create pending deposit
-//	state.pending_deposits.append(PendingDeposit(
-//	    pubkey=deposit_request.pubkey,
-//	    withdrawal_credentials=deposit_request.withdrawal_credentials,
-//	    amount=deposit_request.amount,
-//	    signature=deposit_request.signature,
-//	    slot=state.slot,
-//	))
-func processDepositRequest(beaconState state.BeaconState, req *enginev1.DepositRequest) (state.BeaconState, error) {
-	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get deposit requests start index")
-	}
-	if req == nil {
-		return nil, errors.New("nil deposit request")
-	}
-	if requestsStartIndex == params.BeaconConfig().UnsetDepositRequestsStartIndex {
-		if err := beaconState.SetDepositRequestsStartIndex(req.Index); err != nil {
-			return nil, errors.Wrap(err, "could not set deposit requests start index")
-		}
-	}
-	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
-		PublicKey:             bytesutil.SafeCopyBytes(req.Pubkey),
-		WithdrawalCredentials: bytesutil.SafeCopyBytes(req.WithdrawalCredentials),
-		Amount:                req.Amount,
-		Signature:             bytesutil.SafeCopyBytes(req.Signature),
-		Slot:                  beaconState.Slot(),
-	}); err != nil {
-		return nil, errors.Wrap(err, "could not append deposit request")
-	}
-	return beaconState, nil
-}

beacon-chain/core/requests/deposits_test.go

@@ -1,70 +0,0 @@
-package requests_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-)
-
-func TestProcessDepositRequests(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, 1)
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	require.NoError(t, st.SetDepositRequestsStartIndex(1))
-
-	t.Run("empty requests continues", func(t *testing.T) {
-		newSt, err := requests.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{})
-		require.NoError(t, err)
-		require.DeepEqual(t, newSt, st)
-	})
-	t.Run("nil request errors", func(t *testing.T) {
-		_, err = requests.ProcessDepositRequests(t.Context(), st, []*enginev1.DepositRequest{nil})
-		require.ErrorContains(t, "nil deposit request", err)
-	})
-
-	vals := st.Validators()
-	vals[0].PublicKey = sk.PublicKey().Marshal()
-	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-	require.NoError(t, st.SetValidators(vals))
-	bals := st.Balances()
-	bals[0] = params.BeaconConfig().MinActivationBalance + 2000
-	require.NoError(t, st.SetBalances(bals))
-	require.NoError(t, st.SetPendingDeposits(make([]*eth.PendingDeposit, 0))) // reset pbd as the deterministic state populates this already
-	withdrawalCred := make([]byte, 32)
-	withdrawalCred[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
-	depositMessage := &eth.DepositMessage{
-		PublicKey:             sk.PublicKey().Marshal(),
-		Amount:                1000,
-		WithdrawalCredentials: withdrawalCred,
-	}
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	sr, err := signing.ComputeSigningRoot(depositMessage, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	reqs := []*enginev1.DepositRequest{
-		{
-			Pubkey:                depositMessage.PublicKey,
-			Index:                 0,
-			WithdrawalCredentials: depositMessage.WithdrawalCredentials,
-			Amount:                depositMessage.Amount,
-			Signature:             sig.Marshal(),
-		},
-	}
-	st, err = requests.ProcessDepositRequests(t.Context(), st, reqs)
-	require.NoError(t, err)
-
-	pbd, err := st.PendingDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 1, len(pbd))
-	require.Equal(t, uint64(1000), pbd[0].Amount)
-	require.DeepEqual(t, bytesutil.SafeCopyBytes(reqs[0].Pubkey), pbd[0].PublicKey)
-}

beacon-chain/core/requests/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package requests
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/requests")

beacon-chain/core/transition/BUILD.bazel

@@ -27,7 +27,6 @@ go_library(
         "//beacon-chain/core/execution:go_default_library",
         "//beacon-chain/core/fulu: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/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",

beacon-chain/core/transition/electra.go

@@ -6,7 +6,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	coreRequests "github.com/OffchainLabs/prysm/v7/beacon-chain/core/requests"
 	v "github.com/OffchainLabs/prysm/v7/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -98,7 +97,7 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, electra.NewExecReqError("nil deposit request")
 		}
 	}
-	st, err = coreRequests.ProcessDepositRequests(ctx, st, requests.Deposits)
+	st, err = electra.ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
 		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process deposit requests").Error())
 	}
@@ -108,7 +107,7 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, electra.NewExecReqError("nil withdrawal request")
 		}
 	}
-	st, err = coreRequests.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
+	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
 		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process withdrawal requests").Error())
 	}
@@ -117,7 +116,7 @@ func electraOperations(ctx context.Context, st state.BeaconState, block interfac
 			return nil, electra.NewExecReqError("nil consolidation request")
 		}
 	}
-	if err := coreRequests.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
+	if err := electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, electra.NewExecReqError(errors.Wrap(err, "could not process consolidation requests").Error())
 	}
 	return st, nil

beacon-chain/node/BUILD.bazel

@@ -64,6 +64,7 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//runtime:go_default_library",
         "//runtime/prereqs:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",

beacon-chain/node/node.go

@@ -66,6 +66,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/prometheus"
 	"github.com/OffchainLabs/prysm/v7/runtime"
 	"github.com/OffchainLabs/prysm/v7/runtime/prereqs"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -468,6 +469,10 @@ func (b *BeaconNode) OperationFeed() event.SubscriberSender {
 func (b *BeaconNode) Start() {
 	b.lock.Lock()
 
+	log.WithFields(logrus.Fields{
+		"version": version.Version(),
+	}).Info("Starting beacon node")
+
 	b.services.StartAll()
 
 	stop := b.stop

beacon-chain/node/node_test.go

@@ -68,6 +68,7 @@ func TestNodeClose_OK(t *testing.T) {
 }
 
 func TestNodeStart_Ok(t *testing.T) {
+	hook := logTest.NewGlobal()
 	app := cli.App{}
 	tmp := fmt.Sprintf("%s/datadirtest2", t.TempDir())
 	set := flag.NewFlagSet("test", 0)
@@ -96,9 +97,11 @@ func TestNodeStart_Ok(t *testing.T) {
 	}()
 	time.Sleep(3 * time.Second)
 	node.Close()
+	require.LogsContain(t, hook, "Starting beacon node")
 }
 
 func TestNodeStart_SyncChecker(t *testing.T) {
+	hook := logTest.NewGlobal()
 	app := cli.App{}
 	tmp := fmt.Sprintf("%s/datadirtest2", t.TempDir())
 	set := flag.NewFlagSet("test", 0)
@@ -124,6 +127,7 @@ func TestNodeStart_SyncChecker(t *testing.T) {
 	time.Sleep(3 * time.Second)
 	assert.NotNil(t, node.syncChecker.Svc)
 	node.Close()
+	require.LogsContain(t, hook, "Starting beacon node")
 }
 
 // TestClearDB tests clearing the database

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

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api"
@@ -25,6 +26,7 @@ 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"
@@ -1042,27 +1044,112 @@ 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
 	}
-	root, err := s.Blocker.BlockRoot(ctx, []byte(blockID))
-	if !shared.WriteBlockRootFetchError(w, err) {
-		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
+				}
+			}
+		}
 	}
 
-	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, root)
+	b32Root := bytesutil.ToBytes32(root)
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, b32Root)
 	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, root),
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, b32Root),
 	}
 	httputil.WriteJson(w, response)
 }

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

@@ -2509,10 +2509,6 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			HeadFetcher:           mockChainFetcher,
 			OptimisticModeFetcher: mockChainFetcher,
 			FinalizationFetcher:   mockChainFetcher,
-			Blocker: &lookup.BeaconDbBlocker{
-				BeaconDB:         beaconDB,
-				ChainInfoFetcher: mockChainFetcher,
-			},
 		}
 
 		root, err := genBlk.Block.HashTreeRoot()
@@ -2528,7 +2524,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "bad formatting",
 				blockID:  map[string]string{"block_id": "3bad0"},
-				wantErr:  "Invalid block ID",
+				wantErr:  "Could not parse block ID",
 				wantCode: http.StatusBadRequest,
 			},
 			{
@@ -2576,7 +2572,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:  "Block not found",
+				wantErr:  "Could not find block",
 				wantCode: http.StatusNotFound,
 			},
 			{
@@ -2589,7 +2585,7 @@ func TestServer_GetBlockRoot(t *testing.T) {
 			{
 				name:     "no block",
 				blockID:  map[string]string{"block_id": "105"},
-				wantErr:  "Block not found",
+				wantErr:  "Could not find any blocks with given slot",
 				wantCode: http.StatusNotFound,
 			},
 		}
@@ -2637,10 +2633,6 @@ 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)
@@ -2676,10 +2668,6 @@ 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/config/handlers_test.go

@@ -83,7 +83,6 @@ func TestGetSpec(t *testing.T) {
 	config.ElectraForkEpoch = 107
 	config.FuluForkVersion = []byte("FuluForkVersion")
 	config.FuluForkEpoch = 109
-	config.GloasForkEpoch = 110
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -135,10 +134,6 @@ func TestGetSpec(t *testing.T) {
 	config.AttestationDueBPS = primitives.BP(122)
 	config.AggregateDueBPS = primitives.BP(123)
 	config.ContributionDueBPS = primitives.BP(124)
-	config.AttestationDueBPSGloas = primitives.BP(126)
-	config.AggregateDueBPSGloas = primitives.BP(127)
-	config.SyncMessageDueBPSGloas = primitives.BP(128)
-	config.ContributionDueBPSGloas = primitives.BP(129)
 	config.TerminalBlockHash = common.HexToHash("TerminalBlockHash")
 	config.TerminalBlockHashActivationEpoch = 72
 	config.TerminalTotalDifficulty = "73"
@@ -217,7 +212,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, 191, len(data))
+	assert.Equal(t, 186, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -297,8 +292,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_EPOCH":
-				assert.Equal(t, "110", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
 				assert.Equal(t, "1000", v)
 			case "BLS_WITHDRAWAL_PREFIX":
@@ -481,14 +474,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "123", v)
 			case "CONTRIBUTION_DUE_BPS":
 				assert.Equal(t, "124", v)
-			case "ATTESTATION_DUE_BPS_GLOAS":
-				assert.Equal(t, "126", v)
-			case "AGGREGATE_DUE_BPS_GLOAS":
-				assert.Equal(t, "127", v)
-			case "SYNC_MESSAGE_DUE_BPS_GLOAS":
-				assert.Equal(t, "128", v)
-			case "CONTRIBUTION_DUE_BPS_GLOAS":
-				assert.Equal(t, "129", v)
 			case "MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT":
 				assert.Equal(t, "8", v)
 			case "MAX_REQUEST_LIGHT_CLIENT_UPDATES":

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

@@ -26,30 +26,21 @@ func WriteStateFetchError(w http.ResponseWriter, err error) {
 	httputil.HandleError(w, "Could not get state: "+err.Error(), http.StatusInternalServerError)
 }
 
-// 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
-	}
+// 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 {
 	var blockNotFoundErr *lookup.BlockNotFoundError
 	if errors.As(err, &blockNotFoundErr) {
 		httputil.HandleError(w, "Block not found: "+blockNotFoundErr.Error(), http.StatusNotFound)
-		return true
+		return false
 	}
 	var invalidBlockIdErr *lookup.BlockIdParseError
 	if errors.As(err, &invalidBlockIdErr) {
 		httputil.HandleError(w, "Invalid block ID: "+invalidBlockIdErr.Error(), http.StatusBadRequest)
-		return true
+		return false
 	}
-	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") {
+	if err != nil {
+		httputil.HandleError(w, "Could not get block from block ID: "+err.Error(), http.StatusInternalServerError)
 		return false
 	}
 	if err = blocks.BeaconBlockIsNil(blk); err != nil {
@@ -58,10 +49,3 @@ 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,59 +105,3 @@ 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,7 +60,6 @@ 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)
@@ -226,18 +225,6 @@ 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>
-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,111 +168,6 @@ 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,7 +15,6 @@ 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
@@ -40,14 +39,6 @@ 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/state-native/getters_withdrawal.go

@@ -113,100 +113,77 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 	defer b.lock.RUnlock()
 
 	withdrawals := make([]*enginev1.Withdrawal, 0, params.BeaconConfig().MaxWithdrawalsPerPayload)
-	withdrawalIndex := b.nextWithdrawalIndex
-
-	withdrawalIndex, processedPartialWithdrawalsCount, err := b.appendPendingPartialWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	err = b.appendValidatorsSweepWithdrawals(withdrawalIndex, &withdrawals)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	return withdrawals, processedPartialWithdrawalsCount, nil
-}
-
-func (b *BeaconState) appendPendingPartialWithdrawals(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) (uint64, uint64, error) {
-	if b.version < version.Electra {
-		return withdrawalIndex, 0, nil
-	}
-
-	ws := *withdrawals
-	epoch := slots.ToEpoch(b.slot)
-	var processedPartialWithdrawalsCount uint64
-	for _, w := range b.pendingPartialWithdrawals {
-		if w.WithdrawableEpoch > epoch || len(ws) >= int(params.BeaconConfig().MaxPendingPartialsPerWithdrawalsSweep) {
-			break
-		}
-
-		v, err := b.validatorAtIndexReadOnly(w.Index)
-		if err != nil {
-			return withdrawalIndex, 0, fmt.Errorf("failed to determine withdrawals at index %d: %w", w.Index, err)
-		}
-		vBal, err := b.balanceAtIndex(w.Index)
-		if err != nil {
-			return withdrawalIndex, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
-		}
-		hasSufficientEffectiveBalance := v.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
-		var totalWithdrawn uint64
-		for _, wi := range ws {
-			if wi.ValidatorIndex == w.Index {
-				totalWithdrawn += wi.Amount
-			}
-		}
-		balance, err := mathutil.Sub64(vBal, totalWithdrawn)
-		if err != nil {
-			return withdrawalIndex, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
-		}
-		hasExcessBalance := balance > params.BeaconConfig().MinActivationBalance
-		if v.ExitEpoch() == params.BeaconConfig().FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
-			amount := min(balance-params.BeaconConfig().MinActivationBalance, w.Amount)
-			ws = append(ws, &enginev1.Withdrawal{
-				Index:          withdrawalIndex,
-				ValidatorIndex: w.Index,
-				Address:        v.GetWithdrawalCredentials()[12:],
-				Amount:         amount,
-			})
-			withdrawalIndex++
-		}
-		processedPartialWithdrawalsCount++
-	}
-
-	*withdrawals = ws
-	return withdrawalIndex, processedPartialWithdrawalsCount, nil
-}
-
-func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, withdrawals *[]*enginev1.Withdrawal) error {
-	ws := *withdrawals
 	validatorIndex := b.nextWithdrawalValidatorIndex
-	validatorsLen := b.validatorsLen()
+	withdrawalIndex := b.nextWithdrawalIndex
 	epoch := slots.ToEpoch(b.slot)
+
+	// Electra partial withdrawals functionality.
+	var processedPartialWithdrawalsCount uint64
+	if b.version >= version.Electra {
+		for _, w := range b.pendingPartialWithdrawals {
+			if w.WithdrawableEpoch > epoch || len(withdrawals) >= int(params.BeaconConfig().MaxPendingPartialsPerWithdrawalsSweep) {
+				break
+			}
+
+			v, err := b.validatorAtIndexReadOnly(w.Index)
+			if err != nil {
+				return nil, 0, fmt.Errorf("failed to determine withdrawals at index %d: %w", w.Index, err)
+			}
+			vBal, err := b.balanceAtIndex(w.Index)
+			if err != nil {
+				return nil, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
+			}
+			hasSufficientEffectiveBalance := v.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
+			var totalWithdrawn uint64
+			for _, wi := range withdrawals {
+				if wi.ValidatorIndex == w.Index {
+					totalWithdrawn += wi.Amount
+				}
+			}
+			balance, err := mathutil.Sub64(vBal, totalWithdrawn)
+			if err != nil {
+				return nil, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
+			}
+			hasExcessBalance := balance > params.BeaconConfig().MinActivationBalance
+			if v.ExitEpoch() == params.BeaconConfig().FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
+				amount := min(balance-params.BeaconConfig().MinActivationBalance, w.Amount)
+				withdrawals = append(withdrawals, &enginev1.Withdrawal{
+					Index:          withdrawalIndex,
+					ValidatorIndex: w.Index,
+					Address:        v.GetWithdrawalCredentials()[12:],
+					Amount:         amount,
+				})
+				withdrawalIndex++
+			}
+			processedPartialWithdrawalsCount++
+		}
+	}
+
+	validatorsLen := b.validatorsLen()
 	bound := min(uint64(validatorsLen), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 	for range bound {
 		val, err := b.validatorAtIndexReadOnly(validatorIndex)
 		if err != nil {
-			return errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
+			return nil, 0, errors.Wrapf(err, "could not retrieve validator at index %d", validatorIndex)
 		}
 		balance, err := b.balanceAtIndex(validatorIndex)
 		if err != nil {
-			return errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
+			return nil, 0, errors.Wrapf(err, "could not retrieve balance at index %d", validatorIndex)
 		}
 		if b.version >= version.Electra {
 			var partiallyWithdrawnBalance uint64
-			for _, w := range ws {
+			for _, w := range withdrawals {
 				if w.ValidatorIndex == validatorIndex {
 					partiallyWithdrawnBalance += w.Amount
 				}
 			}
 			balance, err = mathutil.Sub64(balance, partiallyWithdrawnBalance)
 			if err != nil {
-				return errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
+				return nil, 0, errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
 			}
 		}
 		if helpers.IsFullyWithdrawableValidator(val, balance, epoch, b.version) {
-			ws = append(ws, &enginev1.Withdrawal{
+			withdrawals = append(withdrawals, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -214,7 +191,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 			})
 			withdrawalIndex++
 		} else if helpers.IsPartiallyWithdrawableValidator(val, balance, epoch, b.version) {
-			ws = append(ws, &enginev1.Withdrawal{
+			withdrawals = append(withdrawals, &enginev1.Withdrawal{
 				Index:          withdrawalIndex,
 				ValidatorIndex: validatorIndex,
 				Address:        bytesutil.SafeCopyBytes(val.GetWithdrawalCredentials()[ETH1AddressOffset:]),
@@ -222,7 +199,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 			})
 			withdrawalIndex++
 		}
-		if uint64(len(ws)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
+		if uint64(len(withdrawals)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
 			break
 		}
 		validatorIndex += 1
@@ -231,8 +208,7 @@ func (b *BeaconState) appendValidatorsSweepWithdrawals(withdrawalIndex uint64, w
 		}
 	}
 
-	*withdrawals = ws
-	return nil
+	return withdrawals, processedPartialWithdrawalsCount, nil
 }
 
 func (b *BeaconState) PendingPartialWithdrawals() ([]*ethpb.PendingPartialWithdrawal, error) {

changelog/bastin_add-cmd-to-gen-log.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- add `cmd` and all it's subcategories to the log.go generation process.

changelog/bastin_add-version-log-at-startup.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added a version log at startup to display the version of the build.

changelog/bastin_fix-check-logs-bug.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fixed a bug in `hack/check-logs.sh` where untracked files were ignored.

changelog/bastin_remove-prefix-print.md

@@ -0,0 +1,3 @@
+### Changed
+
+- remove printing of the `prefix` field in legacy logs.

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

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

changelog/potuz_hashtree_builds.md

@@ -1,2 +0,0 @@
-### Fixed
-- Fix hashtree release builds.

changelog/terencechain_core-requests.md

@@ -1,2 +0,0 @@
-### Ignored
-- Move withdrawal/consolidation request processing into `beacon-chain/core/requests` to avoid fork/package dependency cycles.

changelog/terencechain_gloas-duty-timings.md

@@ -1,2 +0,0 @@
-### Added
-- Gloas-specific timing intervals for validator attestation, aggregation, and sync duties.

changelog/terencechain_refactor-expected-withdrawals.md

@@ -1,2 +0,0 @@
-### Ignored
-- Refactor expected withdrawals into reusable helpers for future forks.

cmd/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "defaults.go",
         "flags.go",
         "helpers.go",
-        "log.go",
         "password_reader.go",
         "wrap_flags.go",
     ],

cmd/beacon-chain/db/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "db.go",
-        "log.go",
-    ],
+    srcs = ["db.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/db",
     visibility = ["//visibility:public"],
     deps = [

cmd/beacon-chain/db/db.go

@@ -4,9 +4,12 @@ import (
 	beacondb "github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/cmd"
 	"github.com/OffchainLabs/prysm/v7/runtime/tos"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "db")
+
 // Commands for interacting with a beacon chain database.
 var Commands = &cli.Command{
 	Name:     "db",

cmd/beacon-chain/db/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package db
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/db")

cmd/beacon-chain/flags/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package flags
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/flags")
+var log = logrus.WithField("prefix", "flags")

cmd/beacon-chain/genesis/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package genesis
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/genesis")
+var log = logrus.WithField("prefix", "genesis")

cmd/beacon-chain/jwt/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "jwt.go",
-        "log.go",
-    ],
+    srcs = ["jwt.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/jwt",
     visibility = ["//visibility:public"],
     deps = [

cmd/beacon-chain/jwt/jwt.go

@@ -6,6 +6,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/cmd"
 	"github.com/OffchainLabs/prysm/v7/io/file"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -22,7 +23,7 @@ var Commands = &cli.Command{
 	}),
 	Action: func(cliCtx *cli.Context) error {
 		if err := generateAuthSecretInFile(cliCtx); err != nil {
-			log.WithError(err).Fatal("Could not generate jwt")
+			logrus.WithError(err).Fatal("Could not generate jwt")
 		}
 		return nil
 	},
@@ -56,6 +57,6 @@ func generateAuthSecretInFile(c *cli.Context) error {
 	if err := file.WriteFile(fileName, []byte(secret)); err != nil {
 		return err
 	}
-	log.Infof("Successfully wrote JSON-RPC authentication secret to file %s", fileName)
+	logrus.Infof("Successfully wrote JSON-RPC authentication secret to file %s", fileName)
 	return nil
 }

cmd/beacon-chain/jwt/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package jwt
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/jwt")

cmd/beacon-chain/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package main
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain")
+var log = logrus.WithField("prefix", "main")

cmd/beacon-chain/main.go

@@ -243,11 +243,6 @@ func before(ctx *cli.Context) error {
 		}
 	}
 
-	// Log Prysm version on startup. After initializing log-file and ephemeral log-file.
-	log.WithFields(logrus.Fields{
-		"version": version.Version(),
-	}).Info("Prysm Beacon Chain started")
-
 	if err := cmd.ExpandSingleEndpointIfFile(ctx, flags.ExecutionEngineEndpoint); err != nil {
 		return errors.Wrap(err, "failed to expand single endpoint")
 	}

cmd/beacon-chain/storage/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "log.go",
-        "options.go",
-    ],
+    srcs = ["options.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/storage",
     visibility = ["//visibility:public"],
     deps = [

cmd/beacon-chain/storage/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package storage
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/beacon-chain/storage")

cmd/beacon-chain/storage/options.go

@@ -15,6 +15,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/client-stats/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package main
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/client-stats")
+var log = logrus.WithField("prefix", "main")

cmd/helpers.go

@@ -14,6 +14,8 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "node")
+
 // ConfirmAction uses the passed in actionText as the confirmation text displayed in the terminal.
 // The user must enter Y or N to indicate whether they confirm the action detailed in the warning text.
 // Returns a boolean representing the user's answer.

cmd/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package cmd
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd")

cmd/prysmctl/BUILD.bazel

@@ -4,10 +4,7 @@ load("//tools:prysm_image.bzl", "prysm_image_upload")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "log.go",
-        "main.go",
-    ],
+    srcs = ["main.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/prysmctl",
     visibility = ["//visibility:private"],
     deps = [

cmd/prysmctl/checkpointsync/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "cmd.go",
         "download.go",
-        "log.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/prysmctl/checkpointsync",
     visibility = ["//visibility:public"],

cmd/prysmctl/checkpointsync/download.go

@@ -8,6 +8,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api/client"
 	"github.com/OffchainLabs/prysm/v7/api/client/beacon"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/sync/checkpoint"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/prysmctl/checkpointsync/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package checkpointsync
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/checkpointsync")

cmd/prysmctl/db/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "buckets.go",
         "cmd.go",
-        "log.go",
         "query.go",
         "span.go",
     ],

cmd/prysmctl/db/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package db
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/db")

cmd/prysmctl/db/query.go

@@ -8,6 +8,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 	bolt "go.etcd.io/bbolt"
 )

cmd/prysmctl/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package main
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl")

cmd/prysmctl/main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/cmd/prysmctl/testnet"
 	"github.com/OffchainLabs/prysm/v7/cmd/prysmctl/validator"
 	"github.com/OffchainLabs/prysm/v7/cmd/prysmctl/weaksubjectivity"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/prysmctl/p2p/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package p2p
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/p2p")
+var log = logrus.WithField("prefix", "prysmctl-p2p")

cmd/prysmctl/testnet/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "generate_genesis.go",
-        "log.go",
         "testnet.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/prysmctl/testnet",

cmd/prysmctl/testnet/generate_genesis.go

@@ -43,6 +43,7 @@ var (
 		GethGenesisJsonIn  string
 		GethGenesisJsonOut string
 	}{}
+	log           = logrus.WithField("prefix", "genesis")
 	outputSSZFlag = &cli.StringFlag{
 		Name:        "output-ssz",
 		Destination: &generateGenesisStateFlags.OutputSSZ,

cmd/prysmctl/testnet/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package testnet
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/testnet")

cmd/prysmctl/validator/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "cmd.go",
         "error.go",
-        "log.go",
         "proposer_settings.go",
         "withdraw.go",
     ],

cmd/prysmctl/validator/cmd.go

@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/runtime/tos"
 	"github.com/logrusorgru/aurora"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/prysmctl/validator/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package validator
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/validator")

cmd/prysmctl/validator/proposer_settings.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	validatorpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/validator-client"
 	"github.com/ethereum/go-ethereum/common"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/prysmctl/validator/withdraw.go

@@ -18,7 +18,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/logrusorgru/aurora"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -143,7 +143,7 @@ func checkIfWithdrawsAreInPool(ctx context.Context, client *beacon.Client, reque
 	}
 	if len(requestMap) != 0 {
 		for key, address := range requestMap {
-			log.WithFields(logrus.Fields{
+			log.WithFields(log.Fields{
 				"validatorIndex":    key,
 				"executionAddress:": address,
 			}).Warn("Set withdrawal address message not found in the node's operations pool.")

cmd/prysmctl/weaksubjectivity/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "checkpoint.go",
         "cmd.go",
-        "log.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/prysmctl/weaksubjectivity",
     visibility = ["//visibility:public"],

cmd/prysmctl/weaksubjectivity/checkpoint.go

@@ -8,6 +8,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api/client"
 	"github.com/OffchainLabs/prysm/v7/api/client/beacon"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/sync/checkpoint"
+	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 

cmd/prysmctl/weaksubjectivity/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package weaksubjectivity
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/prysmctl/weaksubjectivity")

cmd/validator/BUILD.bazel

@@ -5,7 +5,6 @@ load("//tools:prysm_image.bzl", "prysm_image_upload")
 go_library(
     name = "go_default_library",
     srcs = [
-        "log.go",
         "main.go",
         "usage.go",
     ],

cmd/validator/accounts/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "exit.go",
         "import.go",
         "list.go",
-        "log.go",
         "wallet_utils.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/validator/accounts",

cmd/validator/accounts/accounts.go

@@ -7,9 +7,12 @@ import (
 	"github.com/OffchainLabs/prysm/v7/cmd/validator/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/runtime/tos"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "accounts")
+
 // Commands for managing Prysm validator accounts.
 var Commands = &cli.Command{
 	Name:     "accounts",

cmd/validator/accounts/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package accounts
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator/accounts")

cmd/validator/db/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "db.go",
-        "log.go",
-    ],
+    srcs = ["db.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/cmd/validator/db",
     visibility = ["//visibility:public"],
     deps = [

cmd/validator/db/db.go

@@ -4,9 +4,12 @@ import (
 	"github.com/OffchainLabs/prysm/v7/cmd"
 	"github.com/OffchainLabs/prysm/v7/runtime/tos"
 	validatordb "github.com/OffchainLabs/prysm/v7/validator/db"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "db")
+
 var (
 	// SourceDataDirFlag defines a path on disk where source Prysm databases are stored. Used for conversion.
 	SourceDataDirFlag = &cli.StringFlag{

cmd/validator/db/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package db
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator/db")

cmd/validator/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package main
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator")

cmd/validator/main.go

@@ -34,6 +34,8 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "main")
+
 func startNode(ctx *cli.Context) error {
 	// Verify if ToS is accepted.
 	if err := tos.VerifyTosAcceptedOrPrompt(ctx); err != nil {
@@ -219,11 +221,6 @@ func main() {
 				}
 			}
 
-			// Log Prysm version on startup. After initializing log-file and ephemeral log-file.
-			log.WithFields(logrus.Fields{
-				"version": version.Version(),
-			}).Info("Prysm Validator started")
-
 			// Fix data dir for Windows users.
 			outdatedDataDir := filepath.Join(file.HomeDir(), "AppData", "Roaming", "Eth2Validators")
 			currentDataDir := flags.DefaultValidatorDir()

cmd/validator/slashing-protection/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package historycmd
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator/slashing-protection")
+var log = logrus.WithField("prefix", "historycmd")

cmd/validator/wallet/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "create.go",
-        "log.go",
         "recover.go",
         "wallet.go",
     ],

cmd/validator/wallet/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package wallet
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator/wallet")

cmd/validator/wallet/wallet.go

@@ -5,9 +5,12 @@ import (
 	"github.com/OffchainLabs/prysm/v7/cmd/validator/flags"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/runtime/tos"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
+var log = logrus.WithField("prefix", "wallet")
+
 // Commands for wallets for Prysm validators.
 var Commands = &cli.Command{
 	Name:     "wallet",

cmd/validator/web/log.go

@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package web
 
 import "github.com/sirupsen/logrus"
 
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "cmd/validator/web")
+var log = logrus.WithField("prefix", "web")

config/params/config.go

@@ -91,10 +91,6 @@ type BeaconChainConfig struct {
 	AggregateDueBPS                 primitives.BP    `yaml:"AGGREGATE_DUE_BPS" spec:"true"`                   // AggregateDueBPS defines the aggregate due time in basis points of the slot.
 	SyncMessageDueBPS               primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS" spec:"true"`                // SyncMessageDueBPS defines the sync message due time in basis points of the slot.
 	ContributionDueBPS              primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS" spec:"true"`                // ContributionDueBPS defines the contribution due time in basis points of the slot.
-	AttestationDueBPSGloas          primitives.BP    `yaml:"ATTESTATION_DUE_BPS_GLOAS" spec:"true"`           // AttestationDueBPSGloas defines the attestation due time in basis points of the slot (Gloas).
-	AggregateDueBPSGloas            primitives.BP    `yaml:"AGGREGATE_DUE_BPS_GLOAS" spec:"true"`             // AggregateDueBPSGloas defines the aggregate due time in basis points of the slot (Gloas).
-	SyncMessageDueBPSGloas          primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS_GLOAS" spec:"true"`          // SyncMessageDueBPSGloas defines the sync message due time in basis points of the slot (Gloas).
-	ContributionDueBPSGloas         primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS_GLOAS" spec:"true"`          // ContributionDueBPSGloas defines the contribution due time in basis points of the slot (Gloas).
 
 	// Ethereum PoW parameters.
 	DepositChainID         uint64 `yaml:"DEPOSIT_CHAIN_ID" spec:"true"`         // DepositChainID of the eth1 network. This used for replay protection.
@@ -191,7 +187,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.
-	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.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -347,7 +342,6 @@ func (b *BeaconChainConfig) VersionToForkEpochMap() map[int]primitives.Epoch {
 		version.Deneb:     b.DenebForkEpoch,
 		version.Electra:   b.ElectraForkEpoch,
 		version.Fulu:      b.FuluForkEpoch,
-		version.Gloas:     b.GloasForkEpoch,
 	}
 }
 

config/params/loader.go

@@ -224,7 +224,6 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("ELECTRA_FORK_VERSION: %#x", cfg.ElectraForkVersion),
 		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("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),
@@ -247,10 +246,6 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("AGGREGATE_DUE_BPS: %d", cfg.AggregateDueBPS),
 		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS: %d", cfg.SyncMessageDueBPS),
 		fmt.Sprintf("CONTRIBUTION_DUE_BPS: %d", cfg.ContributionDueBPS),
-		fmt.Sprintf("ATTESTATION_DUE_BPS_GLOAS: %d", cfg.AttestationDueBPSGloas),
-		fmt.Sprintf("AGGREGATE_DUE_BPS_GLOAS: %d", cfg.AggregateDueBPSGloas),
-		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS_GLOAS: %d", cfg.SyncMessageDueBPSGloas),
-		fmt.Sprintf("CONTRIBUTION_DUE_BPS_GLOAS: %d", cfg.ContributionDueBPSGloas),
 	}
 
 	if len(cfg.BlobSchedule) > 0 {

config/params/loader_test.go

@@ -24,9 +24,12 @@ import (
 // These are variables that we don't use in Prysm. (i.e. future hardfork, light client... etc)
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
+	"AGGREGATE_DUE_BPS_GLOAS",
 	"ATTESTATION_DEADLINE",
+	"ATTESTATION_DUE_BPS_GLOAS",
 	"BLOB_SIDECAR_SUBNET_COUNT_FULU",
 	"CELLS_PER_EXT_BLOB",
+	"CONTRIBUTION_DUE_BPS_GLOAS",
 	"EIP6110_FORK_EPOCH",
 	"EIP6110_FORK_VERSION",
 	"EIP7002_FORK_EPOCH",
@@ -42,6 +45,7 @@ var placeholderFields = []string{
 	"EPOCHS_PER_SHUFFLING_PHASE",
 	"FIELD_ELEMENTS_PER_CELL",     // Configured as a constant in config/fieldparams/mainnet.go
 	"FIELD_ELEMENTS_PER_EXT_BLOB", // Configured in proto/ssz_proto_library.bzl
+	"GLOAS_FORK_EPOCH",
 	"GLOAS_FORK_VERSION",
 	"INCLUSION_LIST_SUBMISSION_DEADLINE",
 	"INCLUSION_LIST_SUBMISSION_DUE_BPS",
@@ -56,6 +60,7 @@ var placeholderFields = []string{
 	"PROPOSER_INCLUSION_LIST_CUTOFF",
 	"PROPOSER_INCLUSION_LIST_CUTOFF_BPS",
 	"PROPOSER_SELECTION_GAP",
+	"SYNC_MESSAGE_DUE_BPS_GLOAS",
 	"TARGET_NUMBER_OF_PEERS",
 	"UPDATE_TIMEOUT",
 	"VIEW_FREEZE_CUTOFF_BPS",

config/params/mainnet_config.go

@@ -32,8 +32,6 @@ const (
 	mainnetElectraForkEpoch = 364032 // May 7, 2025, 10:05:11 UTC
 	// Fulu Fork Epoch for mainnet config
 	mainnetFuluForkEpoch = 411392 // December 3, 2025, 09:49:11pm UTC
-	// Gloas Fork Epoch for mainnet config
-	mainnetGloasForkEpoch = math.MaxUint64
 )
 
 var mainnetNetworkConfig = &NetworkConfig{
@@ -123,15 +121,11 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	IntervalsPerSlot:                3,
 
 	// Time-based protocol parameters.
-	ProposerReorgCutoffBPS:  primitives.BP(1667),
-	AttestationDueBPS:       primitives.BP(3333),
-	AggregateDueBPS:         primitives.BP(6667),
-	SyncMessageDueBPS:       primitives.BP(3333),
-	ContributionDueBPS:      primitives.BP(6667),
-	AttestationDueBPSGloas:  primitives.BP(2500),
-	AggregateDueBPSGloas:    primitives.BP(5000),
-	SyncMessageDueBPSGloas:  primitives.BP(2500),
-	ContributionDueBPSGloas: primitives.BP(5000),
+	ProposerReorgCutoffBPS: primitives.BP(1667),
+	AttestationDueBPS:      primitives.BP(3333),
+	AggregateDueBPS:        primitives.BP(6667),
+	SyncMessageDueBPS:      primitives.BP(3333),
+	ContributionDueBPS:     primitives.BP(6667),
 
 	// Ethereum PoW parameters.
 	DepositChainID:         1, // Chain ID of eth1 mainnet.
@@ -240,7 +234,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
 	FuluForkVersion:      []byte{6, 0, 0, 0},
 	FuluForkEpoch:        mainnetFuluForkEpoch,
-	GloasForkEpoch:       mainnetGloasForkEpoch,
 
 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.

config/params/minimal_config.go

@@ -35,10 +35,6 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	// Time parameters
 	minimalConfig.SecondsPerSlot = 6
 	minimalConfig.SlotDurationMilliseconds = 6000
-	minimalConfig.AttestationDueBPSGloas = 2500
-	minimalConfig.AggregateDueBPSGloas = 5000
-	minimalConfig.SyncMessageDueBPSGloas = 2500
-	minimalConfig.ContributionDueBPSGloas = 5000
 	minimalConfig.MinAttestationInclusionDelay = 1
 	minimalConfig.SlotsPerEpoch = 8
 	minimalConfig.SqrRootSlotsPerEpoch = 2
@@ -102,7 +98,6 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ElectraForkEpoch = math.MaxUint64
 	minimalConfig.FuluForkVersion = []byte{6, 0, 0, 1}
 	minimalConfig.FuluForkEpoch = math.MaxUint64
-	minimalConfig.GloasForkEpoch = minimalConfig.FarFutureEpoch
 
 	minimalConfig.SyncCommitteeSize = 32
 	minimalConfig.InactivityScoreBias = 4

crypto/hash/htr/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "hashtree.go",
-        "log.go",
-    ],
+    srcs = ["hashtree.go"],
     importpath = "github.com/OffchainLabs/prysm/v7/crypto/hash/htr",
     visibility = ["//visibility:public"],
     deps = [

crypto/hash/htr/hashtree.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/hashtree"
 	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/prysmaticlabs/gohashtree"
+	log "github.com/sirupsen/logrus"
 )
 
 const minSliceSizeToParallelize = 5000

crypto/hash/htr/log.go

@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package htr
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "crypto/hash/htr")

hack/check-logs.sh

@@ -8,13 +8,12 @@ cd "$ROOT_DIR"
 ./hack/gen-logs.sh
 
 # Fail if that changed anything
-if ! git diff --quiet -- ./ || [[ -n "$(git ls-files --others --exclude-standard -- ./)" ]]; then
+if ! git diff --quiet -- ./; then
   echo "ERROR: log.go files are out of date. Please run:"
   echo "  ./hack/gen-logs.sh"
   echo "and commit the changes."
   echo
   git diff --stat -- ./ || true
-  git status --porcelain -- ./ || true
   exit 1
 fi
 

hack/gen-logs.sh

@@ -14,6 +14,7 @@ EXCLUDED_PATH_PREFIXES=(
   "runtime"
   "monitoring"
   "io"
+  "cmd"
   ".well-known"
   "changelog"
   "hack"

io/logs/logutil.go

@@ -31,7 +31,7 @@ func addLogWriter(w io.Writer) {
 
 // ConfigurePersistentLogging adds a log-to-file writer. File content is identical to stdout.
 func ConfigurePersistentLogging(logFileName string, format string, lvl logrus.Level, vmodule map[string]logrus.Level) error {
-	logrus.WithField("logFileName", logFileName).Debug("Logs will be made persistent")
+	logrus.WithField("logFileName", logFileName).Info("Logs will be made persistent")
 	if err := file.MkdirAll(filepath.Dir(logFileName)); err != nil {
 		return err
 	}
@@ -43,7 +43,7 @@ func ConfigurePersistentLogging(logFileName string, format string, lvl logrus.Le
 	if format != "text" {
 		addLogWriter(f)
 
-		logrus.Debug("File logging initialized")
+		logrus.Info("File logging initialized")
 		return nil
 	}
 
@@ -70,7 +70,7 @@ func ConfigurePersistentLogging(logFileName string, format string, lvl logrus.Le
 		AllowedLevels: logrus.AllLevels[:max(lvl, maxVmoduleLevel)+1],
 	})
 
-	logrus.Debug("File logging initialized")
+	logrus.Info("File logging initialized")
 	return nil
 }
 
@@ -103,7 +103,7 @@ func ConfigureEphemeralLogFile(datadirPath string, app string) error {
 		AllowedLevels: logrus.AllLevels[:ephemeralLogFileVerbosity+1],
 	})
 
-	logrus.Debug("Ephemeral log file initialized")
+	logrus.Info("Ephemeral log file initialized")
 	return nil
 }
 

runtime/logging/logrus-prefixed-formatter/formatter.go

@@ -334,7 +334,7 @@ func (f *TextFormatter) printColored(b *bytes.Buffer, entry *logrus.Entry, keys
 		_, err = fmt.Fprintf(b, "%s %s%s "+messageFormat, colorScheme.TimestampColor(timestamp), level, prefix, message)
 	}
 	for _, k := range keys {
-		if k != "package" {
+		if k != "package" && k != "prefix" {
 			v := entry.Data[k]
 
 			format := "%+v"