Update Spectests to v1.7.0.alpha-1 (#16246)

WORKSPACE

@@ -273,16 +273,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.7.0-alpha.0"
+consensus_spec_version = "v1.7.0-alpha.1"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-b+rJOuVqq+Dy53quPcNYcQwPFoMU7Wp7tdUVe7n0g8w=",
-        "minimal": "sha256-qxRIxtjPxVsVCY90WsBJKhk0027XDSmhjnRvRN14V1c=",
-        "mainnet": "sha256-NsuOQG3LzeiEE1TrWuvQ6vu6BboHv7h7f/RTS0pWkCs=",
+        "general": "sha256-j5R3jA7Oo4OSDMTvpMuD+8RomaCByeFSwtfkq6fL0Zg=",
+        "minimal": "sha256-tdTqByoyswOS4r6OxFmo70y2BP7w1TgEok+gf4cbxB0=",
+        "mainnet": "sha256-5gB4dt6SnSDKzdBc06VedId3NkgvSYyv9n9FRxWKwYI=",
     },
     version = consensus_spec_version,
 )
@@ -298,7 +298,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-hwNdUBgdBrkk6pWIpNYbzbwswUuOu6AMD2exN8uv+QQ=",
+    integrity = "sha256-J+43DrK1pF658kTXTwMS6zGf4KDjvas++m8w2a8swpg=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

beacon-chain/core/blocks/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",

beacon-chain/core/blocks/withdrawals.go

@@ -7,7 +7,6 @@ import (
 	"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"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -213,12 +212,7 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
 		}
-		if features.Get().LowValcountSweep {
-			bound := min(uint64(st.NumValidators()), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-			nextValidatorIndex += primitives.ValidatorIndex(bound)
-		} else {
-			nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		}
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
 		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1

beacon-chain/core/gloas/BUILD.bazel

@@ -1,43 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["payload.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/electra:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/ssz:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["payload_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//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/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//encoding/ssz:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)

beacon-chain/core/gloas/payload.go

@@ -1,341 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// ProcessExecutionPayload processes the signed execution payload envelope for the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def process_execution_payload(
-//
-//	state: BeaconState,
-//	signed_envelope: SignedExecutionPayloadEnvelope,
-//	execution_engine: ExecutionEngine,
-//	verify: bool = True,
-//
-// ) -> None:
-//
-//	envelope = signed_envelope.message
-//	payload = envelope.payload
-//
-//	if verify:
-//	    assert verify_execution_payload_envelope_signature(state, signed_envelope)
-//
-//	previous_state_root = hash_tree_root(state)
-//	if state.latest_block_header.state_root == Root():
-//	    state.latest_block_header.state_root = previous_state_root
-//
-//	assert envelope.beacon_block_root == hash_tree_root(state.latest_block_header)
-//	assert envelope.slot == state.slot
-//
-//	committed_bid = state.latest_execution_payload_bid
-//	assert envelope.builder_index == committed_bid.builder_index
-//	assert committed_bid.blob_kzg_commitments_root == hash_tree_root(envelope.blob_kzg_commitments)
-//	assert committed_bid.prev_randao == payload.prev_randao
-//
-//	assert hash_tree_root(payload.withdrawals) == hash_tree_root(state.payload_expected_withdrawals)
-//
-//	assert committed_bid.gas_limit == payload.gas_limit
-//	assert committed_bid.block_hash == payload.block_hash
-//	assert payload.parent_hash == state.latest_block_hash
-//	assert payload.timestamp == compute_time_at_slot(state, state.slot)
-//	assert (
-//	    len(envelope.blob_kzg_commitments)
-//	    <= get_blob_parameters(get_current_epoch(state)).max_blobs_per_block
-//	)
-//	versioned_hashes = [
-//	    kzg_commitment_to_versioned_hash(commitment) for commitment in envelope.blob_kzg_commitments
-//	]
-//	requests = envelope.execution_requests
-//	assert execution_engine.verify_and_notify_new_payload(
-//	    NewPayloadRequest(
-//	        execution_payload=payload,
-//	        versioned_hashes=versioned_hashes,
-//	        parent_beacon_block_root=state.latest_block_header.parent_root,
-//	        execution_requests=requests,
-//	    )
-//	)
-//
-//	for op in requests.deposits: process_deposit_request(state, op)
-//	for op in requests.withdrawals: process_withdrawal_request(state, op)
-//	for op in requests.consolidations: process_consolidation_request(state, op)
-//
-//	payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
-//	amount = payment.withdrawal.amount
-//	if amount > 0:
-//	    state.builder_pending_withdrawals.append(payment.withdrawal)
-//	state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = (
-//	    BuilderPendingPayment()
-//	)
-//
-//	state.execution_payload_availability[state.slot % SLOTS_PER_HISTORICAL_ROOT] = 0b1
-//	state.latest_block_hash = payload.block_hash
-//
-//	if verify:
-//	    assert envelope.state_root == hash_tree_root(state)
-func ProcessExecutionPayload(
-	ctx context.Context,
-	st state.BeaconState,
-	signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope,
-) error {
-	// Verify the signature on the signed execution payload envelope
-	if err := verifyExecutionPayloadEnvelopeSignature(st, signedEnvelope); err != nil {
-		return errors.Wrap(err, "signature verification failed")
-	}
-
-	envelope, err := signedEnvelope.Envelope()
-	if err != nil {
-		return errors.Wrap(err, "could not get envelope from signed envelope")
-	}
-	payload, err := envelope.Execution()
-	if err != nil {
-		return errors.Wrap(err, "could not get execution payload from envelope")
-	}
-
-	latestHeader := st.LatestBlockHeader()
-	if len(latestHeader.StateRoot) == 0 || bytes.Equal(latestHeader.StateRoot, make([]byte, 32)) {
-		previousStateRoot, err := st.HashTreeRoot(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not compute state root")
-		}
-		latestHeader.StateRoot = previousStateRoot[:]
-		if err := st.SetLatestBlockHeader(latestHeader); err != nil {
-			return errors.Wrap(err, "could not set latest block header")
-		}
-	}
-
-	blockHeaderRoot, err := latestHeader.HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not compute block header root")
-	}
-	beaconBlockRoot := envelope.BeaconBlockRoot()
-	if !bytes.Equal(beaconBlockRoot[:], blockHeaderRoot[:]) {
-		return errors.Errorf("envelope beacon block root does not match state latest block header root: envelope=%#x, header=%#x", beaconBlockRoot, blockHeaderRoot)
-	}
-
-	if envelope.Slot() != st.Slot() {
-		return errors.Errorf("envelope slot does not match state slot: envelope=%d, state=%d", envelope.Slot(), st.Slot())
-	}
-
-	latestBid, err := st.LatestExecutionPayloadBid()
-	if err != nil {
-		return errors.Wrap(err, "could not get latest execution payload bid")
-	}
-	if latestBid == nil {
-		return errors.New("latest execution payload bid is nil")
-	}
-	if envelope.BuilderIndex() != latestBid.BuilderIndex() {
-		return errors.Errorf("envelope builder index does not match committed bid builder index: envelope=%d, bid=%d", envelope.BuilderIndex(), latestBid.BuilderIndex())
-	}
-
-	envelopeBlobCommitments := envelope.BlobKzgCommitments()
-	envelopeBlobRoot, err := ssz.KzgCommitmentsRoot(envelopeBlobCommitments)
-	if err != nil {
-		return errors.Wrap(err, "could not compute envelope blob KZG commitments root")
-	}
-	committedBlobRoot := latestBid.BlobKzgCommitmentsRoot()
-	if !bytes.Equal(committedBlobRoot[:], envelopeBlobRoot[:]) {
-		return errors.Errorf("committed bid blob KZG commitments root does not match envelope: bid=%#x, envelope=%#x", committedBlobRoot, envelopeBlobRoot)
-	}
-
-	withdrawals, err := payload.Withdrawals()
-	if err != nil {
-		return errors.Wrap(err, "could not get withdrawals from payload")
-	}
-	cfg := params.BeaconConfig()
-	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, cfg.MaxWithdrawalsPerPayload)
-	if err != nil {
-		return errors.Wrap(err, "could not compute withdrawals root")
-	}
-
-	expectedWithdrawals, err := st.PayloadExpectedWithdrawals()
-	if err != nil {
-		return errors.Wrap(err, "could not get expected withdrawals")
-	}
-	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, cfg.MaxWithdrawalsPerPayload)
-	if err != nil {
-		return errors.Wrap(err, "could not compute expected withdrawals root")
-	}
-	if !bytes.Equal(withdrawalsRoot[:], expectedRoot[:]) {
-		return errors.Errorf("payload withdrawals root does not match expected withdrawals: payload=%#x, expected=%#x", withdrawalsRoot, expectedRoot)
-	}
-
-	if latestBid.GasLimit() != payload.GasLimit() {
-		return errors.Errorf("committed bid gas limit does not match payload gas limit: bid=%d, payload=%d", latestBid.GasLimit(), payload.GasLimit())
-	}
-
-	latestBidPrevRandao := latestBid.PrevRandao()
-	if !bytes.Equal(payload.PrevRandao(), latestBidPrevRandao[:]) {
-		return errors.Errorf("payload prev randao does not match committed bid prev randao: payload=%#x, bid=%#x", payload.PrevRandao(), latestBidPrevRandao)
-	}
-
-	bidBlockHash := latestBid.BlockHash()
-	payloadBlockHash := payload.BlockHash()
-	if !bytes.Equal(bidBlockHash[:], payloadBlockHash) {
-		return errors.Errorf("committed bid block hash does not match payload block hash: bid=%#x, payload=%#x", bidBlockHash, payloadBlockHash)
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return errors.Wrap(err, "could not get latest block hash")
-	}
-	if !bytes.Equal(payload.ParentHash(), latestBlockHash[:]) {
-		return errors.Errorf("payload parent hash does not match state latest block hash: payload=%#x, state=%#x", payload.ParentHash(), latestBlockHash)
-	}
-
-	t, err := slots.StartTime(st.GenesisTime(), st.Slot())
-	if err != nil {
-		return errors.Wrap(err, "could not compute timestamp")
-	}
-	if payload.Timestamp() != uint64(t.Unix()) {
-		return errors.Errorf("payload timestamp does not match expected timestamp: payload=%d, expected=%d", payload.Timestamp(), uint64(t.Unix()))
-	}
-
-	maxBlobsPerBlock := cfg.MaxBlobsPerBlock(envelope.Slot())
-	if len(envelopeBlobCommitments) > maxBlobsPerBlock {
-		return errors.Errorf("too many blob KZG commitments: got=%d, max=%d", len(envelopeBlobCommitments), maxBlobsPerBlock)
-	}
-
-	if err := processExecutionRequests(ctx, st, envelope.ExecutionRequests()); err != nil {
-		return errors.Wrap(err, "could not process execution requests")
-	}
-
-	if err := queueBuilderPayment(ctx, st); err != nil {
-		return errors.Wrap(err, "could not queue builder payment")
-	}
-
-	if err := st.SetExecutionPayloadAvailability(st.Slot(), true); err != nil {
-		return errors.Wrap(err, "could not set execution payload availability")
-	}
-
-	if err := st.SetLatestBlockHash([32]byte(payload.BlockHash())); err != nil {
-		return errors.Wrap(err, "could not set latest block hash")
-	}
-
-	r, err := st.HashTreeRoot(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get hash tree root")
-	}
-	if r != envelope.StateRoot() {
-		return fmt.Errorf("state root mismatch: expected %#x, got %#x", envelope.StateRoot(), r)
-	}
-
-	return nil
-}
-
-// processExecutionRequests processes deposits, withdrawals, and consolidations from execution requests.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// for op in requests.deposits: process_deposit_request(state, op)
-// for op in requests.withdrawals: process_withdrawal_request(state, op)
-// for op in requests.consolidations: process_consolidation_request(state, op)
-func processExecutionRequests(ctx context.Context, st state.BeaconState, requests *enginev1.ExecutionRequests) error {
-	var err error
-	st, err = electra.ProcessDepositRequests(ctx, st, requests.Deposits)
-	if err != nil {
-		return errors.Wrap(err, "could not process deposit requests")
-	}
-
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
-	if err != nil {
-		return errors.Wrap(err, "could not process withdrawal requests")
-	}
-	err = electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations)
-	if err != nil {
-		return errors.Wrap(err, "could not process consolidation requests")
-	}
-	return nil
-}
-
-// queueBuilderPayment implements the builder payment queuing logic for Gloas.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// payment = state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH]
-// amount = payment.withdrawal.amount
-// if amount > 0:
-//
-//	state.builder_pending_withdrawals.append(payment.withdrawal)
-//
-// state.builder_pending_payments[SLOTS_PER_EPOCH + state.slot % SLOTS_PER_EPOCH] = BuilderPendingPayment()
-func queueBuilderPayment(ctx context.Context, st state.BeaconState) error {
-	slot := st.Slot()
-	payment, err := st.BuilderPendingPayment(slot)
-	if err != nil {
-		return errors.Wrap(err, "could not get builder pending payment")
-	}
-
-	if payment.Withdrawal != nil && payment.Withdrawal.Amount > 0 {
-		if err := st.AppendBuilderPendingWithdrawal(payment.Withdrawal); err != nil {
-			return errors.Wrap(err, "could not append builder pending withdrawal")
-		}
-	}
-
-	reset := &ethpb.BuilderPendingPayment{
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-		},
-	}
-	if err := st.SetBuilderPendingPayment(slot, reset); err != nil {
-		return errors.Wrap(err, "could not set builder pending payment")
-	}
-
-	return nil
-}
-
-// verifyExecutionPayloadEnvelopeSignature verifies the BLS signature on a signed execution payload envelope.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// if verify: assert verify_execution_payload_envelope_signature(state, signed_envelope)
-func verifyExecutionPayloadEnvelopeSignature(st state.BeaconState, signedEnvelope interfaces.ROSignedExecutionPayloadEnvelope) error {
-	envelope, err := signedEnvelope.Envelope()
-	if err != nil {
-		return fmt.Errorf("failed to get envelope: %w", err)
-	}
-
-	builderIdx := envelope.BuilderIndex()
-	builderPubkey := st.PubkeyAtIndex(primitives.ValidatorIndex(builderIdx))
-	publicKey, err := bls.PublicKeyFromBytes(builderPubkey[:])
-	if err != nil {
-		return fmt.Errorf("invalid builder public key: %w", err)
-	}
-
-	signatureBytes := signedEnvelope.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return fmt.Errorf("invalid signature format: %w", err)
-	}
-
-	currentEpoch := slots.ToEpoch(envelope.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing domain: %w", err)
-	}
-
-	signingRoot, err := signedEnvelope.SigningRoot(domain)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing root: %w", err)
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
-	}
-
-	return nil
-}

beacon-chain/core/gloas/payload_test.go

@@ -1,269 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"testing"
-
-	"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"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"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/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-type payloadFixture struct {
-	state       state.BeaconState
-	signed      interfaces.ROSignedExecutionPayloadEnvelope
-	signedProto *ethpb.SignedExecutionPayloadEnvelope
-	envelope    *ethpb.ExecutionPayloadEnvelope
-	payload     *enginev1.ExecutionPayloadDeneb
-	slot        primitives.Slot
-}
-
-func buildPayloadFixture(t *testing.T, mutate func(payload *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, envelope *ethpb.ExecutionPayloadEnvelope)) payloadFixture {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(0)
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pk := sk.PublicKey().Marshal()
-
-	randao := bytes.Repeat([]byte{0xAA}, 32)
-	parentHash := bytes.Repeat([]byte{0xBB}, 32)
-	blockHash := bytes.Repeat([]byte{0xCC}, 32)
-
-	withdrawals := []*enginev1.Withdrawal{
-		{Index: 0, ValidatorIndex: 1, Address: bytes.Repeat([]byte{0x01}, 20), Amount: 0},
-	}
-
-	blobCommitments := [][]byte{}
-	blobRoot, err := ssz.KzgCommitmentsRoot(blobCommitments)
-	require.NoError(t, err)
-
-	payload := &enginev1.ExecutionPayloadDeneb{
-		ParentHash:    parentHash,
-		FeeRecipient:  bytes.Repeat([]byte{0x01}, 20),
-		StateRoot:     bytes.Repeat([]byte{0x02}, 32),
-		ReceiptsRoot:  bytes.Repeat([]byte{0x03}, 32),
-		LogsBloom:     bytes.Repeat([]byte{0x04}, 256),
-		PrevRandao:    randao,
-		BlockNumber:   1,
-		GasLimit:      1,
-		GasUsed:       0,
-		Timestamp:     100,
-		ExtraData:     []byte{},
-		BaseFeePerGas: bytes.Repeat([]byte{0x05}, 32),
-		BlockHash:     blockHash,
-		Transactions:  [][]byte{},
-		Withdrawals:   withdrawals,
-		BlobGasUsed:   0,
-		ExcessBlobGas: 0,
-	}
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        parentHash,
-		ParentBlockRoot:        bytes.Repeat([]byte{0xDD}, 32),
-		BlockHash:              blockHash,
-		PrevRandao:             randao,
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: blobRoot[:],
-		FeeRecipient:           bytes.Repeat([]byte{0xEE}, 20),
-	}
-
-	header := &ethpb.BeaconBlockHeader{
-		Slot:       slot,
-		ParentRoot: bytes.Repeat([]byte{0x11}, 32),
-		StateRoot:  bytes.Repeat([]byte{0x22}, 32),
-		BodyRoot:   bytes.Repeat([]byte{0x33}, 32),
-	}
-	headerRoot, err := header.HashTreeRoot()
-	require.NoError(t, err)
-
-	envelope := &ethpb.ExecutionPayloadEnvelope{
-		Slot:               slot,
-		BuilderIndex:       builderIdx,
-		BeaconBlockRoot:    headerRoot[:],
-		Payload:            payload,
-		BlobKzgCommitments: blobCommitments,
-		ExecutionRequests:  &enginev1.ExecutionRequests{},
-	}
-
-	if mutate != nil {
-		mutate(payload, bid, envelope)
-	}
-
-	genesisRoot := bytes.Repeat([]byte{0xAB}, 32)
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.ETH1AddressWithdrawalPrefixByte
-
-	eth1Data := &ethpb.Eth1Data{
-		DepositRoot:  bytes.Repeat([]byte{0x66}, 32),
-		DepositCount: 0,
-		BlockHash:    bytes.Repeat([]byte{0x77}, 32),
-	}
-
-	vals := []*ethpb.Validator{
-		{
-			PublicKey:             pk,
-			WithdrawalCredentials: withdrawalCreds,
-			EffectiveBalance:      cfg.MinActivationBalance + 1_000,
-		},
-	}
-	balances := []uint64{cfg.MinActivationBalance + 1_000}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-
-	executionPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	genesisTime := uint64(0)
-	slotSeconds := cfg.SecondsPerSlot * uint64(slot)
-	if payload.Timestamp > slotSeconds {
-		genesisTime = payload.Timestamp - slotSeconds
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisTime:           genesisTime,
-		GenesisValidatorsRoot: genesisRoot,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-		LatestBlockHeader:            header,
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		Eth1Data:                     eth1Data,
-		Validators:                   vals,
-		Balances:                     balances,
-		LatestBlockHash:              payload.ParentHash,
-		LatestExecutionPayloadBid:    bid,
-		BuilderPendingPayments:       payments,
-		ExecutionPayloadAvailability: executionPayloadAvailability,
-		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
-		PayloadExpectedWithdrawals:   payload.Withdrawals,
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-
-	expected := st.Copy()
-	ctx := context.Background()
-	require.NoError(t, processExecutionRequests(ctx, expected, envelope.ExecutionRequests))
-	require.NoError(t, queueBuilderPayment(ctx, expected))
-	require.NoError(t, expected.SetExecutionPayloadAvailability(slot, true))
-	var blockHashArr [32]byte
-	copy(blockHashArr[:], payload.BlockHash)
-	require.NoError(t, expected.SetLatestBlockHash(blockHashArr))
-	expectedRoot, err := expected.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	envelope.StateRoot = expectedRoot[:]
-
-	epoch := slots.ToEpoch(slot)
-	domain, err := signing.Domain(st.Fork(), epoch, cfg.DomainBeaconBuilder, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	signingRoot, err := signing.ComputeSigningRoot(envelope, domain)
-	require.NoError(t, err)
-	signature := sk.Sign(signingRoot[:]).Marshal()
-
-	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
-		Message:   envelope,
-		Signature: signature,
-	}
-	signed, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
-	require.NoError(t, err)
-
-	return payloadFixture{
-		state:       st,
-		signed:      signed,
-		signedProto: signedProto,
-		envelope:    envelope,
-		payload:     payload,
-		slot:        slot,
-	}
-}
-
-func TestProcessExecutionPayload_Success(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-	require.NoError(t, ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed))
-
-	latestHash, err := fixture.state.LatestBlockHash()
-	require.NoError(t, err)
-	var expectedHash [32]byte
-	copy(expectedHash[:], fixture.payload.BlockHash)
-	require.Equal(t, expectedHash, latestHash)
-
-	payment, err := fixture.state.BuilderPendingPayment(fixture.slot)
-	require.NoError(t, err)
-	require.NotNil(t, payment)
-	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayload_PrevRandaoMismatch(t *testing.T) {
-	fixture := buildPayloadFixture(t, func(_ *enginev1.ExecutionPayloadDeneb, bid *ethpb.ExecutionPayloadBid, _ *ethpb.ExecutionPayloadEnvelope) {
-		bid.PrevRandao = bytes.Repeat([]byte{0xFF}, 32)
-	})
-
-	err := ProcessExecutionPayload(t.Context(), fixture.state, fixture.signed)
-	require.ErrorContains(t, "prev randao", err)
-}
-
-func TestQueueBuilderPayment_ZeroAmountClearsSlot(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-
-	require.NoError(t, queueBuilderPayment(t.Context(), fixture.state))
-
-	payment, err := fixture.state.BuilderPendingPayment(fixture.slot)
-	require.NoError(t, err)
-	require.NotNil(t, payment)
-	require.Equal(t, primitives.Gwei(0), payment.Withdrawal.Amount)
-}
-
-func TestVerifyExecutionPayloadEnvelopeSignature_InvalidSig(t *testing.T) {
-	fixture := buildPayloadFixture(t, nil)
-
-	signedProto := &ethpb.SignedExecutionPayloadEnvelope{
-		Message:   fixture.signedProto.Message,
-		Signature: bytes.Repeat([]byte{0xFF}, 96),
-	}
-	badSigned, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signedProto)
-	require.NoError(t, err)
-
-	err = verifyExecutionPayloadEnvelopeSignature(fixture.state, badSigned)
-	require.ErrorContains(t, "invalid signature format", err)
-}

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

@@ -205,7 +205,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, 176, len(data))
+	assert.Equal(t, 175, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -419,8 +419,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x0a000000", v)
 			case "DOMAIN_APPLICATION_BUILDER":
 				assert.Equal(t, "0x00000001", v)
-			case "DOMAIN_BEACON_BUILDER":
-				assert.Equal(t, "0x1b000000", v)
 			case "DOMAIN_BLOB_SIDECAR":
 				assert.Equal(t, "0x00000000", v)
 			case "TRANSITION_TOTAL_DIFFICULTY":

beacon-chain/state/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "error.go",
         "interfaces.go",
-        "interfaces_gloas.go",
         "prometheus.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/state",

beacon-chain/state/interfaces.go

@@ -66,7 +66,6 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyDeposits
 	ReadOnlyConsolidations
 	ReadOnlyProposerLookahead
-	ReadOnlyGloasFields
 	ToProtoUnsafe() any
 	ToProto() any
 	GenesisTime() time.Time
@@ -103,7 +102,6 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyDeposits
 	WriteOnlyProposerLookahead
 	SetGenesisTime(val time.Time) error
-	WriteOnlyGloasFields
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val primitives.Slot) error
 	SetFork(val *ethpb.Fork) error

beacon-chain/state/interfaces_gloas.go

@@ -1,26 +0,0 @@
-package state
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-type WriteOnlyGloasFields interface {
-	SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error
-	SetBuilderPendingPayment(index primitives.Slot, payment *ethpb.BuilderPendingPayment) error
-	SetLatestBlockHash(hash [32]byte) error
-	SetExecutionPayloadAvailability(index primitives.Slot, available bool) error
-	SetBuilderPendingPayments(payments []*ethpb.BuilderPendingPayment) error
-	AppendBuilderPendingWithdrawal(withdrawal *ethpb.BuilderPendingWithdrawal) error
-}
-
-type ReadOnlyGloasFields interface {
-	LatestBlockHash() ([32]byte, error)
-	BuilderPendingPayment(slot primitives.Slot) (*ethpb.BuilderPendingPayment, error)
-	BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error)
-	BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error)
-	LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error)
-	PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error)
-}

beacon-chain/state/state-native/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "getters_deposits.go",
         "getters_eth1.go",
         "getters_exit.go",
-        "getters_gloas.go",
         "getters_misc.go",
         "getters_participation.go",
         "getters_payload_header.go",
@@ -37,7 +36,6 @@ go_library(
         "setters_deposit_requests.go",
         "setters_deposits.go",
         "setters_eth1.go",
-        "setters_gloas.go",
         "setters_misc.go",
         "setters_participation.go",
         "setters_payload_header.go",
@@ -99,7 +97,6 @@ go_test(
         "getters_deposit_requests_test.go",
         "getters_deposits_test.go",
         "getters_exit_test.go",
-        "getters_gloas_test.go",
         "getters_participation_test.go",
         "getters_setters_lookahead_test.go",
         "getters_test.go",
@@ -117,7 +114,6 @@ go_test(
         "setters_deposit_requests_test.go",
         "setters_deposits_test.go",
         "setters_eth1_test.go",
-        "setters_gloas_test.go",
         "setters_misc_test.go",
         "setters_participation_test.go",
         "setters_payload_header_test.go",

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

@@ -1,81 +0,0 @@
-package state_native
-
-import (
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// LatestBlockHash returns the hash of the latest execution block.
-func (b *BeaconState) LatestBlockHash() ([32]byte, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestBlockHash == nil {
-		return [32]byte{}, nil
-	}
-
-	return [32]byte(b.latestBlockHash), nil
-}
-
-// BuilderPendingPayment returns a specific builder pending payment for the given slot.
-func (b *BeaconState) BuilderPendingPayment(slot primitives.Slot) (*ethpb.BuilderPendingPayment, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-
-	return ethpb.CopyBuilderPendingPayment(b.builderPendingPayments[paymentIndex]), nil
-}
-
-// BuilderPendingPayments returns the builder pending payments.
-func (b *BeaconState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.builderPendingPayments == nil {
-		return make([]*ethpb.BuilderPendingPayment, 0), nil
-	}
-
-	return ethpb.CopyBuilderPendingPaymentSlice(b.builderPendingPayments), nil
-}
-
-// BuilderPendingWithdrawals returns the builder pending withdrawals.
-func (b *BeaconState) BuilderPendingWithdrawals() ([]*ethpb.BuilderPendingWithdrawal, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.builderPendingWithdrawals == nil {
-		return make([]*ethpb.BuilderPendingWithdrawal, 0), nil
-	}
-
-	return ethpb.CopyBuilderPendingWithdrawalSlice(b.builderPendingWithdrawals), nil
-}
-
-// LatestExecutionPayloadBid returns the cached latest execution payload bid for Gloas.
-func (b *BeaconState) LatestExecutionPayloadBid() (interfaces.ROExecutionPayloadBid, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.latestExecutionPayloadBid == nil {
-		return nil, nil
-	}
-
-	return blocks.WrappedROExecutionPayloadBid(b.latestExecutionPayloadBid.Copy())
-}
-
-// PayloadExpectedWithdrawals returns the expected withdrawals for the current payload.
-func (b *BeaconState) PayloadExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	if b.payloadExpectedWithdrawals == nil {
-		return make([]*enginev1.Withdrawal, 0), nil
-	}
-
-	return b.payloadExpectedWithdrawalsVal(), nil
-}

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

@@ -1,67 +0,0 @@
-package state_native_test
-
-import (
-	"testing"
-
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestLatestBlockHash(t *testing.T) {
-	t.Run("nil hash returns zero", func(t *testing.T) {
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{})
-		require.NoError(t, err)
-
-		hash, err := s.LatestBlockHash()
-		require.NoError(t, err)
-		assert.Equal(t, [32]byte{}, hash)
-	})
-
-	t.Run("returns value", func(t *testing.T) {
-		var want [32]byte
-		copy(want[:], []byte("latest-block-hash"))
-
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			LatestBlockHash: want[:],
-		})
-		require.NoError(t, err)
-
-		hash, err := s.LatestBlockHash()
-		require.NoError(t, err)
-		assert.Equal(t, want, hash)
-	})
-}
-
-func TestBuilderPendingPayment(t *testing.T) {
-	t.Run("returns payment for slot", func(t *testing.T) {
-		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-		slot := primitives.Slot(7)
-		paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-		payments := make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2)
-		payment := &ethpb.BuilderPendingPayment{
-			Weight: 11,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20},
-				Amount:       99,
-				BuilderIndex: 3,
-			},
-		}
-		payments[paymentIndex] = payment
-
-		s, err := state_native.InitializeFromProtoGloas(&ethpb.BeaconStateGloas{
-			BuilderPendingPayments: payments,
-		})
-		require.NoError(t, err)
-
-		got, err := s.BuilderPendingPayment(slot)
-		require.NoError(t, err)
-		require.DeepEqual(t, payment, got)
-
-		got.Withdrawal.FeeRecipient[0] = 9
-		require.Equal(t, byte(1), payment.Withdrawal.FeeRecipient[0])
-	})
-}

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

@@ -1,101 +0,0 @@
-package state_native
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-func (b *BeaconState) SetExecutionPayloadBid(h interfaces.ROExecutionPayloadBid) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	parentBlockHash := h.ParentBlockHash()
-	parentBlockRoot := h.ParentBlockRoot()
-	blockHash := h.BlockHash()
-	randao := h.PrevRandao()
-	blobKzgCommitmentsRoot := h.BlobKzgCommitmentsRoot()
-	feeRecipient := h.FeeRecipient()
-	b.latestExecutionPayloadBid = &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        parentBlockHash[:],
-		ParentBlockRoot:        parentBlockRoot[:],
-		BlockHash:              blockHash[:],
-		PrevRandao:             randao[:],
-		GasLimit:               h.GasLimit(),
-		BuilderIndex:           h.BuilderIndex(),
-		Slot:                   h.Slot(),
-		Value:                  h.Value(),
-		ExecutionPayment:       h.ExecutionPayment(),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot[:],
-		FeeRecipient:           feeRecipient[:],
-	}
-	b.markFieldAsDirty(types.LatestExecutionPayloadBid)
-
-	return nil
-}
-
-// SetBuilderPendingPayment sets a builder pending payment for the specified slot.
-func (b *BeaconState) SetBuilderPendingPayment(slot primitives.Slot, payment *ethpb.BuilderPendingPayment) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-
-	b.builderPendingPayments[paymentIndex] = ethpb.CopyBuilderPendingPayment(payment)
-
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}
-
-// SetLatestBlockHash sets the latest execution block hash.
-func (b *BeaconState) SetLatestBlockHash(hash [32]byte) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.latestBlockHash = hash[:]
-	b.markFieldAsDirty(types.LatestBlockHash)
-	return nil
-}
-
-// SetExecutionPayloadAvailability sets the execution payload availability bit for a specific slot.
-func (b *BeaconState) SetExecutionPayloadAvailability(index primitives.Slot, available bool) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	bitIndex := index % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := bitIndex / 8
-	bitPosition := bitIndex % 8
-
-	// Set or clear the bit
-	if available {
-		b.executionPayloadAvailability[byteIndex] |= 1 << bitPosition
-	} else {
-		b.executionPayloadAvailability[byteIndex] &^= 1 << bitPosition
-	}
-
-	b.markFieldAsDirty(types.ExecutionPayloadAvailability)
-	return nil
-}
-
-// SetBuilderPendingPayments sets the entire builder pending payments array.
-func (b *BeaconState) SetBuilderPendingPayments(payments []*ethpb.BuilderPendingPayment) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.builderPendingPayments = ethpb.CopyBuilderPendingPaymentSlice(payments)
-	b.markFieldAsDirty(types.BuilderPendingPayments)
-	return nil
-}
-
-// AppendBuilderPendingWithdrawal appends a builder pending withdrawal to the list.
-func (b *BeaconState) AppendBuilderPendingWithdrawal(withdrawal *ethpb.BuilderPendingWithdrawal) error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.builderPendingWithdrawals = append(b.builderPendingWithdrawals, ethpb.CopyBuilderPendingWithdrawal(withdrawal))
-	b.markFieldAsDirty(types.BuilderPendingWithdrawals)
-	return nil
-}

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

@@ -1,121 +0,0 @@
-package state_native
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestSetBuilderPendingPayment(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	slot := primitives.Slot(7)
-	paymentIndex := slotsPerEpoch + (slot % slotsPerEpoch)
-	payment := &ethpb.BuilderPendingPayment{
-		Weight: 11,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: []byte{1, 2, 3, 4, 5},
-			Amount:       99,
-			BuilderIndex: 3,
-		},
-	}
-
-	state := &BeaconState{
-		builderPendingPayments: make([]*ethpb.BuilderPendingPayment, slotsPerEpoch*2),
-		dirtyFields:            make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetBuilderPendingPayment(slot, payment))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingPayments])
-	require.DeepEqual(t, payment, state.builderPendingPayments[paymentIndex])
-
-	state.builderPendingPayments[paymentIndex].Withdrawal.FeeRecipient[0] = 9
-	require.Equal(t, byte(1), payment.Withdrawal.FeeRecipient[0])
-}
-
-func TestSetLatestBlockHash(t *testing.T) {
-	var hash [32]byte
-	copy(hash[:], []byte("latest-block-hash"))
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetLatestBlockHash(hash))
-	require.Equal(t, true, state.dirtyFields[types.LatestBlockHash])
-	require.DeepEqual(t, hash[:], state.latestBlockHash)
-}
-
-func TestSetExecutionPayloadAvailability(t *testing.T) {
-	state := &BeaconState{
-		executionPayloadAvailability: make([]byte, params.BeaconConfig().SlotsPerHistoricalRoot/8),
-		dirtyFields:                  make(map[types.FieldIndex]bool),
-	}
-
-	slot := primitives.Slot(10)
-	bitIndex := slot % params.BeaconConfig().SlotsPerHistoricalRoot
-	byteIndex := bitIndex / 8
-	bitPosition := bitIndex % 8
-
-	require.NoError(t, state.SetExecutionPayloadAvailability(slot, true))
-	require.Equal(t, true, state.dirtyFields[types.ExecutionPayloadAvailability])
-	require.Equal(t, byte(1<<bitPosition), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
-
-	require.NoError(t, state.SetExecutionPayloadAvailability(slot, false))
-	require.Equal(t, byte(0), state.executionPayloadAvailability[byteIndex]&(1<<bitPosition))
-}
-
-func TestSetBuilderPendingPayments(t *testing.T) {
-	payments := []*ethpb.BuilderPendingPayment{
-		{
-			Weight: 1,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{1, 1, 1},
-				Amount:       5,
-				BuilderIndex: 2,
-			},
-		},
-		{
-			Weight: 2,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{2, 2, 2},
-				Amount:       6,
-				BuilderIndex: 4,
-			},
-		},
-	}
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.SetBuilderPendingPayments(payments))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingPayments])
-	require.DeepEqual(t, payments, state.builderPendingPayments)
-
-	state.builderPendingPayments[0].Weight = 99
-	require.Equal(t, primitives.Gwei(1), payments[0].Weight)
-}
-
-func TestAppendBuilderPendingWithdrawal(t *testing.T) {
-	withdrawal := &ethpb.BuilderPendingWithdrawal{
-		FeeRecipient: []byte{9, 8, 7},
-		Amount:       77,
-		BuilderIndex: 12,
-	}
-
-	state := &BeaconState{
-		dirtyFields: make(map[types.FieldIndex]bool),
-	}
-
-	require.NoError(t, state.AppendBuilderPendingWithdrawal(withdrawal))
-	require.Equal(t, true, state.dirtyFields[types.BuilderPendingWithdrawals])
-	require.Equal(t, 1, len(state.builderPendingWithdrawals))
-	require.DeepEqual(t, withdrawal, state.builderPendingWithdrawals[0])
-
-	state.builderPendingWithdrawals[0].FeeRecipient[0] = 1
-	require.Equal(t, byte(9), withdrawal.FeeRecipient[0])
-}

changelog/potuz_update_spectests_2.md

@@ -0,0 +1,2 @@
+### Added
+- Update spectests to v1.7.0-alpha-1.

changelog/t_gloas-process-execution-payload.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add process execution payload for gloas

config/features/config.go

@@ -81,7 +81,6 @@ type Flags struct {
 	SaveInvalidBlob  bool // SaveInvalidBlob saves invalid blob to temp.
 
 	EnableDiscoveryReboot bool // EnableDiscoveryReboot allows the node to have its local listener to be rebooted in the event of discovery issues.
-	LowValcountSweep      bool // LowValcountSweep bounds withdrawal sweep by validator count.
 
 	// KeystoreImportDebounceInterval specifies the time duration the validator waits to reload new keys if they have
 	// changed on disk. This feature is for advanced use cases only.
@@ -290,11 +289,6 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(ignoreUnviableAttestations)
 		cfg.IgnoreUnviableAttestations = true
 	}
-	if ctx.Bool(lowValcountSweep.Name) {
-		logEnabled(lowValcountSweep)
-		cfg.LowValcountSweep = true
-	}
-
 	if ctx.IsSet(EnableStateDiff.Name) {
 		logEnabled(EnableStateDiff)
 		cfg.EnableStateDiff = true

config/features/flags.go

@@ -216,13 +216,6 @@ var (
 		Name:  "ignore-unviable-attestations",
 		Usage: "Ignores attestations whose target state is not viable with respect to the current head (avoid expensive state replay from lagging attesters).",
 	}
-	// lowValcountSweep bounds withdrawal sweep by validator count.
-	lowValcountSweep = &cli.BoolFlag{
-		Name:   "low-valcount-sweep",
-		Usage:  "Uses validator count bound for withdrawal sweep when validator count is less than MaxValidatorsPerWithdrawalsSweep.",
-		Value:  false,
-		Hidden: true,
-	}
 )
 
 // devModeFlags holds list of flags that are set when development mode is on.
@@ -285,7 +278,6 @@ var BeaconChainFlags = combinedFlags([]cli.Flag{
 	enableExperimentalAttestationPool,
 	forceHeadFlag,
 	blacklistRoots,
-	lowValcountSweep,
 }, deprecatedBeaconFlags, deprecatedFlags, upcomingDeprecation)
 
 func combinedFlags(flags ...[]cli.Flag) []cli.Flag {

config/params/config.go

@@ -139,7 +139,6 @@ type BeaconChainConfig struct {
 	DomainApplicationMask             [4]byte `yaml:"DOMAIN_APPLICATION_MASK" spec:"true"`               // DomainApplicationMask defines the BLS signature domain for application mask.
 	DomainApplicationBuilder          [4]byte `yaml:"DOMAIN_APPLICATION_BUILDER" spec:"true"`            // DomainApplicationBuilder defines the BLS signature domain for application builder.
 	DomainBLSToExecutionChange        [4]byte `yaml:"DOMAIN_BLS_TO_EXECUTION_CHANGE" spec:"true"`        // DomainBLSToExecutionChange defines the BLS signature domain to change withdrawal addresses to ETH1 prefix
-	DomainBeaconBuilder               [4]byte `yaml:"DOMAIN_BEACON_BUILDER" spec:"true"`                 // DomainBeaconBuilder defines the BLS signature domain for beacon block builder.
 
 	// Prysm constants.
 	GenesisValidatorsRoot          [32]byte        // GenesisValidatorsRoot is the root hash of the genesis validators.

config/params/mainnet_config.go

@@ -182,7 +182,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainApplicationMask:             bytesutil.Uint32ToBytes4(0x00000001),
 	DomainApplicationBuilder:          bytesutil.Uint32ToBytes4(0x00000001),
 	DomainBLSToExecutionChange:        bytesutil.Uint32ToBytes4(0x0A000000),
-	DomainBeaconBuilder:               bytesutil.Uint32ToBytes4(0x1B000000),
 
 	// Prysm constants.
 	GenesisValidatorsRoot:          [32]byte{75, 54, 61, 185, 78, 40, 97, 32, 215, 110, 185, 5, 52, 15, 221, 78, 84, 191, 233, 240, 107, 243, 63, 246, 207, 90, 210, 127, 81, 27, 254, 149},

consensus-types/blocks/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "execution.go",
-        "execution_payload_envelope.go",
         "factory.go",
         "get_payload.go",
         "getters.go",
@@ -15,13 +14,11 @@ go_library(
         "roblock.go",
         "rodatacolumn.go",
         "setters.go",
-        "signed_execution_bid.go",
         "types.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/consensus-types/blocks",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/state/stateutil:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -37,7 +34,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client: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_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_prysmaticlabs_gohashtree//:go_default_library",
@@ -48,7 +44,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "execution_payload_envelope_test.go",
         "execution_test.go",
         "factory_test.go",
         "getters_test.go",
@@ -62,7 +57,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/core/signing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",

consensus-types/blocks/execution_payload_envelope.go

@@ -1,156 +0,0 @@
-package blocks
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/encoding/ssz"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/ethereum/go-ethereum/common"
-	"google.golang.org/protobuf/proto"
-)
-
-type signedExecutionPayloadEnvelope struct {
-	s *ethpb.SignedExecutionPayloadEnvelope
-}
-
-type executionPayloadEnvelope struct {
-	p *ethpb.ExecutionPayloadEnvelope
-}
-
-// WrappedROSignedExecutionPayloadEnvelope wraps a signed execution payload envelope proto in a read-only interface.
-func WrappedROSignedExecutionPayloadEnvelope(s *ethpb.SignedExecutionPayloadEnvelope) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
-	w := signedExecutionPayloadEnvelope{s: s}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// WrappedROExecutionPayloadEnvelope wraps an execution payload envelope proto in a read-only interface.
-func WrappedROExecutionPayloadEnvelope(p *ethpb.ExecutionPayloadEnvelope) (interfaces.ROExecutionPayloadEnvelope, error) {
-	w := &executionPayloadEnvelope{p: p}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// Envelope returns the execution payload envelope as a read-only interface.
-func (s signedExecutionPayloadEnvelope) Envelope() (interfaces.ROExecutionPayloadEnvelope, error) {
-	return WrappedROExecutionPayloadEnvelope(s.s.Message)
-}
-
-// Signature returns the BLS signature as a 96-byte array.
-func (s signedExecutionPayloadEnvelope) Signature() [field_params.BLSSignatureLength]byte {
-	return [field_params.BLSSignatureLength]byte(s.s.Signature)
-}
-
-// IsNil reports whether the signed envelope or its contents are invalid.
-func (s signedExecutionPayloadEnvelope) IsNil() bool {
-	if s.s == nil {
-		return true
-	}
-	if len(s.s.Signature) != field_params.BLSSignatureLength {
-		return true
-	}
-	w := executionPayloadEnvelope{p: s.s.Message}
-	return w.IsNil()
-}
-
-// SigningRoot computes the signing root for the signed envelope with the provided domain.
-func (s signedExecutionPayloadEnvelope) SigningRoot(domain []byte) (root [32]byte, err error) {
-	return signing.ComputeSigningRoot(s.s.Message, domain)
-}
-
-// Proto returns the underlying protobuf message.
-func (s signedExecutionPayloadEnvelope) Proto() proto.Message {
-	return s.s
-}
-
-// IsNil reports whether the envelope or its required fields are invalid.
-func (p *executionPayloadEnvelope) IsNil() bool {
-	if p.p == nil {
-		return true
-	}
-	if p.p.Payload == nil {
-		return true
-	}
-	if len(p.p.BeaconBlockRoot) != field_params.RootLength {
-		return true
-	}
-	if p.p.BlobKzgCommitments == nil {
-		return true
-	}
-	return false
-}
-
-// IsBlinded reports whether the envelope contains a blinded payload.
-func (p *executionPayloadEnvelope) IsBlinded() bool {
-	return !p.IsNil() && p.p.Payload == nil
-}
-
-// Execution returns the execution payload as a read-only interface.
-func (p *executionPayloadEnvelope) Execution() (interfaces.ExecutionData, error) {
-	if p.IsBlinded() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return WrappedExecutionPayloadDeneb(p.p.Payload)
-}
-
-// ExecutionRequests returns the execution requests attached to the envelope.
-func (p *executionPayloadEnvelope) ExecutionRequests() *enginev1.ExecutionRequests {
-	return p.p.ExecutionRequests
-}
-
-// BuilderIndex returns the proposer/builder index for the envelope.
-func (p *executionPayloadEnvelope) BuilderIndex() primitives.BuilderIndex {
-	return p.p.BuilderIndex
-}
-
-// BeaconBlockRoot returns the beacon block root referenced by the envelope.
-func (p *executionPayloadEnvelope) BeaconBlockRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.BeaconBlockRoot)
-}
-
-// BlobKzgCommitments returns a copy of the envelope's KZG commitments.
-func (p *executionPayloadEnvelope) BlobKzgCommitments() [][]byte {
-	commitments := make([][]byte, len(p.p.BlobKzgCommitments))
-	for i, commit := range p.p.BlobKzgCommitments {
-		commitments[i] = make([]byte, len(commit))
-		copy(commitments[i], commit)
-	}
-	return commitments
-}
-
-// VersionedHashes returns versioned hashes derived from the KZG commitments.
-func (p *executionPayloadEnvelope) VersionedHashes() []common.Hash {
-	commitments := p.p.BlobKzgCommitments
-	versionedHashes := make([]common.Hash, len(commitments))
-	for i, commitment := range commitments {
-		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
-	}
-	return versionedHashes
-}
-
-// BlobKzgCommitmentsRoot returns the SSZ root of the envelope's KZG commitments.
-func (p *executionPayloadEnvelope) BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error) {
-	if p.IsNil() || p.p.BlobKzgCommitments == nil {
-		return [field_params.RootLength]byte{}, consensus_types.ErrNilObjectWrapped
-	}
-
-	return ssz.KzgCommitmentsRoot(p.p.BlobKzgCommitments)
-}
-
-// Slot returns the slot of the envelope.
-func (p *executionPayloadEnvelope) Slot() primitives.Slot {
-	return p.p.Slot
-}
-
-// StateRoot returns the state root carried by the envelope.
-func (p *executionPayloadEnvelope) StateRoot() [field_params.RootLength]byte {
-	return [field_params.RootLength]byte(p.p.StateRoot)
-}

consensus-types/blocks/execution_payload_envelope_test.go

@@ -1,115 +0,0 @@
-package blocks_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func validExecutionPayloadEnvelope() *ethpb.ExecutionPayloadEnvelope {
-	payload := &enginev1.ExecutionPayloadDeneb{
-		ParentHash:    bytes.Repeat([]byte{0x01}, 32),
-		FeeRecipient:  bytes.Repeat([]byte{0x02}, 20),
-		StateRoot:     bytes.Repeat([]byte{0x03}, 32),
-		ReceiptsRoot:  bytes.Repeat([]byte{0x04}, 32),
-		LogsBloom:     bytes.Repeat([]byte{0x05}, 256),
-		PrevRandao:    bytes.Repeat([]byte{0x06}, 32),
-		BlockNumber:   1,
-		GasLimit:      2,
-		GasUsed:       3,
-		Timestamp:     4,
-		BaseFeePerGas: bytes.Repeat([]byte{0x07}, 32),
-		BlockHash:     bytes.Repeat([]byte{0x08}, 32),
-		Transactions:  [][]byte{},
-		Withdrawals:   []*enginev1.Withdrawal{},
-		BlobGasUsed:   0,
-		ExcessBlobGas: 0,
-	}
-
-	return &ethpb.ExecutionPayloadEnvelope{
-		Payload:            payload,
-		ExecutionRequests:  &enginev1.ExecutionRequests{},
-		BuilderIndex:       10,
-		BeaconBlockRoot:    bytes.Repeat([]byte{0xAA}, 32),
-		Slot:               9,
-		BlobKzgCommitments: [][]byte{bytes.Repeat([]byte{0x0C}, 48)},
-		StateRoot:          bytes.Repeat([]byte{0xBB}, 32),
-	}
-}
-
-func TestWrappedROExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error on invalid beacon root length", func(t *testing.T) {
-		invalid := validExecutionPayloadEnvelope()
-		invalid.BeaconBlockRoot = []byte{0x01}
-		_, err := blocks.WrappedROExecutionPayloadEnvelope(invalid)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and exposes fields", func(t *testing.T) {
-		env := validExecutionPayloadEnvelope()
-		wrapped, err := blocks.WrappedROExecutionPayloadEnvelope(env)
-		require.NoError(t, err)
-
-		require.Equal(t, primitives.BuilderIndex(10), wrapped.BuilderIndex())
-		require.Equal(t, primitives.Slot(9), wrapped.Slot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), wrapped.BeaconBlockRoot())
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xBB}, 32)), wrapped.StateRoot())
-
-		commitments := wrapped.BlobKzgCommitments()
-		assert.DeepEqual(t, env.BlobKzgCommitments, commitments)
-
-		versioned := wrapped.VersionedHashes()
-		require.Equal(t, 1, len(versioned))
-
-		reqs := wrapped.ExecutionRequests()
-		require.NotNil(t, reqs)
-
-		exec, err := wrapped.Execution()
-		require.NoError(t, err)
-		assert.DeepEqual(t, env.Payload.ParentHash, exec.ParentHash())
-	})
-}
-
-func TestWrappedROSignedExecutionPayloadEnvelope(t *testing.T) {
-	t.Run("returns error for invalid signature length", func(t *testing.T) {
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: bytes.Repeat([]byte{0xAA}, 95),
-		}
-		_, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.Equal(t, consensus_types.ErrNilObjectWrapped, err)
-	})
-
-	t.Run("wraps and provides envelope/signing data", func(t *testing.T) {
-		sig := bytes.Repeat([]byte{0xAB}, 96)
-		signed := &ethpb.SignedExecutionPayloadEnvelope{
-			Message:   validExecutionPayloadEnvelope(),
-			Signature: sig,
-		}
-
-		wrapped, err := blocks.WrappedROSignedExecutionPayloadEnvelope(signed)
-		require.NoError(t, err)
-
-		gotSig := wrapped.Signature()
-		assert.DeepEqual(t, [96]byte(sig), gotSig)
-
-		env, err := wrapped.Envelope()
-		require.NoError(t, err)
-		assert.DeepEqual(t, [32]byte(bytes.Repeat([]byte{0xAA}, 32)), env.BeaconBlockRoot())
-
-		domain := bytes.Repeat([]byte{0xCC}, 32)
-		wantRoot, err := signing.ComputeSigningRoot(signed.Message, domain)
-		require.NoError(t, err)
-		gotRoot, err := wrapped.SigningRoot(domain)
-		require.NoError(t, err)
-		require.Equal(t, wantRoot, gotRoot)
-	})
-}

consensus-types/blocks/signed_execution_bid.go

@@ -1,140 +0,0 @@
-package blocks
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-// signedExecutionPayloadBid wraps the protobuf signed execution payload bid
-// and implements the ROSignedExecutionPayloadBid interface.
-type signedExecutionPayloadBid struct {
-	bid *ethpb.SignedExecutionPayloadBid
-}
-
-// executionPayloadBidGloas wraps the protobuf execution payload bid for Gloas fork
-// and implements the ROExecutionPayloadBidGloas interface.
-type executionPayloadBidGloas struct {
-	payload *ethpb.ExecutionPayloadBid
-}
-
-// IsNil checks if the signed execution payload bid is nil or invalid.
-func (s signedExecutionPayloadBid) IsNil() bool {
-	if s.bid == nil {
-		return true
-	}
-
-	if _, err := WrappedROExecutionPayloadBid(s.bid.Message); err != nil {
-		return true
-	}
-
-	return len(s.bid.Signature) != 96
-}
-
-// IsNil checks if the execution payload bid is nil or has invalid fields.
-func (h executionPayloadBidGloas) IsNil() bool {
-	if h.payload == nil {
-		return true
-	}
-
-	if len(h.payload.ParentBlockHash) != 32 ||
-		len(h.payload.ParentBlockRoot) != 32 ||
-		len(h.payload.BlockHash) != 32 ||
-		len(h.payload.BlobKzgCommitmentsRoot) != 32 {
-		return true
-	}
-
-	return false
-}
-
-// WrappedROSignedExecutionPayloadBid creates a new read-only signed execution payload bid
-// wrapper from the given protobuf message.
-func WrappedROSignedExecutionPayloadBid(pb *ethpb.SignedExecutionPayloadBid) (interfaces.ROSignedExecutionPayloadBid, error) {
-	wrapper := signedExecutionPayloadBid{bid: pb}
-	if wrapper.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return wrapper, nil
-}
-
-// WrappedROExecutionPayloadBid creates a new read-only execution payload bid
-// wrapper for the Gloas fork from the given protobuf message.
-func WrappedROExecutionPayloadBid(pb *ethpb.ExecutionPayloadBid) (interfaces.ROExecutionPayloadBid, error) {
-	wrapper := executionPayloadBidGloas{payload: pb}
-	if wrapper.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return wrapper, nil
-}
-
-// Bid returns the execution payload bid as a read-only interface.
-func (s signedExecutionPayloadBid) Bid() (interfaces.ROExecutionPayloadBid, error) {
-	return WrappedROExecutionPayloadBid(s.bid.Message)
-}
-
-// SigningRoot computes the signing root for the execution payload bid with the given domain.
-func (s signedExecutionPayloadBid) SigningRoot(domain []byte) ([32]byte, error) {
-	return signing.ComputeSigningRoot(s.bid.Message, domain)
-}
-
-// Signature returns the BLS signature as a 96-byte array.
-func (s signedExecutionPayloadBid) Signature() [96]byte {
-	return [96]byte(s.bid.Signature)
-}
-
-// ParentBlockHash returns the hash of the parent execution block.
-func (h executionPayloadBidGloas) ParentBlockHash() [32]byte {
-	return [32]byte(h.payload.ParentBlockHash)
-}
-
-// ParentBlockRoot returns the beacon block root of the parent block.
-func (h executionPayloadBidGloas) ParentBlockRoot() [32]byte {
-	return [32]byte(h.payload.ParentBlockRoot)
-}
-
-// PrevRandao returns the previous randao value for the execution block.
-func (h executionPayloadBidGloas) PrevRandao() [32]byte {
-	return [32]byte(h.payload.PrevRandao)
-}
-
-// BlockHash returns the hash of the execution block.
-func (h executionPayloadBidGloas) BlockHash() [32]byte {
-	return [32]byte(h.payload.BlockHash)
-}
-
-// GasLimit returns the gas limit for the execution block.
-func (h executionPayloadBidGloas) GasLimit() uint64 {
-	return h.payload.GasLimit
-}
-
-// BuilderIndex returns the builder index of the builder who created this bid.
-func (h executionPayloadBidGloas) BuilderIndex() primitives.BuilderIndex {
-	return h.payload.BuilderIndex
-}
-
-// Slot returns the beacon chain slot for which this bid was created.
-func (h executionPayloadBidGloas) Slot() primitives.Slot {
-	return h.payload.Slot
-}
-
-// Value returns the payment value offered by the builder in Gwei.
-func (h executionPayloadBidGloas) Value() primitives.Gwei {
-	return primitives.Gwei(h.payload.Value)
-}
-
-// ExecutionPayment returns the execution payment offered by the builder.
-func (h executionPayloadBidGloas) ExecutionPayment() primitives.Gwei {
-	return primitives.Gwei(h.payload.ExecutionPayment)
-}
-
-// BlobKzgCommitmentsRoot returns the root of the KZG commitments for blobs.
-func (h executionPayloadBidGloas) BlobKzgCommitmentsRoot() [32]byte {
-	return [32]byte(h.payload.BlobKzgCommitmentsRoot)
-}
-
-// FeeRecipient returns the execution address that will receive the builder payment.
-func (h executionPayloadBidGloas) FeeRecipient() [20]byte {
-	return [20]byte(h.payload.FeeRecipient)
-}

consensus-types/interfaces/BUILD.bazel

@@ -5,9 +5,7 @@ go_library(
     srcs = [
         "beacon_block.go",
         "error.go",
-        "execution_payload_envelope.go",
         "light_client.go",
-        "signed_execution_payload_bid.go",
         "utils.go",
         "validator.go",
     ],
@@ -20,7 +18,6 @@ go_library(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/validator-client: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_prysmaticlabs_fastssz//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

consensus-types/interfaces/execution_payload_envelope.go

@@ -1,31 +0,0 @@
-package interfaces
-
-import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	"github.com/ethereum/go-ethereum/common"
-	"google.golang.org/protobuf/proto"
-)
-
-type ROSignedExecutionPayloadEnvelope interface {
-	Envelope() (ROExecutionPayloadEnvelope, error)
-	Signature() [field_params.BLSSignatureLength]byte
-	SigningRoot([]byte) ([32]byte, error)
-	IsNil() bool
-	Proto() proto.Message
-}
-
-type ROExecutionPayloadEnvelope interface {
-	Execution() (ExecutionData, error)
-	ExecutionRequests() *enginev1.ExecutionRequests
-	BuilderIndex() primitives.BuilderIndex
-	BeaconBlockRoot() [field_params.RootLength]byte
-	BlobKzgCommitments() [][]byte
-	BlobKzgCommitmentsRoot() ([field_params.RootLength]byte, error)
-	VersionedHashes() []common.Hash
-	Slot() primitives.Slot
-	StateRoot() [field_params.RootLength]byte
-	IsBlinded() bool
-	IsNil() bool
-}

consensus-types/interfaces/signed_execution_payload_bid.go

@@ -1,28 +0,0 @@
-package interfaces
-
-import (
-	field_params "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-type ROSignedExecutionPayloadBid interface {
-	Bid() (ROExecutionPayloadBid, error)
-	Signature() [field_params.BLSSignatureLength]byte
-	SigningRoot([]byte) ([32]byte, error)
-	IsNil() bool
-}
-
-type ROExecutionPayloadBid interface {
-	ParentBlockHash() [32]byte
-	ParentBlockRoot() [32]byte
-	PrevRandao() [32]byte
-	BlockHash() [32]byte
-	GasLimit() uint64
-	BuilderIndex() primitives.BuilderIndex
-	Slot() primitives.Slot
-	Value() primitives.Gwei
-	ExecutionPayment() primitives.Gwei
-	BlobKzgCommitmentsRoot() [32]byte
-	FeeRecipient() [20]byte
-	IsNil() bool
-}

encoding/ssz/htrutils.go

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/crypto/hash/htr"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -142,24 +141,3 @@ func withdrawalRoot(w *enginev1.Withdrawal) ([32]byte, error) {
 	}
 	return w.HashTreeRoot()
 }
-
-// KzgCommitmentsRoot computes the HTR for a list of KZG commitments
-func KzgCommitmentsRoot(commitments [][]byte) ([32]byte, error) {
-	roots := make([][32]byte, len(commitments))
-	for i, commitment := range commitments {
-		chunks, err := PackByChunk([][]byte{commitment})
-		if err != nil {
-			return [32]byte{}, err
-		}
-		roots[i] = htr.VectorizedSha256(chunks)[0]
-	}
-
-	commitmentsRoot, err := BitwiseMerkleize(roots, uint64(len(roots)), fieldparams.MaxBlobCommitmentsPerBlock)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not compute merkleization")
-	}
-
-	length := make([]byte, 32)
-	binary.LittleEndian.PutUint64(length[:8], uint64(len(roots)))
-	return MixInLength(commitmentsRoot, length), nil
-}

proto/prysm/v1alpha1/cloners.go

@@ -189,54 +189,3 @@ func copyBeaconBlockBodyGloas(body *BeaconBlockBodyGloas) *BeaconBlockBodyGloas
 
 	return copied
 }
-
-// CopyBuilderPendingPaymentSlice creates a deep copy of a builder pending payment slice.
-func CopyBuilderPendingPaymentSlice(original []*BuilderPendingPayment) []*BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	copied := make([]*BuilderPendingPayment, len(original))
-	for i, payment := range original {
-		copied[i] = CopyBuilderPendingPayment(payment)
-	}
-	return copied
-}
-
-// CopyBuilderPendingPayment creates a deep copy of a builder pending payment.
-func CopyBuilderPendingPayment(original *BuilderPendingPayment) *BuilderPendingPayment {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingPayment{
-		Weight:     original.Weight,
-		Withdrawal: CopyBuilderPendingWithdrawal(original.Withdrawal),
-	}
-}
-
-// CopyBuilderPendingWithdrawalSlice creates a deep copy of a builder pending withdrawal slice.
-func CopyBuilderPendingWithdrawalSlice(original []*BuilderPendingWithdrawal) []*BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	copied := make([]*BuilderPendingWithdrawal, len(original))
-	for i, withdrawal := range original {
-		copied[i] = CopyBuilderPendingWithdrawal(withdrawal)
-	}
-	return copied
-}
-
-// CopyBuilderPendingWithdrawal creates a deep copy of a builder pending withdrawal.
-func CopyBuilderPendingWithdrawal(original *BuilderPendingWithdrawal) *BuilderPendingWithdrawal {
-	if original == nil {
-		return nil
-	}
-
-	return &BuilderPendingWithdrawal{
-		FeeRecipient: bytesutil.SafeCopyBytes(original.FeeRecipient),
-		Amount:       original.Amount,
-		BuilderIndex: original.BuilderIndex,
-	}
-}

proto/prysm/v1alpha1/cloners_test.go

@@ -1246,89 +1246,3 @@ func genPayloadAttestations(num int) []*v1alpha1.PayloadAttestation {
 	}
 	return pas
 }
-
-func TestCopyBuilderPendingWithdrawal(t *testing.T) {
-	t.Run("nil returns nil", func(t *testing.T) {
-		if got := v1alpha1.CopyBuilderPendingWithdrawal(nil); got != nil {
-			t.Fatalf("CopyBuilderPendingWithdrawal(nil) = %v, want nil", got)
-		}
-	})
-
-	t.Run("deep copy", func(t *testing.T) {
-		original := &v1alpha1.BuilderPendingWithdrawal{
-			FeeRecipient: []byte{0x01, 0x02},
-			Amount:       primitives.Gwei(10),
-			BuilderIndex: primitives.BuilderIndex(3),
-		}
-
-		copied := v1alpha1.CopyBuilderPendingWithdrawal(original)
-		if copied == original {
-			t.Fatalf("expected new pointer for withdrawal copy")
-		}
-		if !reflect.DeepEqual(copied, original) {
-			t.Fatalf("CopyBuilderPendingWithdrawal() = %v, want %v", copied, original)
-		}
-
-		original.FeeRecipient[0] = 0xFF
-		original.Amount = primitives.Gwei(20)
-		original.BuilderIndex = primitives.BuilderIndex(9)
-
-		if copied.FeeRecipient[0] == original.FeeRecipient[0] {
-			t.Fatalf("fee recipient was not deep copied")
-		}
-		if copied.Amount != primitives.Gwei(10) {
-			t.Fatalf("amount mutated on copy: %d", copied.Amount)
-		}
-		if copied.BuilderIndex != primitives.BuilderIndex(3) {
-			t.Fatalf("builder index mutated on copy: %d", copied.BuilderIndex)
-		}
-	})
-}
-
-func TestCopyBuilderPendingPayment(t *testing.T) {
-	t.Run("nil returns nil", func(t *testing.T) {
-		if got := v1alpha1.CopyBuilderPendingPayment(nil); got != nil {
-			t.Fatalf("CopyBuilderPendingPayment(nil) = %v, want nil", got)
-		}
-	})
-
-	t.Run("deep copy", func(t *testing.T) {
-		original := &v1alpha1.BuilderPendingPayment{
-			Weight: primitives.Gwei(5),
-			Withdrawal: &v1alpha1.BuilderPendingWithdrawal{
-				FeeRecipient: []byte{0x0A, 0x0B},
-				Amount:       primitives.Gwei(50),
-				BuilderIndex: primitives.BuilderIndex(7),
-			},
-		}
-
-		copied := v1alpha1.CopyBuilderPendingPayment(original)
-		if copied == original {
-			t.Fatalf("expected new pointer for payment copy")
-		}
-		if copied.Withdrawal == original.Withdrawal {
-			t.Fatalf("expected nested withdrawal to be deep copied")
-		}
-		if !reflect.DeepEqual(copied, original) {
-			t.Fatalf("CopyBuilderPendingPayment() = %v, want %v", copied, original)
-		}
-
-		original.Weight = primitives.Gwei(10)
-		original.Withdrawal.FeeRecipient[0] = 0xFF
-		original.Withdrawal.Amount = primitives.Gwei(75)
-		original.Withdrawal.BuilderIndex = primitives.BuilderIndex(9)
-
-		if copied.Weight != primitives.Gwei(5) {
-			t.Fatalf("weight mutated on copy: %d", copied.Weight)
-		}
-		if copied.Withdrawal.FeeRecipient[0] == original.Withdrawal.FeeRecipient[0] {
-			t.Fatalf("withdrawal fee recipient was not deep copied")
-		}
-		if copied.Withdrawal.Amount != primitives.Gwei(50) {
-			t.Fatalf("withdrawal amount mutated on copy: %d", copied.Withdrawal.Amount)
-		}
-		if copied.Withdrawal.BuilderIndex != primitives.BuilderIndex(7) {
-			t.Fatalf("withdrawal builder index mutated on copy: %d", copied.Withdrawal.BuilderIndex)
-		}
-	})
-}

specrefs/.ethspecify.yml

@@ -1,4 +1,4 @@
-version: v1.7.0-alpha.0
+version: v1.7.0-alpha.1
 style: full
 
 specrefs:
@@ -117,6 +117,8 @@ exceptions:
   dataclasses:
     # Not implemented
     - BlobParameters#fulu
+    - ExpectedWithdrawals#capella
+    - ExpectedWithdrawals#electra
     - LatestMessage#phase0
     - LightClientStore#altair
     - OptimisticStore#bellatrix
@@ -126,6 +128,7 @@ exceptions:
     - LightClientStore#capella
 
     # Not implemented: gloas (future fork)
+    - ExpectedWithdrawals#gloas
     - LatestMessage#gloas
     - Store#gloas
 

specrefs/dataclasses.yml

@@ -34,6 +34,26 @@
         blobs: List[Blob, MAX_BLOB_COMMITMENTS_PER_BLOCK]
     </spec>
 
+- name: ExpectedWithdrawals#capella
+  sources: []
+  spec: |
+    <spec dataclass="ExpectedWithdrawals" fork="capella" hash="73becb4c">
+    class ExpectedWithdrawals(object):
+        withdrawals: Sequence[Withdrawal]
+        processed_sweep_withdrawals_count: uint64
+    </spec>
+
+- name: ExpectedWithdrawals#electra
+  sources: []
+  spec: |
+    <spec dataclass="ExpectedWithdrawals" fork="electra" hash="a3827f01">
+    class ExpectedWithdrawals(object):
+        withdrawals: Sequence[Withdrawal]
+        # [New in Electra:EIP7251]
+        processed_partial_withdrawals_count: uint64
+        processed_sweep_withdrawals_count: uint64
+    </spec>
+
 - name: GetPayloadResponse#bellatrix
   sources:
     - file: consensus-types/blocks/get_payload.go

specrefs/functions.yml

@@ -2366,8 +2366,8 @@
     - file: beacon-chain/state/state-native/getters_withdrawal.go
       search: func (b *BeaconState) ExpectedWithdrawals(
   spec: |
-    <spec fn="get_expected_withdrawals" fork="capella" hash="d6a98c14">
-    def get_expected_withdrawals(state: BeaconState) -> Tuple[Sequence[Withdrawal], uint64]:
+    <spec fn="get_expected_withdrawals" fork="capella" hash="12088347">
+    def get_expected_withdrawals(state: BeaconState) -> ExpectedWithdrawals:
         withdrawal_index = state.next_withdrawal_index
         withdrawals: List[Withdrawal] = []
 
@@ -2377,7 +2377,10 @@
         )
         withdrawals.extend(validators_sweep_withdrawals)
 
-        return withdrawals, processed_validators_sweep_count
+        return ExpectedWithdrawals(
+            withdrawals,
+            processed_validators_sweep_count,
+        )
     </spec>
 
 - name: get_expected_withdrawals#electra
@@ -2385,8 +2388,8 @@
     - file: beacon-chain/state/state-native/getters_withdrawal.go
       search: func (b *BeaconState) ExpectedWithdrawals(
   spec: |
-    <spec fn="get_expected_withdrawals" fork="electra" hash="cfce862b">
-    def get_expected_withdrawals(state: BeaconState) -> Tuple[Sequence[Withdrawal], uint64, uint64]:
+    <spec fn="get_expected_withdrawals" fork="electra" hash="254541e3">
+    def get_expected_withdrawals(state: BeaconState) -> ExpectedWithdrawals:
         withdrawal_index = state.next_withdrawal_index
         withdrawals: List[Withdrawal] = []
 
@@ -2403,8 +2406,12 @@
         )
         withdrawals.extend(validators_sweep_withdrawals)
 
-        # [Modified in Electra:EIP7251]
-        return withdrawals, processed_partial_withdrawals_count, processed_validators_sweep_count
+        return ExpectedWithdrawals(
+            withdrawals,
+            # [New in Electra:EIP7251]
+            processed_partial_withdrawals_count,
+            processed_validators_sweep_count,
+        )
     </spec>
 
 - name: get_filtered_block_tree
@@ -4932,7 +4939,7 @@
 - name: prepare_execution_payload#capella
   sources: []
   spec: |
-    <spec fn="prepare_execution_payload" fork="capella" hash="c258893e">
+    <spec fn="prepare_execution_payload" fork="capella" hash="998e8b92">
     def prepare_execution_payload(
         state: BeaconState,
         safe_block_hash: Hash32,
@@ -4945,15 +4952,12 @@
         parent_hash = state.latest_execution_payload_header.block_hash
 
         # Set the forkchoice head and initiate the payload build process
-        # [New in Capella]
-        withdrawals, _ = get_expected_withdrawals(state)
-
         payload_attributes = PayloadAttributes(
             timestamp=compute_time_at_slot(state, state.slot),
             prev_randao=get_randao_mix(state, get_current_epoch(state)),
             suggested_fee_recipient=suggested_fee_recipient,
             # [New in Capella]
-            withdrawals=withdrawals,
+            withdrawals=get_expected_withdrawals(state).withdrawals,
         )
         return execution_engine.notify_forkchoice_updated(
             head_block_hash=parent_hash,
@@ -4966,7 +4970,7 @@
 - name: prepare_execution_payload#deneb
   sources: []
   spec: |
-    <spec fn="prepare_execution_payload" fork="deneb" hash="59f61f3a">
+    <spec fn="prepare_execution_payload" fork="deneb" hash="c617aa1b">
     def prepare_execution_payload(
         state: BeaconState,
         safe_block_hash: Hash32,
@@ -4978,13 +4982,11 @@
         parent_hash = state.latest_execution_payload_header.block_hash
 
         # Set the forkchoice head and initiate the payload build process
-        withdrawals, _ = get_expected_withdrawals(state)
-
         payload_attributes = PayloadAttributes(
             timestamp=compute_time_at_slot(state, state.slot),
             prev_randao=get_randao_mix(state, get_current_epoch(state)),
             suggested_fee_recipient=suggested_fee_recipient,
-            withdrawals=withdrawals,
+            withdrawals=get_expected_withdrawals(state).withdrawals,
             # [New in Deneb:EIP4788]
             parent_beacon_block_root=hash_tree_root(state.latest_block_header),
         )
@@ -4999,7 +5001,7 @@
 - name: prepare_execution_payload#electra
   sources: []
   spec: |
-    <spec fn="prepare_execution_payload" fork="electra" hash="5414b883">
+    <spec fn="prepare_execution_payload" fork="electra" hash="c617aa1b">
     def prepare_execution_payload(
         state: BeaconState,
         safe_block_hash: Hash32,
@@ -5010,15 +5012,13 @@
         # Verify consistency of the parent hash with respect to the previous execution payload header
         parent_hash = state.latest_execution_payload_header.block_hash
 
-        # [Modified in EIP7251]
         # Set the forkchoice head and initiate the payload build process
-        withdrawals, _, _ = get_expected_withdrawals(state)
-
         payload_attributes = PayloadAttributes(
             timestamp=compute_time_at_slot(state, state.slot),
             prev_randao=get_randao_mix(state, get_current_epoch(state)),
             suggested_fee_recipient=suggested_fee_recipient,
-            withdrawals=withdrawals,
+            withdrawals=get_expected_withdrawals(state).withdrawals,
+            # [New in Deneb:EIP4788]
             parent_beacon_block_root=hash_tree_root(state.latest_block_header),
         )
         return execution_engine.notify_forkchoice_updated(
@@ -7071,18 +7071,18 @@
     - file: beacon-chain/core/blocks/withdrawals.go
       search: func ProcessWithdrawals(
   spec: |
-    <spec fn="process_withdrawals" fork="capella" hash="901f9fc4">
+    <spec fn="process_withdrawals" fork="capella" hash="47327ef6">
     def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
         # Get expected withdrawals
-        withdrawals, processed_validators_sweep_count = get_expected_withdrawals(state)
-        assert payload.withdrawals == withdrawals
+        expected = get_expected_withdrawals(state)
+        assert payload.withdrawals == expected.withdrawals
 
         # Apply expected withdrawals
-        apply_withdrawals(state, withdrawals)
+        apply_withdrawals(state, expected.withdrawals)
 
         # Update withdrawals fields in the state
-        update_next_withdrawal_index(state, withdrawals)
-        update_next_withdrawal_validator_index(state, processed_validators_sweep_count)
+        update_next_withdrawal_index(state, expected.withdrawals)
+        update_next_withdrawal_validator_index(state, expected.withdrawals)
     </spec>
 
 - name: process_withdrawals#electra
@@ -7090,23 +7090,20 @@
     - file: beacon-chain/core/blocks/withdrawals.go
       search: func ProcessWithdrawals(
   spec: |
-    <spec fn="process_withdrawals" fork="electra" hash="67870972">
+    <spec fn="process_withdrawals" fork="electra" hash="24a50daa">
     def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
-        # [Modified in Electra:EIP7251]
         # Get expected withdrawals
-        withdrawals, processed_partial_withdrawals_count, processed_validators_sweep_count = (
-            get_expected_withdrawals(state)
-        )
-        assert payload.withdrawals == withdrawals
+        expected = get_expected_withdrawals(state)
+        assert payload.withdrawals == expected.withdrawals
 
         # Apply expected withdrawals
-        apply_withdrawals(state, withdrawals)
+        apply_withdrawals(state, expected.withdrawals)
 
         # Update withdrawals fields in the state
-        update_next_withdrawal_index(state, withdrawals)
+        update_next_withdrawal_index(state, expected.withdrawals)
         # [New in Electra:EIP7251]
-        update_pending_partial_withdrawals(state, processed_partial_withdrawals_count)
-        update_next_withdrawal_validator_index(state, processed_validators_sweep_count)
+        update_pending_partial_withdrawals(state, expected.processed_partial_withdrawals_count)
+        update_next_withdrawal_validator_index(state, expected.withdrawals)
     </spec>
 
 - name: queue_excess_active_balance

testing/spectest/mainnet/BUILD.bazel

@@ -200,7 +200,6 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
-        "gloas__operations__execution_payload_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -279,7 +278,6 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
-        "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/mainnet/gloas__operations__execution_payload_test.go

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

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

@@ -1,29 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    testonly = True,
-    srcs = [
-        "execution_payload.go",
-        "helpers.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/gloas:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/spectest/utils:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_golang_snappy//:go_default_library",
-        "@com_github_google_go_cmp//cmp:go_default_library",
-        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
-    ],
-)

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

@@ -1,119 +0,0 @@
-package operations
-
-import (
-	"context"
-	"os"
-	"path"
-	"strings"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
-	"github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/golang/snappy"
-	"github.com/google/go-cmp/cmp"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/testing/protocmp"
-)
-
-type ExecutionConfig struct {
-	Valid bool `json:"execution_valid"`
-}
-
-func sszToSignedExecutionPayloadEnvelope(b []byte) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
-	envelope := &ethpb.SignedExecutionPayloadEnvelope{}
-	if err := envelope.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return blocks.WrappedROSignedExecutionPayloadEnvelope(envelope)
-}
-
-func RunExecutionPayloadTest(t *testing.T, config string) {
-	require.NoError(t, utils.SetConfig(t, config))
-	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "operations/execution_payload/pyspec_tests")
-	if len(testFolders) == 0 {
-		t.Fatalf("No test folders found for %s/%s/%s", config, "gloas", "operations/execution_payload/pyspec_tests")
-	}
-	for _, folder := range testFolders {
-		t.Run(folder.Name(), func(t *testing.T) {
-			helpers.ClearCache()
-
-			// Check if signed_envelope.ssz_snappy exists, skip if not
-			_, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy"))
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				t.Skipf("Skipping test %s: signed_envelope.ssz_snappy not found", folder.Name())
-				return
-			}
-
-			// Read the signed execution payload envelope
-			envelopeFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy")
-			require.NoError(t, err)
-			envelopeSSZ, err := snappy.Decode(nil /* dst */, envelopeFile)
-			require.NoError(t, err, "Failed to decompress envelope")
-			signedEnvelope, err := sszToSignedExecutionPayloadEnvelope(envelopeSSZ)
-			require.NoError(t, err, "Failed to unmarshal signed envelope")
-
-			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
-			require.NoError(t, err)
-			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
-			require.NoError(t, err, "Failed to decompress")
-			preBeaconState, err := sszToState(preBeaconStateSSZ)
-			require.NoError(t, err)
-
-			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
-			postSSZExists := true
-			if err != nil && strings.Contains(err.Error(), "could not locate file") {
-				postSSZExists = false
-			} else {
-				require.NoError(t, err)
-			}
-
-			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
-			require.NoError(t, err)
-			config := &ExecutionConfig{}
-			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
-			if !config.Valid {
-				t.Skip("Skipping invalid execution engine test as it's never supported")
-			}
-
-			err = gloas.ProcessExecutionPayload(context.Background(), preBeaconState, signedEnvelope)
-			if postSSZExists {
-				require.NoError(t, err)
-				comparePostState(t, postSSZFilepath, preBeaconState)
-			} else if config.Valid {
-				// Note: This doesn't test anything worthwhile. It essentially tests
-				// that *any* error has occurred, not any specific error.
-				if err == nil {
-					t.Fatal("Did not fail when expected")
-				}
-				t.Logf("Expected failure; failure reason = %v", err)
-				return
-			}
-		})
-	}
-}
-
-func comparePostState(t *testing.T, postSSZFilepath string, want state.BeaconState) {
-	postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
-	require.NoError(t, err)
-	postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
-	require.NoError(t, err, "Failed to decompress")
-	postBeaconState, err := sszToState(postBeaconStateSSZ)
-	require.NoError(t, err)
-	postBeaconStatePb, ok := postBeaconState.ToProtoUnsafe().(proto.Message)
-	require.Equal(t, true, ok, "post beacon state did not return a proto.Message")
-	pbState, ok := want.ToProtoUnsafe().(proto.Message)
-	require.Equal(t, true, ok, "beacon state did not return a proto.Message")
-
-	if !proto.Equal(postBeaconStatePb, pbState) {
-		diff := cmp.Diff(pbState, postBeaconStatePb, protocmp.Transform())
-		t.Fatalf("Post state does not match expected state, diff: %s", diff)
-	}
-}

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

@@ -1,15 +0,0 @@
-package operations
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-)
-
-func sszToState(b []byte) (state.BeaconState, error) {
-	base := &ethpb.BeaconStateGloas{}
-	if err := base.UnmarshalSSZ(b); err != nil {
-		return nil, err
-	}
-	return state_native.InitializeFromProtoGloas(base)
-}

testing/spectest/utils/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/utils",
     visibility = ["//testing/spectest:__subpackages__"],
     deps = [
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//io/file:go_default_library",
         "//testing/require:go_default_library",

testing/spectest/utils/config.go

@@ -6,20 +6,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 )
 
 // SetConfig sets the global params for spec tests depending on the option chosen.
 // Provides reset function allowing to get back to the previous configuration at the end of a test.
 func SetConfig(t testing.TB, config string) error {
-	params.SetupTestConfigCleanup(t)
-
-	resetFeatures := features.InitWithReset(&features.Flags{
-		LowValcountSweep: true,
-	})
-	t.Cleanup(resetFeatures)
-
 	switch config {
 	case "minimal":
 		params.OverrideBeaconConfig(params.MinimalSpecConfig().Copy())