Bump the go_modules group across 1 directory with 5 updates

Bumps the go_modules group with 5 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [github.com/consensys/gnark-crypto](https://github.com/consensys/gnark-crypto) | `0.14.0` | `0.18.1` |
| [golang.org/x/crypto](https://github.com/golang/crypto) | `0.44.0` | `0.45.0` |
| [github.com/pion/interceptor](https://github.com/pion/interceptor) | `0.1.37` | `0.1.39` |
| [github.com/quic-go/quic-go](https://github.com/quic-go/quic-go) | `0.49.1-0.20250925085836-275c172fec2b` | `0.57.0` |
| [golang.org/x/oauth2](https://github.com/golang/oauth2) | `0.25.0` | `0.27.0` |



Updates `github.com/consensys/gnark-crypto` from 0.14.0 to 0.18.1
- [Release notes](https://github.com/consensys/gnark-crypto/releases)
- [Changelog](https://github.com/Consensys/gnark-crypto/blob/master/CHANGELOG.md)
- [Commits](https://github.com/consensys/gnark-crypto/compare/v0.14.0...v0.18.1)

Updates `golang.org/x/crypto` from 0.44.0 to 0.45.0
- [Commits](https://github.com/golang/crypto/compare/v0.44.0...v0.45.0)

Updates `github.com/pion/interceptor` from 0.1.37 to 0.1.39
- [Release notes](https://github.com/pion/interceptor/releases)
- [Commits](https://github.com/pion/interceptor/compare/v0.1.37...v0.1.39)

Updates `github.com/quic-go/quic-go` from 0.49.1-0.20250925085836-275c172fec2b to 0.57.0
- [Release notes](https://github.com/quic-go/quic-go/releases)
- [Commits](https://github.com/quic-go/quic-go/commits/v0.57.0)

Updates `golang.org/x/oauth2` from 0.25.0 to 0.27.0
- [Commits](https://github.com/golang/oauth2/compare/v0.25.0...v0.27.0)

---
updated-dependencies:
- dependency-name: github.com/consensys/gnark-crypto
  dependency-version: 0.18.1
  dependency-type: direct:production
  dependency-group: go_modules
- dependency-name: golang.org/x/crypto
  dependency-version: 0.45.0
  dependency-type: direct:production
  dependency-group: go_modules
- dependency-name: github.com/pion/interceptor
  dependency-version: 0.1.39
  dependency-type: indirect
  dependency-group: go_modules
- dependency-name: github.com/quic-go/quic-go
  dependency-version: 0.57.0
  dependency-type: indirect
  dependency-group: go_modules
- dependency-name: golang.org/x/oauth2
  dependency-version: 0.27.0
  dependency-type: indirect
  dependency-group: go_modules
...

Signed-off-by: dependabot[bot] <support@github.com>

BUILD.bazel

@@ -1,4 +1,5 @@
 load("@bazel_gazelle//:def.bzl", "gazelle")
+load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
@@ -54,6 +55,15 @@ alias(
     visibility = ["//visibility:public"],
 )
 
+gometalinter(
+    name = "gometalinter",
+    config = "//:.gometalinter.json",
+    paths = [
+        "./...",
+    ],
+    prefix = prefix,
+)
+
 goimports(
     name = "goimports",
     display_diffs = True,

WORKSPACE

@@ -423,6 +423,10 @@ load("@prysm//testing/endtoend:deps.bzl", "e2e_deps")
 
 e2e_deps()
 
+load("@com_github_atlassian_bazel_tools//gometalinter:deps.bzl", "gometalinter_dependencies")
+
+gometalinter_dependencies()
+
 load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
 
 gazelle_dependencies(go_sdk = "go_sdk")

api/server/structs/block.go

@@ -503,77 +503,3 @@ func (s *SignedBlindedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
 func (s *SignedBlindedBeaconBlockFulu) SigString() string {
 	return s.Signature
 }
-
-// ----------------------------------------------------------------------------
-// Gloas
-// ----------------------------------------------------------------------------
-
-type ExecutionPayloadBid struct {
-	ParentBlockHash        string `json:"parent_block_hash"`
-	ParentBlockRoot        string `json:"parent_block_root"`
-	BlockHash              string `json:"block_hash"`
-	PrevRandao             string `json:"prev_randao"`
-	FeeRecipient           string `json:"fee_recipient"`
-	GasLimit               string `json:"gas_limit"`
-	BuilderIndex           string `json:"builder_index"`
-	Slot                   string `json:"slot"`
-	Value                  string `json:"value"`
-	ExecutionPayment       string `json:"execution_payment"`
-	BlobKzgCommitmentsRoot string `json:"blob_kzg_commitments_root"`
-}
-
-type SignedExecutionPayloadBid struct {
-	Message   *ExecutionPayloadBid `json:"message"`
-	Signature string               `json:"signature"`
-}
-
-type PayloadAttestationData struct {
-	BeaconBlockRoot   string `json:"beacon_block_root"`
-	Slot              string `json:"slot"`
-	PayloadPresent    bool   `json:"payload_present"`
-	BlobDataAvailable bool   `json:"blob_data_available"`
-}
-
-type PayloadAttestation struct {
-	AggregationBits string                  `json:"aggregation_bits"`
-	Data            *PayloadAttestationData `json:"data"`
-	Signature       string                  `json:"signature"`
-}
-
-type BeaconBlockBodyGloas struct {
-	RandaoReveal              string                        `json:"randao_reveal"`
-	Eth1Data                  *Eth1Data                     `json:"eth1_data"`
-	Graffiti                  string                        `json:"graffiti"`
-	ProposerSlashings         []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings         []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations              []*AttestationElectra         `json:"attestations"`
-	Deposits                  []*Deposit                    `json:"deposits"`
-	VoluntaryExits            []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate             *SyncAggregate                `json:"sync_aggregate"`
-	BLSToExecutionChanges     []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	SignedExecutionPayloadBid *SignedExecutionPayloadBid    `json:"signed_execution_payload_bid"`
-	PayloadAttestations       []*PayloadAttestation         `json:"payload_attestations"`
-}
-
-type BeaconBlockGloas struct {
-	Slot          string                `json:"slot"`
-	ProposerIndex string                `json:"proposer_index"`
-	ParentRoot    string                `json:"parent_root"`
-	StateRoot     string                `json:"state_root"`
-	Body          *BeaconBlockBodyGloas `json:"body"`
-}
-
-type SignedBeaconBlockGloas struct {
-	Message   *BeaconBlockGloas `json:"message"`
-	Signature string            `json:"signature"`
-}
-
-var _ SignedMessageJsoner = &SignedBeaconBlockGloas{}
-
-func (s *SignedBeaconBlockGloas) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBeaconBlockGloas) SigString() string {
-	return s.Signature
-}

api/server/structs/conversions_block.go

@@ -268,8 +268,6 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockFuluFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockFulu:
 		return SignedBeaconBlockFuluFromConsensus(pbStruct)
-	case *eth.SignedBeaconBlockGloas:
-		return SignedBeaconBlockGloasFromConsensus(pbStruct)
 	default:
 		return nil, ErrUnsupportedConversion
 	}
@@ -2887,379 +2885,3 @@ func SignedBeaconBlockFuluFromConsensus(b *eth.SignedBeaconBlockFulu) (*SignedBe
 		Signature: hexutil.Encode(b.Signature),
 	}, nil
 }
-
-// ----------------------------------------------------------------------------
-// Gloas
-// ----------------------------------------------------------------------------
-
-func SignedBeaconBlockGloasFromConsensus(b *eth.SignedBeaconBlockGloas) (*SignedBeaconBlockGloas, error) {
-	block, err := BeaconBlockGloasFromConsensus(b.Block)
-	if err != nil {
-		return nil, err
-	}
-	return &SignedBeaconBlockGloas{
-		Message:   block,
-		Signature: hexutil.Encode(b.Signature),
-	}, nil
-}
-
-func BeaconBlockGloasFromConsensus(b *eth.BeaconBlockGloas) (*BeaconBlockGloas, error) {
-	payloadAttestations := make([]*PayloadAttestation, len(b.Body.PayloadAttestations))
-	for i, pa := range b.Body.PayloadAttestations {
-		payloadAttestations[i] = PayloadAttestationFromConsensus(pa)
-	}
-
-	return &BeaconBlockGloas{
-		Slot:          fmt.Sprintf("%d", b.Slot),
-		ProposerIndex: fmt.Sprintf("%d", b.ProposerIndex),
-		ParentRoot:    hexutil.Encode(b.ParentRoot),
-		StateRoot:     hexutil.Encode(b.StateRoot),
-		Body: &BeaconBlockBodyGloas{
-			RandaoReveal:              hexutil.Encode(b.Body.RandaoReveal),
-			Eth1Data:                  Eth1DataFromConsensus(b.Body.Eth1Data),
-			Graffiti:                  hexutil.Encode(b.Body.Graffiti),
-			ProposerSlashings:         ProposerSlashingsFromConsensus(b.Body.ProposerSlashings),
-			AttesterSlashings:         AttesterSlashingsElectraFromConsensus(b.Body.AttesterSlashings),
-			Attestations:              AttsElectraFromConsensus(b.Body.Attestations),
-			Deposits:                  DepositsFromConsensus(b.Body.Deposits),
-			VoluntaryExits:            SignedExitsFromConsensus(b.Body.VoluntaryExits),
-			SyncAggregate:             SyncAggregateFromConsensus(b.Body.SyncAggregate),
-			BLSToExecutionChanges:     SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
-			SignedExecutionPayloadBid: SignedExecutionPayloadBidFromConsensus(b.Body.SignedExecutionPayloadBid),
-			PayloadAttestations:       payloadAttestations,
-		},
-	}, nil
-}
-
-func SignedExecutionPayloadBidFromConsensus(b *eth.SignedExecutionPayloadBid) *SignedExecutionPayloadBid {
-	return &SignedExecutionPayloadBid{
-		Message:   ExecutionPayloadBidFromConsensus(b.Message),
-		Signature: hexutil.Encode(b.Signature),
-	}
-}
-
-func ExecutionPayloadBidFromConsensus(b *eth.ExecutionPayloadBid) *ExecutionPayloadBid {
-	return &ExecutionPayloadBid{
-		ParentBlockHash:        hexutil.Encode(b.ParentBlockHash),
-		ParentBlockRoot:        hexutil.Encode(b.ParentBlockRoot),
-		BlockHash:              hexutil.Encode(b.BlockHash),
-		PrevRandao:             hexutil.Encode(b.PrevRandao),
-		FeeRecipient:           hexutil.Encode(b.FeeRecipient),
-		GasLimit:               fmt.Sprintf("%d", b.GasLimit),
-		BuilderIndex:           fmt.Sprintf("%d", b.BuilderIndex),
-		Slot:                   fmt.Sprintf("%d", b.Slot),
-		Value:                  fmt.Sprintf("%d", b.Value),
-		ExecutionPayment:       fmt.Sprintf("%d", b.ExecutionPayment),
-		BlobKzgCommitmentsRoot: hexutil.Encode(b.BlobKzgCommitmentsRoot),
-	}
-}
-
-func PayloadAttestationFromConsensus(pa *eth.PayloadAttestation) *PayloadAttestation {
-	return &PayloadAttestation{
-		AggregationBits: hexutil.Encode(pa.AggregationBits),
-		Data:            PayloadAttestationDataFromConsensus(pa.Data),
-		Signature:       hexutil.Encode(pa.Signature),
-	}
-}
-
-func PayloadAttestationDataFromConsensus(d *eth.PayloadAttestationData) *PayloadAttestationData {
-	return &PayloadAttestationData{
-		BeaconBlockRoot:   hexutil.Encode(d.BeaconBlockRoot),
-		Slot:              fmt.Sprintf("%d", d.Slot),
-		PayloadPresent:    d.PayloadPresent,
-		BlobDataAvailable: d.BlobDataAvailable,
-	}
-}
-
-func (b *SignedBeaconBlockGloas) ToConsensus() (*eth.SignedBeaconBlockGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-
-	sig, err := bytesutil.DecodeHexWithLength(b.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	block, err := b.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	return &eth.SignedBeaconBlockGloas{
-		Block:     block,
-		Signature: sig,
-	}, nil
-}
-
-func (b *BeaconBlockGloas) ToConsensus() (*eth.BeaconBlockGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	if b.Body == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body")
-	}
-	if b.Body.Eth1Data == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.Eth1Data")
-	}
-	if b.Body.SyncAggregate == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.SyncAggregate")
-	}
-	if b.Body.SignedExecutionPayloadBid == nil {
-		return nil, server.NewDecodeError(errNilValue, "Body.SignedExecutionPayloadBid")
-	}
-
-	slot, err := strconv.ParseUint(b.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	proposerIndex, err := strconv.ParseUint(b.ProposerIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ProposerIndex")
-	}
-	parentRoot, err := bytesutil.DecodeHexWithLength(b.ParentRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentRoot")
-	}
-	stateRoot, err := bytesutil.DecodeHexWithLength(b.StateRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "StateRoot")
-	}
-	body, err := b.Body.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body")
-	}
-	return &eth.BeaconBlockGloas{
-		Slot:          primitives.Slot(slot),
-		ProposerIndex: primitives.ValidatorIndex(proposerIndex),
-		ParentRoot:    parentRoot,
-		StateRoot:     stateRoot,
-		Body:          body,
-	}, nil
-}
-
-func (b *BeaconBlockBodyGloas) ToConsensus() (*eth.BeaconBlockBodyGloas, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-
-	randaoReveal, err := bytesutil.DecodeHexWithLength(b.RandaoReveal, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "RandaoReveal")
-	}
-	depositRoot, err := bytesutil.DecodeHexWithLength(b.Eth1Data.DepositRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.DepositRoot")
-	}
-	depositCount, err := strconv.ParseUint(b.Eth1Data.DepositCount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.DepositCount")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(b.Eth1Data.BlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Eth1Data.BlockHash")
-	}
-	graffiti, err := bytesutil.DecodeHexWithLength(b.Graffiti, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Graffiti")
-	}
-	proposerSlashings, err := ProposerSlashingsToConsensus(b.ProposerSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ProposerSlashings")
-	}
-	attesterSlashings, err := AttesterSlashingsElectraToConsensus(b.AttesterSlashings)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AttesterSlashings")
-	}
-	atts, err := AttsElectraToConsensus(b.Attestations)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Attestations")
-	}
-	deposits, err := DepositsToConsensus(b.Deposits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Deposits")
-	}
-	exits, err := SignedExitsToConsensus(b.VoluntaryExits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "VoluntaryExits")
-	}
-	syncCommitteeBits, err := bytesutil.DecodeHexWithLength(b.SyncAggregate.SyncCommitteeBits, fieldparams.SyncAggregateSyncCommitteeBytesLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SyncAggregate.SyncCommitteeBits")
-	}
-	syncCommitteeSig, err := bytesutil.DecodeHexWithLength(b.SyncAggregate.SyncCommitteeSignature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SyncAggregate.SyncCommitteeSignature")
-	}
-	blsChanges, err := SignedBLSChangesToConsensus(b.BLSToExecutionChanges)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BLSToExecutionChanges")
-	}
-	signedBid, err := b.SignedExecutionPayloadBid.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SignedExecutionPayloadBid")
-	}
-	payloadAttestations, err := PayloadAttestationsToConsensus(b.PayloadAttestations)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "PayloadAttestations")
-	}
-
-	return &eth.BeaconBlockBodyGloas{
-		RandaoReveal: randaoReveal,
-		Eth1Data: &eth.Eth1Data{
-			DepositRoot:  depositRoot,
-			DepositCount: depositCount,
-			BlockHash:    blockHash,
-		},
-		Graffiti:          graffiti,
-		ProposerSlashings: proposerSlashings,
-		AttesterSlashings: attesterSlashings,
-		Attestations:      atts,
-		Deposits:          deposits,
-		VoluntaryExits:    exits,
-		SyncAggregate: &eth.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: syncCommitteeSig,
-		},
-		BlsToExecutionChanges:     blsChanges,
-		SignedExecutionPayloadBid: signedBid,
-		PayloadAttestations:       payloadAttestations,
-	}, nil
-}
-
-func (b *SignedExecutionPayloadBid) ToConsensus() (*eth.SignedExecutionPayloadBid, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	sig, err := bytesutil.DecodeHexWithLength(b.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	message, err := b.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	return &eth.SignedExecutionPayloadBid{
-		Message:   message,
-		Signature: sig,
-	}, nil
-}
-
-func (b *ExecutionPayloadBid) ToConsensus() (*eth.ExecutionPayloadBid, error) {
-	if b == nil {
-		return nil, errNilValue
-	}
-	parentBlockHash, err := bytesutil.DecodeHexWithLength(b.ParentBlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockHash")
-	}
-	parentBlockRoot, err := bytesutil.DecodeHexWithLength(b.ParentBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ParentBlockRoot")
-	}
-	blockHash, err := bytesutil.DecodeHexWithLength(b.BlockHash, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlockHash")
-	}
-	prevRandao, err := bytesutil.DecodeHexWithLength(b.PrevRandao, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "PrevRandao")
-	}
-	feeRecipient, err := bytesutil.DecodeHexWithLength(b.FeeRecipient, fieldparams.FeeRecipientLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "FeeRecipient")
-	}
-	gasLimit, err := strconv.ParseUint(b.GasLimit, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "GasLimit")
-	}
-	builderIndex, err := strconv.ParseUint(b.BuilderIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BuilderIndex")
-	}
-	slot, err := strconv.ParseUint(b.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	value, err := strconv.ParseUint(b.Value, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Value")
-	}
-	executionPayment, err := strconv.ParseUint(b.ExecutionPayment, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ExecutionPayment")
-	}
-	blobKzgCommitmentsRoot, err := bytesutil.DecodeHexWithLength(b.BlobKzgCommitmentsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BlobKzgCommitmentsRoot")
-	}
-	return &eth.ExecutionPayloadBid{
-		ParentBlockHash:        parentBlockHash,
-		ParentBlockRoot:        parentBlockRoot,
-		BlockHash:              blockHash,
-		PrevRandao:             prevRandao,
-		FeeRecipient:           feeRecipient,
-		GasLimit:               gasLimit,
-		BuilderIndex:           primitives.BuilderIndex(builderIndex),
-		Slot:                   primitives.Slot(slot),
-		Value:                  primitives.Gwei(value),
-		ExecutionPayment:       primitives.Gwei(executionPayment),
-		BlobKzgCommitmentsRoot: blobKzgCommitmentsRoot,
-	}, nil
-}
-
-func PayloadAttestationsToConsensus(pa []*PayloadAttestation) ([]*eth.PayloadAttestation, error) {
-	if pa == nil {
-		return nil, errNilValue
-	}
-	result := make([]*eth.PayloadAttestation, len(pa))
-	for i, p := range pa {
-		converted, err := p.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d]", i))
-		}
-		result[i] = converted
-	}
-	return result, nil
-}
-
-func (p *PayloadAttestation) ToConsensus() (*eth.PayloadAttestation, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	aggregationBits, err := hexutil.Decode(p.AggregationBits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AggregationBits")
-	}
-	data, err := p.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(p.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	return &eth.PayloadAttestation{
-		AggregationBits: aggregationBits,
-		Data:            data,
-		Signature:       sig,
-	}, nil
-}
-
-func (d *PayloadAttestationData) ToConsensus() (*eth.PayloadAttestationData, error) {
-	if d == nil {
-		return nil, errNilValue
-	}
-	beaconBlockRoot, err := bytesutil.DecodeHexWithLength(d.BeaconBlockRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "BeaconBlockRoot")
-	}
-	slot, err := strconv.ParseUint(d.Slot, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Slot")
-	}
-	return &eth.PayloadAttestationData{
-		BeaconBlockRoot:   beaconBlockRoot,
-		Slot:              primitives.Slot(slot),
-		PayloadPresent:    d.PayloadPresent,
-		BlobDataAvailable: d.BlobDataAvailable,
-	}, nil
-}

beacon-chain/blockchain/BUILD.bazel

@@ -27,7 +27,6 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "receive_data_column.go",
-        "receive_proof.go",
         "service.go",
         "setup_forkchoice.go",
         "tracked_proposer.go",
@@ -50,7 +49,6 @@ go_library(
         "//beacon-chain/core/electra:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
-        "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",

beacon-chain/blockchain/options.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem"
@@ -227,14 +226,6 @@ func WithDataColumnStorage(b *filesystem.DataColumnStorage) Option {
 	}
 }
 
-// WithProofStorage sets the proof storage backend for the blockchain service.
-func WithProofStorage(p *filesystem.ProofStorage) Option {
-	return func(s *Service) error {
-		s.proofStorage = p
-		return nil
-	}
-}
-
 // WithSyncChecker sets the sync checker for the blockchain service.
 func WithSyncChecker(checker Checker) Option {
 	return func(s *Service) error {
@@ -275,10 +266,3 @@ func WithStartWaitingDataColumnSidecars(c chan bool) Option {
 		return nil
 	}
 }
-
-func WithOperationNotifier(operationNotifier operation.Notifier) Option {
-	return func(s *Service) error {
-		s.cfg.OperationNotifier = operationNotifier
-		return nil
-	}
-}

beacon-chain/blockchain/process_block.go

@@ -113,7 +113,6 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 			s.updateCachesPostBlockProcessing(cfg)
 		}()
 	}
-
 	return nil
 }
 
@@ -662,17 +661,10 @@ func (s *Service) isDataAvailable(
 		return errors.New("invalid nil beacon block")
 	}
 
-	root, blockVersion := roBlock.Root(), roBlock.Version()
+	root := roBlock.Root()
+	blockVersion := block.Version()
 	if blockVersion >= version.Fulu {
-		if err := s.areExecutionProofsAvailable(ctx, roBlock); err != nil {
-			return fmt.Errorf("are execution proofs available: %w", err)
-		}
-
-		if err := s.areDataColumnsAvailable(ctx, root, block); err != nil {
-			return fmt.Errorf("are data columns available: %w", err)
-		}
-
-		return nil
+		return s.areDataColumnsAvailable(ctx, root, block)
 	}
 
 	if blockVersion >= version.Deneb {
@@ -682,77 +674,6 @@ func (s *Service) isDataAvailable(
 	return nil
 }
 
-// areExecutionProofsAvailable blocks until we have enough execution proofs to import the block,
-// or an error or context cancellation occurs.
-// This check is only performed for lightweight verifier nodes that need zkVM proofs
-// to validate block execution (nodes without execution layer + proof generation capability).
-// A nil result means that the data availability check is successful.
-func (s *Service) areExecutionProofsAvailable(ctx context.Context, roBlock consensusblocks.ROBlock) error {
-	// Return early if zkVM features are disabled (no need to check for execution proofs),
-	// or if the generation proof is enabled (we will generate proofs ourselves).
-	if !features.Get().EnableZkvm {
-		return nil
-	}
-
-	root, slot := roBlock.Root(), roBlock.Block().Slot()
-
-	requiredProofCount := params.BeaconConfig().MinProofsRequired
-	log := log.WithFields(logrus.Fields{
-		"root":               fmt.Sprintf("%#x", root),
-		"slot":               slot,
-		"requiredProofCount": requiredProofCount,
-	})
-
-	// Subscribe to newly execution proofs stored in the database.
-	subscription, identChan := s.proofStorage.Subscribe()
-	defer subscription.Unsubscribe()
-
-	// Return early if we already have enough proofs.
-	if actualProofCount := uint64(s.proofStorage.Summary(root).Count()); actualProofCount >= requiredProofCount {
-		log.WithField("actualProofCount", actualProofCount).Debug("Already have enough execution proofs")
-		return nil
-	}
-
-	// Log for DA checks that cross over into the next slot; helpful for debugging.
-	nextSlot, err := slots.StartTime(s.genesisTime, roBlock.Block().Slot()+1)
-	if err != nil {
-		return fmt.Errorf("start time: %w", err)
-	}
-
-	// Avoid logging if DA check is called after next slot start.
-	if nextSlot.After(time.Now()) {
-		timer := time.AfterFunc(time.Until(nextSlot), func() {
-			actualCount := uint64(s.proofStorage.Summary(root).Count())
-			if actualCount >= requiredProofCount {
-				return
-			}
-
-			log.WithField("proofsRetrieved", actualCount).Warning("Execution proofs still missing at slot end")
-		})
-
-		defer timer.Stop()
-	}
-
-	// Some proofs are missing; wait for them.
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case proofIdent := <-identChan:
-			// Skip if the proof is for a different block.
-			if proofIdent.BlockRoot != root {
-				continue
-			}
-
-			// Return if we have enough proofs.
-			if actualProofCount := uint64(s.proofStorage.Summary(root).Count()); actualProofCount >= requiredProofCount {
-				log.WithField("actualProofCount", actualProofCount).Debug("Got enough execution proofs")
-				return nil
-			}
-		}
-	}
-}
-
 // areDataColumnsAvailable blocks until all data columns committed to in the block are available,
 // or an error or context cancellation occurs. A nil result means that the data availability check is successful.
 func (s *Service) areDataColumnsAvailable(
@@ -889,7 +810,14 @@ func (s *Service) areDataColumnsAvailable(
 			}
 
 		case <-ctx.Done():
-			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, helpers.SortedPrettySliceFromMap(missing))
+			var missingIndices any = "all"
+			missingIndicesCount := len(missing)
+
+			if missingIndicesCount < fieldparams.NumberOfColumns {
+				missingIndices = helpers.SortedPrettySliceFromMap(missing)
+			}
+
+			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, missingIndices)
 		}
 	}
 }

beacon-chain/blockchain/receive_block.go

@@ -60,12 +60,6 @@ type DataColumnReceiver interface {
 	ReceiveDataColumns([]blocks.VerifiedRODataColumn) error
 }
 
-// ProofReceiver interface defines the methods of chain service for receiving new
-// execution proofs
-type ProofReceiver interface {
-	ReceiveProof(blocks.VerifiedROSignedExecutionProof) error
-}
-
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)

beacon-chain/blockchain/receive_proof.go

@@ -1,15 +0,0 @@
-package blockchain
-
-import (
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/pkg/errors"
-)
-
-// ReceiveProof saves an execution proof to storage.
-func (s *Service) ReceiveProof(proof blocks.VerifiedROSignedExecutionProof) error {
-	if err := s.proofStorage.Save([]blocks.VerifiedROSignedExecutionProof{proof}); err != nil {
-		return errors.Wrap(err, "save proof")
-	}
-
-	return nil
-}

beacon-chain/blockchain/service.go

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/async/event"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
@@ -65,7 +64,6 @@ type Service struct {
 	blockBeingSynced               *currentlySyncingBlock
 	blobStorage                    *filesystem.BlobStorage
 	dataColumnStorage              *filesystem.DataColumnStorage
-	proofStorage                   *filesystem.ProofStorage
 	slasherEnabled                 bool
 	lcStore                        *lightClient.Store
 	startWaitingDataColumnSidecars chan bool // for testing purposes only
@@ -88,7 +86,6 @@ type config struct {
 	P2P                     p2p.Accessor
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
-	OperationNotifier       operation.Notifier
 	ForkChoiceStore         f.ForkChoicer
 	AttService              *attestations.Service
 	StateGen                *stategen.State

beacon-chain/blockchain/testing/mock.go

@@ -75,7 +75,6 @@ type ChainService struct {
 	SyncingRoot                 [32]byte
 	Blobs                       []blocks.VerifiedROBlob
 	DataColumns                 []blocks.VerifiedRODataColumn
-	Proofs                      []blocks.VerifiedROSignedExecutionProof
 	TargetRoot                  [32]byte
 	MockHeadSlot                *primitives.Slot
 }
@@ -758,12 +757,6 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 	return nil
 }
 
-// ReceiveProof implements the same method in chain service
-func (c *ChainService) ReceiveProof(proof blocks.VerifiedROSignedExecutionProof) error {
-	c.Proofs = append(c.Proofs, proof)
-	return nil
-}
-
 // DependentRootForEpoch mocks the same method in the chain service
 func (c *ChainService) DependentRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/core/altair/deposit.go

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

beacon-chain/core/blocks/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "attestation.go",
         "attester_slashing.go",
+        "deposit.go",
         "error.go",
         "eth1_data.go",
         "exit.go",
@@ -20,7 +21,6 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -33,6 +33,8 @@ go_library(
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//container/trie:go_default_library",
+        "//contracts/deposit:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -59,6 +61,7 @@ go_test(
         "attester_slashing_test.go",
         "block_operations_fuzz_test.go",
         "block_regression_test.go",
+        "deposit_test.go",
         "eth1_data_test.go",
         "exit_test.go",
         "exports_test.go",
@@ -87,6 +90,7 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/bls/common:go_default_library",
         "//crypto/hash:go_default_library",

beacon-chain/core/blocks/block_operations_fuzz_test.go

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

beacon-chain/core/blocks/deposit.go

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

beacon-chain/core/blocks/deposit_test.go

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

beacon-chain/core/blocks/proposer_slashing.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
@@ -12,7 +11,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
@@ -128,16 +126,7 @@ func processProposerSlashing(
 	if exitInfo == nil {
 		return nil, errors.New("exit info is required to process proposer slashing")
 	}
-
 	var err error
-	// [New in Gloas:EIP7732]: remove the BuilderPendingPayment corresponding to the slashed proposer within 2 epoch window
-	if beaconState.Version() >= version.Gloas {
-		err = gloas.RemoveBuilderPendingPayment(beaconState, slashing.Header_1.Header)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	beaconState, err = validators.SlashValidator(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, exitInfo)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)

beacon-chain/core/electra/BUILD.bazel

@@ -14,11 +14,13 @@ go_library(
         "transition.go",
         "upgrade.go",
         "validator.go",
+        "withdrawals.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/electra",
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
@@ -41,6 +43,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 +64,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 +83,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

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

@@ -46,9 +46,6 @@ const (
 
 	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
 	DataColumnReceived = 12
-
-	// ExecutionProofReceived is sent after a execution proof object has been received from gossip or rpc.
-	ExecutionProofReceived = 13
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -80,11 +77,6 @@ type BLSToExecutionChangeReceivedData struct {
 	Change *ethpb.SignedBLSToExecutionChange
 }
 
-// ExecutionProofReceivedData is the data sent with ExecutionProofReceived events.
-type ExecutionProofReceivedData struct {
-	ExecutionProof *blocks.VerifiedROSignedExecutionProof
-}
-
 // BlobSidecarReceivedData is the data sent with BlobSidecarReceived events.
 type BlobSidecarReceivedData struct {
 	Blob *blocks.VerifiedROBlob

beacon-chain/core/gloas/BUILD.bazel

@@ -1,66 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "bid.go",
-        "payload_attestation.go",
-        "pending_payment.go",
-        "proposer_slashing.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    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",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types: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",
-        "//crypto/bls/common:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil: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 = [
-        "bid_test.go",
-        "payload_attestation_test.go",
-        "pending_payment_test.go",
-        "proposer_slashing_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/core/helpers: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/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)

beacon-chain/core/gloas/bid.go

@@ -1,193 +0,0 @@
-package gloas
-
-import (
-	"fmt"
-
-	"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/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
-//
-//	signed_bid = block.body.signed_execution_payload_bid
-//	bid = signed_bid.message
-//	builder_index = bid.builder_index
-//	amount = bid.value
-//	if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	  assert amount == 0
-//	  assert signed_bid.signature == G2_POINT_AT_INFINITY
-//	else:
-//	  assert is_active_builder(state, builder_index)
-//	  assert can_builder_cover_bid(state, builder_index, amount)
-//	  assert verify_execution_payload_bid_signature(state, signed_bid)
-//	assert bid.slot == block.slot
-//	assert bid.parent_block_hash == state.latest_block_hash
-//	assert bid.parent_block_root == block.parent_root
-//	assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//	if amount > 0:
-//	  state.builder_pending_payments[...] = BuilderPendingPayment(weight=0, withdrawal=BuilderPendingWithdrawal(fee_recipient=bid.fee_recipient, amount=amount, builder_index=builder_index))
-//	state.latest_execution_payload_bid = bid
-func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
-	signedBid, err := block.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get signed execution payload bid")
-	}
-
-	wrappedBid, err := blocks.WrappedROSignedExecutionPayloadBid(signedBid)
-	if err != nil {
-		return errors.Wrap(err, "failed to wrap signed bid")
-	}
-
-	bid, err := wrappedBid.Bid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get bid from wrapped bid")
-	}
-
-	builderIndex := bid.BuilderIndex()
-	amount := bid.Value()
-
-	if builderIndex == params.BeaconConfig().BuilderIndexSelfBuild {
-		if amount != 0 {
-			return fmt.Errorf("self-build amount must be zero, got %d", amount)
-		}
-		if wrappedBid.Signature() != common.InfiniteSignature {
-			return errors.New("self-build signature must be point at infinity")
-		}
-	} else {
-		ok, err := st.IsActiveBuilder(builderIndex)
-		if err != nil {
-			return errors.Wrap(err, "builder active check failed")
-		}
-		if !ok {
-			return fmt.Errorf("builder %d is not active", builderIndex)
-		}
-
-		ok, err = st.CanBuilderCoverBid(builderIndex, amount)
-		if err != nil {
-			return errors.Wrap(err, "builder balance check failed")
-		}
-		if !ok {
-			return fmt.Errorf("builder %d cannot cover bid amount %d", builderIndex, amount)
-		}
-
-		if err := validatePayloadBidSignature(st, wrappedBid); err != nil {
-			return errors.Wrap(err, "bid signature validation failed")
-		}
-	}
-
-	if err := validateBidConsistency(st, bid, block); err != nil {
-		return errors.Wrap(err, "bid consistency validation failed")
-	}
-
-	if amount > 0 {
-		feeRecipient := bid.FeeRecipient()
-		pendingPayment := &ethpb.BuilderPendingPayment{
-			Weight: 0,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: feeRecipient[:],
-				Amount:       amount,
-				BuilderIndex: builderIndex,
-			},
-		}
-		slotIndex := params.BeaconConfig().SlotsPerEpoch + (bid.Slot() % params.BeaconConfig().SlotsPerEpoch)
-		if err := st.SetBuilderPendingPayment(slotIndex, pendingPayment); err != nil {
-			return errors.Wrap(err, "failed to set pending payment")
-		}
-	}
-
-	if err := st.SetExecutionPayloadBid(bid); err != nil {
-		return errors.Wrap(err, "failed to cache execution payload bid")
-	}
-
-	return nil
-}
-
-// validateBidConsistency checks that the bid is consistent with the current beacon state.
-func validateBidConsistency(st state.BeaconState, bid interfaces.ROExecutionPayloadBid, block interfaces.ReadOnlyBeaconBlock) error {
-	if bid.Slot() != block.Slot() {
-		return fmt.Errorf("bid slot %d does not match block slot %d", bid.Slot(), block.Slot())
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return errors.Wrap(err, "failed to get latest block hash")
-	}
-	if bid.ParentBlockHash() != latestBlockHash {
-		return fmt.Errorf("bid parent block hash mismatch: got %x, expected %x",
-			bid.ParentBlockHash(), latestBlockHash)
-	}
-
-	if bid.ParentBlockRoot() != block.ParentRoot() {
-		return fmt.Errorf("bid parent block root mismatch: got %x, expected %x",
-			bid.ParentBlockRoot(), block.ParentRoot())
-	}
-
-	randaoMix, err := helpers.RandaoMix(st, slots.ToEpoch(st.Slot()))
-	if err != nil {
-		return errors.Wrap(err, "failed to get randao mix")
-	}
-	if bid.PrevRandao() != [32]byte(randaoMix) {
-		return fmt.Errorf("bid prev randao mismatch: got %x, expected %x", bid.PrevRandao(), randaoMix)
-	}
-
-	return nil
-}
-
-// validatePayloadBidSignature verifies the BLS signature on a signed execution payload bid.
-// It validates that the signature was created by the builder specified in the bid
-// using the appropriate domain for the beacon builder.
-func validatePayloadBidSignature(st state.ReadOnlyBeaconState, signedBid interfaces.ROSignedExecutionPayloadBid) error {
-	bid, err := signedBid.Bid()
-	if err != nil {
-		return errors.Wrap(err, "failed to get bid")
-	}
-
-	pubkey, err := st.BuilderPubkey(bid.BuilderIndex())
-	if err != nil {
-		return errors.Wrap(err, "failed to get builder pubkey")
-	}
-
-	publicKey, err := bls.PublicKeyFromBytes(pubkey[:])
-	if err != nil {
-		return errors.Wrap(err, "invalid builder public key")
-	}
-
-	signatureBytes := signedBid.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return errors.Wrap(err, "invalid signature format")
-	}
-
-	currentEpoch := slots.ToEpoch(bid.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return errors.Wrap(err, "failed to compute signing domain")
-	}
-
-	signingRoot, err := signedBid.SigningRoot(domain)
-	if err != nil {
-		return errors.Wrap(err, "failed to compute signing root")
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return signing.ErrSigFailedToVerify
-	}
-
-	return nil
-}

beacon-chain/core/gloas/bid_test.go

@@ -1,633 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	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/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"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"
-	validatorpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/validator-client"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	fastssz "github.com/prysmaticlabs/fastssz"
-	"google.golang.org/protobuf/proto"
-)
-
-type stubBlockBody struct {
-	signedBid *ethpb.SignedExecutionPayloadBid
-}
-
-func (s stubBlockBody) Version() int                                 { return version.Gloas }
-func (s stubBlockBody) RandaoReveal() [96]byte                       { return [96]byte{} }
-func (s stubBlockBody) Eth1Data() *ethpb.Eth1Data                    { return nil }
-func (s stubBlockBody) Graffiti() [32]byte                           { return [32]byte{} }
-func (s stubBlockBody) ProposerSlashings() []*ethpb.ProposerSlashing { return nil }
-func (s stubBlockBody) AttesterSlashings() []ethpb.AttSlashing       { return nil }
-func (s stubBlockBody) Attestations() []ethpb.Att                    { return nil }
-func (s stubBlockBody) Deposits() []*ethpb.Deposit                   { return nil }
-func (s stubBlockBody) VoluntaryExits() []*ethpb.SignedVoluntaryExit { return nil }
-func (s stubBlockBody) SyncAggregate() (*ethpb.SyncAggregate, error) { return nil, nil }
-func (s stubBlockBody) IsNil() bool                                  { return s.signedBid == nil }
-func (s stubBlockBody) HashTreeRoot() ([32]byte, error)              { return [32]byte{}, nil }
-func (s stubBlockBody) Proto() (proto.Message, error)                { return nil, nil }
-func (s stubBlockBody) Execution() (interfaces.ExecutionData, error) { return nil, nil }
-func (s stubBlockBody) BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error) {
-	return nil, nil
-}
-func (s stubBlockBody) BlobKzgCommitments() ([][]byte, error) { return nil, nil }
-func (s stubBlockBody) ExecutionRequests() (*enginev1.ExecutionRequests, error) {
-	return nil, nil
-}
-func (s stubBlockBody) PayloadAttestations() ([]*ethpb.PayloadAttestation, error) {
-	return nil, nil
-}
-func (s stubBlockBody) SignedExecutionPayloadBid() (*ethpb.SignedExecutionPayloadBid, error) {
-	return s.signedBid, nil
-}
-func (s stubBlockBody) MarshalSSZ() ([]byte, error)         { return nil, nil }
-func (s stubBlockBody) MarshalSSZTo([]byte) ([]byte, error) { return nil, nil }
-func (s stubBlockBody) UnmarshalSSZ([]byte) error           { return nil }
-func (s stubBlockBody) SizeSSZ() int                        { return 0 }
-
-type stubBlock struct {
-	slot       primitives.Slot
-	proposer   primitives.ValidatorIndex
-	parentRoot [32]byte
-	body       stubBlockBody
-	v          int
-}
-
-var (
-	_ interfaces.ReadOnlyBeaconBlockBody = (*stubBlockBody)(nil)
-	_ interfaces.ReadOnlyBeaconBlock     = (*stubBlock)(nil)
-)
-
-func (s stubBlock) Slot() primitives.Slot                    { return s.slot }
-func (s stubBlock) ProposerIndex() primitives.ValidatorIndex { return s.proposer }
-func (s stubBlock) ParentRoot() [32]byte                     { return s.parentRoot }
-func (s stubBlock) StateRoot() [32]byte                      { return [32]byte{} }
-func (s stubBlock) Body() interfaces.ReadOnlyBeaconBlockBody { return s.body }
-func (s stubBlock) IsNil() bool                              { return false }
-func (s stubBlock) IsBlinded() bool                          { return false }
-func (s stubBlock) HashTreeRoot() ([32]byte, error)          { return [32]byte{}, nil }
-func (s stubBlock) Proto() (proto.Message, error)            { return nil, nil }
-func (s stubBlock) MarshalSSZ() ([]byte, error)              { return nil, nil }
-func (s stubBlock) MarshalSSZTo([]byte) ([]byte, error)      { return nil, nil }
-func (s stubBlock) UnmarshalSSZ([]byte) error                { return nil }
-func (s stubBlock) SizeSSZ() int                             { return 0 }
-func (s stubBlock) Version() int                             { return s.v }
-func (s stubBlock) AsSignRequestObject() (validatorpb.SignRequestObject, error) {
-	return nil, nil
-}
-func (s stubBlock) HashTreeRootWith(*fastssz.Hasher) error { return nil }
-
-func buildGloasState(t *testing.T, slot primitives.Slot, proposerIdx primitives.ValidatorIndex, builderIdx primitives.BuilderIndex, balance uint64, randao [32]byte, latestHash [32]byte, builderPubkey [48]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0xAA}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0xBB}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao[:]
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.BuilderWithdrawalPrefixByte
-
-	validatorCount := int(proposerIdx) + 1
-	validators := make([]*ethpb.Validator, validatorCount)
-	balances := make([]uint64, validatorCount)
-	for i := range validatorCount {
-		validators[i] = &ethpb.Validator{
-			PublicKey:                  builderPubkey[:],
-			WithdrawalCredentials:      withdrawalCreds,
-			EffectiveBalance:           balance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
-			ExitEpoch:                  cfg.FarFutureEpoch,
-			WithdrawableEpoch:          cfg.FarFutureEpoch,
-		}
-		balances[i] = balance
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{}}
-	}
-
-	var builders []*ethpb.Builder
-	if builderIdx != params.BeaconConfig().BuilderIndexSelfBuild {
-		builderCount := int(builderIdx) + 1
-		builders = make([]*ethpb.Builder, builderCount)
-		builders[builderCount-1] = &ethpb.Builder{
-			Pubkey:            builderPubkey[:],
-			Version:           []byte{0},
-			ExecutionAddress:  bytes.Repeat([]byte{0x01}, 20),
-			Balance:           primitives.Gwei(balance),
-			DepositEpoch:      0,
-			WithdrawableEpoch: cfg.FarFutureEpoch,
-		}
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x11}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x22}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x22}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                blockRoots,
-		StateRoots:                stateRoots,
-		RandaoMixes:               randaoMixes,
-		Validators:                validators,
-		Balances:                  balances,
-		LatestBlockHash:           latestHash[:],
-		BuilderPendingPayments:    payments,
-		BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
-		Builders:                  builders,
-		FinalizedCheckpoint: &ethpb.Checkpoint{
-			Epoch: 1,
-		},
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return st.(*state_native.BeaconState)
-}
-
-func signBid(t *testing.T, sk common.SecretKey, bid *ethpb.ExecutionPayloadBid, fork *ethpb.Fork, genesisRoot [32]byte) [96]byte {
-	t.Helper()
-	epoch := slots.ToEpoch(primitives.Slot(bid.Slot))
-	domain, err := signing.Domain(fork, epoch, params.BeaconConfig().DomainBeaconBuilder, genesisRoot[:])
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(bid, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(root[:]).Marshal()
-	var out [96]byte
-	copy(out[:], sig)
-	return out
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
-	slot := primitives.Slot(12)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-	pubKey := [48]byte{}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(0), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
-	slot := primitives.Slot(2)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte{}
-	latestHash := [32]byte{1}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, [48]byte{})
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err := ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "self-build amount must be zero", err)
-}
-
-func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
-	slot := primitives.Slot(8)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pub := sk.PublicKey().Marshal()
-	var pubKey [48]byte
-	copy(pubKey[:], pub)
-
-	balance := params.BeaconConfig().MinActivationBalance + 1_000_000
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, balance, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  500_000,
-		ExecutionPayment:       1,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: sig[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx, // not self-build
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-
-	require.NotNil(t, stateProto.LatestExecutionPayloadBid)
-	require.Equal(t, primitives.BuilderIndex(1), stateProto.LatestExecutionPayloadBid.BuilderIndex)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.LatestExecutionPayloadBid.Value)
-}
-
-func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
-	slot := primitives.Slot(4)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x01}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x02}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-	// Make builder inactive by setting withdrawable_epoch.
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	stateProto.Builders[int(builderIdx)].WithdrawableEpoch = 0
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x03}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x04}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "is not active", err)
-}
-
-func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x0A}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x0B}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+10, randao, latestHash, pubKey)
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	// Add pending balances to push below required balance.
-	stateProto.BuilderPendingWithdrawals = []*ethpb.BuilderPendingWithdrawal{
-		{Amount: 15, BuilderIndex: builderIdx},
-	}
-	stateProto.BuilderPendingPayments = []*ethpb.BuilderPendingPayment{
-		{Withdrawal: &ethpb.BuilderPendingWithdrawal{Amount: 20, BuilderIndex: builderIdx}},
-	}
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  25,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "cannot cover bid amount", err)
-}
-
-func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
-	slot := primitives.Slot(6)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	// Use an invalid signature.
-	invalidSig := [96]byte{1}
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: invalidSig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid signature validation failed", err)
-}
-
-func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
-	slot := primitives.Slot(10)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot + 1, // mismatch
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid slot", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
-	slot := primitives.Slot(11)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32), // mismatch
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block hash mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
-	slot := primitives.Slot(12)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	parentRoot := bytes.Repeat([]byte{0x22}, 32)
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        parentRoot,
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bytes.Repeat([]byte{0x99}, 32)), // mismatch
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block root mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
-	slot := primitives.Slot(13)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             bytes.Repeat([]byte{0x01}, 32), // mismatch
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "prev randao mismatch", err)
-}

beacon-chain/core/gloas/payload_attestation.go

@@ -1,253 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"slices"
-
-	"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"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	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/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/hash"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// ProcessPayloadAttestations validates payload attestations in a block body.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_payload_attestation(state: BeaconState, payload_attestation: PayloadAttestation):
-//
-//	data = payload_attestation.data
-//	assert data.beacon_block_root == state.latest_block_header.parent_root
-//	assert data.slot + 1 == state.slot
-//	indexed = get_indexed_payload_attestation(state, data.slot, payload_attestation)
-//	assert is_valid_indexed_payload_attestation(state, indexed)
-func ProcessPayloadAttestations(ctx context.Context, st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
-	atts, err := body.PayloadAttestations()
-	if err != nil {
-		return errors.Wrap(err, "failed to get payload attestations from block body")
-	}
-	if len(atts) == 0 {
-		return nil
-	}
-
-	header := st.LatestBlockHeader()
-
-	for i, att := range atts {
-		data := att.Data
-		if !bytes.Equal(data.BeaconBlockRoot, header.ParentRoot) {
-			return fmt.Errorf("payload attestation %d has wrong parent: got %x want %x", i, data.BeaconBlockRoot, header.ParentRoot)
-		}
-
-		dataSlot, err := data.Slot.SafeAdd(1)
-		if err != nil {
-			return errors.Wrapf(err, "payload attestation %d has invalid slot addition", i)
-		}
-		if dataSlot != st.Slot() {
-			return fmt.Errorf("payload attestation %d has wrong slot: got %d want %d", i, data.Slot+1, st.Slot())
-		}
-
-		indexed, err := indexedPayloadAttestation(ctx, st, att)
-		if err != nil {
-			return errors.Wrapf(err, "payload attestation %d failed to convert to indexed form", i)
-		}
-		if err := validIndexedPayloadAttestation(st, indexed); err != nil {
-			return errors.Wrapf(err, "payload attestation %d failed to verify indexed form", i)
-		}
-	}
-	return nil
-}
-
-// indexedPayloadAttestation converts a payload attestation into its indexed form.
-func indexedPayloadAttestation(ctx context.Context, st state.ReadOnlyBeaconState, att *eth.PayloadAttestation) (*consensus_types.IndexedPayloadAttestation, error) {
-	committee, err := payloadCommittee(ctx, st, att.Data.Slot)
-	if err != nil {
-		return nil, err
-	}
-	indices := make([]primitives.ValidatorIndex, 0, len(committee))
-	for i, idx := range committee {
-		if att.AggregationBits.BitAt(uint64(i)) {
-			indices = append(indices, idx)
-		}
-	}
-	slices.Sort(indices)
-
-	return &consensus_types.IndexedPayloadAttestation{
-		AttestingIndices: indices,
-		Data:             att.Data,
-		Signature:        att.Signature,
-	}, nil
-}
-
-// payloadCommittee returns the payload timeliness committee for a given slot for the state.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// get_ptc(state: BeaconState, slot: Slot) -> Vector[ValidatorIndex, PTC_SIZE]:
-//
-//	epoch = compute_epoch_at_slot(slot)
-//	seed = hash(get_seed(state, epoch, DOMAIN_PTC_ATTESTER) + uint_to_bytes(slot))
-//	indices = []
-//	committees_per_slot = get_committee_count_per_slot(state, epoch)
-//	for i in range(committees_per_slot):
-//	  committee = get_beacon_committee(state, slot, CommitteeIndex(i))
-//	  indices.extend(committee)
-//	return compute_balance_weighted_selection(state, indices, seed, size=PTC_SIZE, shuffle_indices=False)
-func payloadCommittee(ctx context.Context, st state.ReadOnlyBeaconState, slot primitives.Slot) ([]primitives.ValidatorIndex, error) {
-	epoch := slots.ToEpoch(slot)
-	seed, err := ptcSeed(st, epoch, slot)
-	if err != nil {
-		return nil, err
-	}
-
-	activeCount, err := helpers.ActiveValidatorCount(ctx, st, epoch)
-	if err != nil {
-		return nil, err
-	}
-
-	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	out := make([]primitives.ValidatorIndex, 0, activeCount/uint64(params.BeaconConfig().SlotsPerEpoch))
-
-	for i := primitives.CommitteeIndex(0); i < primitives.CommitteeIndex(committeesPerSlot); i++ {
-		committee, err := helpers.BeaconCommitteeFromState(ctx, st, slot, i)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to get beacon committee %d", i)
-		}
-		out = append(out, committee...)
-	}
-
-	return selectByBalance(ctx, st, out, seed, fieldparams.PTCSize)
-}
-
-// ptcSeed computes the seed for the payload timeliness committee.
-func ptcSeed(st state.ReadOnlyBeaconState, epoch primitives.Epoch, slot primitives.Slot) ([32]byte, error) {
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainPTCAttester)
-	if err != nil {
-		return [32]byte{}, err
-	}
-	return hash.Hash(append(seed[:], bytesutil.Bytes8(uint64(slot))...)), nil
-}
-
-// selectByBalance selects a balance-weighted subset of input candidates.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// compute_balance_weighted_selection(state, indices, seed, size, shuffle_indices):
-// Note: shuffle_indices is false for PTC.
-//
-//	total = len(indices); selected = []; i = 0
-//	while len(selected) < size:
-//	  next = i % total
-//	  if shuffle_indices: next = compute_shuffled_index(next, total, seed)
-//	  if compute_balance_weighted_acceptance(state, indices[next], seed, i):
-//	    selected.append(indices[next])
-//	  i += 1
-func selectByBalance(ctx context.Context, st state.ReadOnlyBeaconState, candidates []primitives.ValidatorIndex, seed [32]byte, count uint64) ([]primitives.ValidatorIndex, error) {
-	if len(candidates) == 0 {
-		return nil, errors.New("no candidates for balance weighted selection")
-	}
-
-	hashFunc := hash.CustomSHA256Hasher()
-	// Pre-allocate buffer for hash input: seed (32 bytes) + round counter (8 bytes).
-	var buf [40]byte
-	copy(buf[:], seed[:])
-	maxBalance := params.BeaconConfig().MaxEffectiveBalanceElectra
-
-	selected := make([]primitives.ValidatorIndex, 0, count)
-	total := uint64(len(candidates))
-	for i := uint64(0); uint64(len(selected)) < count; i++ {
-		if ctx.Err() != nil {
-			return nil, ctx.Err()
-		}
-		idx := candidates[i%total]
-		ok, err := acceptByBalance(st, idx, buf[:], hashFunc, maxBalance, i)
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			selected = append(selected, idx)
-		}
-	}
-	return selected, nil
-}
-
-// acceptByBalance determines if a validator is accepted based on its effective balance.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// compute_balance_weighted_acceptance(state, index, seed, i):
-//
-//	MAX_RANDOM_VALUE = 2**16 - 1
-//	random_bytes = hash(seed + uint_to_bytes(i // 16))
-//	offset = i % 16 * 2
-//	random_value = bytes_to_uint64(random_bytes[offset:offset+2])
-//	effective_balance = state.validators[index].effective_balance
-//	return effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value
-func acceptByBalance(st state.ReadOnlyBeaconState, idx primitives.ValidatorIndex, seedBuf []byte, hashFunc func([]byte) [32]byte, maxBalance uint64, round uint64) (bool, error) {
-	// Reuse the seed buffer by overwriting the last 8 bytes with the round counter.
-	binary.LittleEndian.PutUint64(seedBuf[len(seedBuf)-8:], round/16)
-	random := hashFunc(seedBuf)
-	offset := (round % 16) * 2
-	randomValue := uint64(binary.LittleEndian.Uint16(random[offset : offset+2])) // 16-bit draw per spec
-
-	val, err := st.ValidatorAtIndex(idx)
-	if err != nil {
-		return false, errors.Wrapf(err, "validator %d", idx)
-	}
-
-	return val.EffectiveBalance*fieldparams.MaxRandomValueElectra >= maxBalance*randomValue, nil
-}
-
-// validIndexedPayloadAttestation verifies the signature of an indexed payload attestation.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// is_valid_indexed_payload_attestation(state: BeaconState, indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
-//
-//	indices = indexed_payload_attestation.attesting_indices
-//	return len(indices) > 0 and indices == sorted(indices) and
-//	  bls.FastAggregateVerify(
-//	    [state.validators[i].pubkey for i in indices],
-//	    compute_signing_root(indexed_payload_attestation.data, get_domain(state, DOMAIN_PTC_ATTESTER, compute_epoch_at_slot(attestation.data.slot)),
-//	    indexed_payload_attestation.signature,
-//	  )
-func validIndexedPayloadAttestation(st state.ReadOnlyBeaconState, att *consensus_types.IndexedPayloadAttestation) error {
-	indices := att.AttestingIndices
-	if len(indices) == 0 || !slices.IsSorted(indices) {
-		return errors.New("attesting indices empty or unsorted")
-	}
-
-	pubkeys := make([]bls.PublicKey, len(indices))
-	for i, idx := range indices {
-		val, err := st.ValidatorAtIndexReadOnly(idx)
-		if err != nil {
-			return errors.Wrapf(err, "validator %d", idx)
-		}
-		keyBytes := val.PublicKey()
-		key, err := bls.PublicKeyFromBytes(keyBytes[:])
-		if err != nil {
-			return errors.Wrapf(err, "pubkey %d", idx)
-		}
-		pubkeys[i] = key
-	}
-
-	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(att.Data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	root, err := signing.ComputeSigningRoot(att.Data, domain)
-	if err != nil {
-		return err
-	}
-	sig, err := bls.SignatureFromBytes(att.Signature)
-	if err != nil {
-		return err
-	}
-
-	if !sig.FastAggregateVerify(pubkeys, root) {
-		return errors.New("invalid signature")
-	}
-	return nil
-}

beacon-chain/core/gloas/payload_attestation_test.go

@@ -1,305 +0,0 @@
-package gloas_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/go-bitfield"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"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/crypto/bls/common"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	testutil "github.com/OffchainLabs/prysm/v7/testing/util"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func TestProcessPayloadAttestations_WrongParent(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(2))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	att := &eth.PayloadAttestation{
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: bytes.Repeat([]byte{0xbb}, 32),
-			Slot:            1,
-		},
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "wrong parent", err)
-}
-
-func TestProcessPayloadAttestations_WrongSlot(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(3))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	att := &eth.PayloadAttestation{
-		Data: &eth.PayloadAttestationData{
-			BeaconBlockRoot: parentRoot,
-			Slot:            1,
-		},
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "wrong slot", err)
-}
-
-func TestProcessPayloadAttestations_InvalidSignature(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk2}),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "invalid signature", err)
-}
-
-func TestProcessPayloadAttestations_EmptyAggregationBits(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	require.NoError(t, st.SetSlot(2))
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: bitfield.NewBitvector512(),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "attesting indices empty or unsorted", err)
-}
-
-func TestProcessPayloadAttestations_HappyPath(t *testing.T) {
-	helpers.ClearCache()
-	setupTestConfig(t)
-
-	sk1, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	aggBits := bitfield.NewBitvector512()
-	aggBits.SetBitAt(0, true)
-	aggBits.SetBitAt(1, true)
-
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: aggBits,
-		Signature:       signAttestation(t, st, attData, []common.SecretKey{sk1, sk2}),
-	}
-	body := buildBody(t, att)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.NoError(t, err)
-}
-
-func TestProcessPayloadAttestations_MultipleAttestations(t *testing.T) {
-	helpers.ClearCache()
-	setupTestConfig(t)
-
-	sk1, pk1 := newKey(t)
-	sk2, pk2 := newKey(t)
-	vals := []*eth.Validator{activeValidator(pk1), activeValidator(pk2)}
-
-	st := newTestState(t, vals, 2)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData1 := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-	attData2 := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            1,
-	}
-
-	att1 := &eth.PayloadAttestation{
-		Data:            attData1,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       signAttestation(t, st, attData1, []common.SecretKey{sk1}),
-	}
-	att2 := &eth.PayloadAttestation{
-		Data:            attData2,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 1),
-		Signature:       signAttestation(t, st, attData2, []common.SecretKey{sk2}),
-	}
-
-	body := buildBody(t, att1, att2)
-
-	err := gloas.ProcessPayloadAttestations(t.Context(), st, body)
-	require.NoError(t, err)
-}
-
-func TestProcessPayloadAttestations_IndexedVerificationError(t *testing.T) {
-	setupTestConfig(t)
-
-	_, pk := newKey(t)
-	st := newTestState(t, []*eth.Validator{activeValidator(pk)}, 1)
-	parentRoot := bytes.Repeat([]byte{0xaa}, 32)
-	require.NoError(t, st.SetLatestBlockHeader(&eth.BeaconBlockHeader{ParentRoot: parentRoot}))
-
-	attData := &eth.PayloadAttestationData{
-		BeaconBlockRoot: parentRoot,
-		Slot:            0,
-	}
-	att := &eth.PayloadAttestation{
-		Data:            attData,
-		AggregationBits: setBits(bitfield.NewBitvector512(), 0),
-		Signature:       make([]byte, 96),
-	}
-	body := buildBody(t, att)
-
-	errState := &validatorLookupErrState{
-		BeaconState: st,
-		errIndex:    0,
-	}
-	err := gloas.ProcessPayloadAttestations(t.Context(), errState, body)
-	require.ErrorContains(t, "failed to verify indexed form", err)
-	require.ErrorContains(t, "validator 0", err)
-}
-
-func newTestState(t *testing.T, vals []*eth.Validator, slot primitives.Slot) state.BeaconState {
-	st, err := testutil.NewBeaconState()
-	require.NoError(t, err)
-	for _, v := range vals {
-		require.NoError(t, st.AppendValidator(v))
-		require.NoError(t, st.AppendBalance(v.EffectiveBalance))
-	}
-	require.NoError(t, st.SetSlot(slot))
-	require.NoError(t, helpers.UpdateCommitteeCache(t.Context(), st, slots.ToEpoch(slot)))
-	return st
-}
-
-func setupTestConfig(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.SlotsPerEpoch = 1
-	cfg.MaxEffectiveBalanceElectra = cfg.MaxEffectiveBalance
-	params.OverrideBeaconConfig(cfg)
-}
-
-func buildBody(t *testing.T, atts ...*eth.PayloadAttestation) interfaces.ReadOnlyBeaconBlockBody {
-	body := &eth.BeaconBlockBodyGloas{
-		PayloadAttestations:   atts,
-		RandaoReveal:          make([]byte, 96),
-		Eth1Data:              &eth.Eth1Data{},
-		Graffiti:              make([]byte, 32),
-		ProposerSlashings:     []*eth.ProposerSlashing{},
-		AttesterSlashings:     []*eth.AttesterSlashingElectra{},
-		Attestations:          []*eth.AttestationElectra{},
-		Deposits:              []*eth.Deposit{},
-		VoluntaryExits:        []*eth.SignedVoluntaryExit{},
-		SyncAggregate:         &eth.SyncAggregate{},
-		BlsToExecutionChanges: []*eth.SignedBLSToExecutionChange{},
-	}
-	wrapped, err := blocks.NewBeaconBlockBody(body)
-	require.NoError(t, err)
-	return wrapped
-}
-
-func setBits(bits bitfield.Bitvector512, idx uint64) bitfield.Bitvector512 {
-	bits.SetBitAt(idx, true)
-	return bits
-}
-
-func activeValidator(pub []byte) *eth.Validator {
-	return &eth.Validator{
-		PublicKey:                  pub,
-		EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-		WithdrawalCredentials:      make([]byte, 32),
-		ActivationEligibilityEpoch: 0,
-		ActivationEpoch:            0,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-	}
-}
-
-func newKey(t *testing.T) (common.SecretKey, []byte) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	return sk, sk.PublicKey().Marshal()
-}
-
-func signAttestation(t *testing.T, st state.ReadOnlyBeaconState, data *eth.PayloadAttestationData, sks []common.SecretKey) []byte {
-	domain, err := signing.Domain(st.Fork(), slots.ToEpoch(data.Slot), params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(data, domain)
-	require.NoError(t, err)
-
-	sigs := make([]common.Signature, len(sks))
-	for i, sk := range sks {
-		sigs[i] = sk.Sign(root[:])
-	}
-	agg := bls.AggregateSignatures(sigs)
-	return agg.Marshal()
-}
-
-type validatorLookupErrState struct {
-	state.BeaconState
-	errIndex primitives.ValidatorIndex
-}
-
-// ValidatorAtIndexReadOnly is overridden to simulate a missing validator lookup.
-func (s *validatorLookupErrState) ValidatorAtIndexReadOnly(idx primitives.ValidatorIndex) (state.ReadOnlyValidator, error) {
-	if idx == s.errIndex {
-		return nil, state.ErrNilValidatorsInState
-	}
-	return s.BeaconState.ValidatorAtIndexReadOnly(idx)
-}

beacon-chain/core/gloas/pending_payment.go

@@ -1,76 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-)
-
-// ProcessBuilderPendingPayments processes the builder pending payments from the previous epoch.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def process_builder_pending_payments(state: BeaconState) -> None:
-//
-//	quorum = get_builder_payment_quorum_threshold(state)
-//	for payment in state.builder_pending_payments[:SLOTS_PER_EPOCH]:
-//	    if payment.weight >= quorum:
-//	        state.builder_pending_withdrawals.append(payment.withdrawal)
-//
-//	old_payments = state.builder_pending_payments[SLOTS_PER_EPOCH:]
-//	new_payments = [BuilderPendingPayment() for _ in range(SLOTS_PER_EPOCH)]
-//	state.builder_pending_payments = old_payments + new_payments
-func ProcessBuilderPendingPayments(state state.BeaconState) error {
-	quorum, err := builderQuorumThreshold(state)
-	if err != nil {
-		return errors.Wrap(err, "could not compute builder payment quorum threshold")
-	}
-
-	payments, err := state.BuilderPendingPayments()
-	if err != nil {
-		return errors.Wrap(err, "could not get builder pending payments")
-	}
-
-	slotsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch)
-	var withdrawals []*ethpb.BuilderPendingWithdrawal
-	for _, payment := range payments[:slotsPerEpoch] {
-		if quorum > payment.Weight {
-			continue
-		}
-		withdrawals = append(withdrawals, payment.Withdrawal)
-	}
-
-	if err := state.AppendBuilderPendingWithdrawals(withdrawals); err != nil {
-		return errors.Wrap(err, "could not append builder pending withdrawals")
-	}
-
-	if err := state.RotateBuilderPendingPayments(); err != nil {
-		return errors.Wrap(err, "could not rotate builder pending payments")
-	}
-
-	return nil
-}
-
-// builderQuorumThreshold calculates the quorum threshold for builder payments.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// def get_builder_payment_quorum_threshold(state: BeaconState) -> uint64:
-//
-//	per_slot_balance = get_total_active_balance(state) // SLOTS_PER_EPOCH
-//	quorum = per_slot_balance * BUILDER_PAYMENT_THRESHOLD_NUMERATOR
-//	return uint64(quorum // BUILDER_PAYMENT_THRESHOLD_DENOMINATOR)
-func builderQuorumThreshold(state state.ReadOnlyBeaconState) (primitives.Gwei, error) {
-	activeBalance, err := helpers.TotalActiveBalance(state)
-	if err != nil {
-		return 0, errors.Wrap(err, "could not get total active balance")
-	}
-
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := uint64(cfg.SlotsPerEpoch)
-	numerator := cfg.BuilderPaymentThresholdNumerator
-	denominator := cfg.BuilderPaymentThresholdDenominator
-
-	activeBalancePerSlot := activeBalance / slotsPerEpoch
-	quorum := (activeBalancePerSlot * numerator) / denominator
-	return primitives.Gwei(quorum), nil
-}

beacon-chain/core/gloas/pending_payment_test.go

@@ -1,119 +0,0 @@
-package gloas
-
-import (
-	"slices"
-	"testing"
-
-	"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"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestBuilderQuorumThreshold(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&ethpb.BeaconStateGloas{Validators: validators})
-	require.NoError(t, err)
-
-	got, err := builderQuorumThreshold(st)
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	want := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	require.Equal(t, primitives.Gwei(want), got)
-}
-
-func TestProcessBuilderPendingPayments(t *testing.T) {
-	helpers.ClearCache()
-	cfg := params.BeaconConfig()
-
-	buildPayments := func(weights ...primitives.Gwei) []*ethpb.BuilderPendingPayment {
-		p := make([]*ethpb.BuilderPendingPayment, 2*int(cfg.SlotsPerEpoch))
-		for i := range p {
-			p[i] = &ethpb.BuilderPendingPayment{
-				Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)},
-			}
-		}
-		for i, w := range weights {
-			p[i].Weight = w
-			p[i].Withdrawal.Amount = 1
-		}
-		return p
-	}
-
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-		{EffectiveBalance: cfg.MaxEffectiveBalance, ActivationEpoch: 0, ExitEpoch: 1},
-	}
-	pbSt, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{Validators: validators})
-	require.NoError(t, err)
-
-	total := uint64(len(validators)) * cfg.MaxEffectiveBalance
-	perSlot := total / uint64(cfg.SlotsPerEpoch)
-	quorum := (perSlot * cfg.BuilderPaymentThresholdNumerator) / cfg.BuilderPaymentThresholdDenominator
-	slotsPerEpoch := int(cfg.SlotsPerEpoch)
-
-	t.Run("append qualifying withdrawals", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum+1), primitives.Gwei(quorum+2))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 2, len(st.withdrawals))
-		require.Equal(t, payments[0].Withdrawal, st.withdrawals[0])
-		require.Equal(t, payments[1].Withdrawal, st.withdrawals[1])
-
-		require.Equal(t, 2*slotsPerEpoch, len(st.payments))
-		for i := slotsPerEpoch; i < 2*slotsPerEpoch; i++ {
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Weight)
-			require.Equal(t, primitives.Gwei(0), st.payments[i].Withdrawal.Amount)
-			require.Equal(t, 20, len(st.payments[i].Withdrawal.FeeRecipient))
-		}
-	})
-
-	t.Run("no withdrawals when below quorum", func(t *testing.T) {
-		payments := buildPayments(primitives.Gwei(quorum - 1))
-		st := &testProcessState{BeaconState: pbSt, payments: payments}
-
-		require.NoError(t, ProcessBuilderPendingPayments(st))
-		require.Equal(t, 0, len(st.withdrawals))
-	})
-}
-
-type testProcessState struct {
-	state.BeaconState
-	payments    []*ethpb.BuilderPendingPayment
-	withdrawals []*ethpb.BuilderPendingWithdrawal
-}
-
-func (t *testProcessState) BuilderPendingPayments() ([]*ethpb.BuilderPendingPayment, error) {
-	return t.payments, nil
-}
-
-func (t *testProcessState) AppendBuilderPendingWithdrawals(withdrawals []*ethpb.BuilderPendingWithdrawal) error {
-	t.withdrawals = append(t.withdrawals, withdrawals...)
-	return nil
-}
-
-func (t *testProcessState) RotateBuilderPendingPayments() error {
-	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
-	rotated := slices.Clone(t.payments[slotsPerEpoch:])
-	for range slotsPerEpoch {
-		rotated = append(rotated, &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		})
-	}
-	t.payments = rotated
-	return nil
-}

beacon-chain/core/gloas/proposer_slashing.go

@@ -1,43 +0,0 @@
-package gloas
-
-import (
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-)
-
-// RemoveBuilderPendingPayment removes the pending builder payment for the proposal slot.
-// Spec v1.7.0 (pseudocode):
-//
-//	slot = header_1.slot
-//	proposal_epoch = compute_epoch_at_slot(slot)
-//	if proposal_epoch == get_current_epoch(state):
-//	  payment_index = SLOTS_PER_EPOCH + slot % SLOTS_PER_EPOCH
-//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
-//	elif proposal_epoch == get_previous_epoch(state):
-//	  payment_index = slot % SLOTS_PER_EPOCH
-//	  state.builder_pending_payments[payment_index] = BuilderPendingPayment()
-func RemoveBuilderPendingPayment(st state.BeaconState, header *eth.BeaconBlockHeader) error {
-	proposalEpoch := slots.ToEpoch(header.Slot)
-	currentEpoch := time.CurrentEpoch(st)
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-
-	var paymentIndex primitives.Slot
-	if proposalEpoch == currentEpoch {
-		paymentIndex = slotsPerEpoch + header.Slot%slotsPerEpoch
-	} else if proposalEpoch+1 == currentEpoch {
-		paymentIndex = header.Slot % slotsPerEpoch
-	} else {
-		return nil
-	}
-
-	if err := st.ClearBuilderPendingPayment(paymentIndex); err != nil {
-		return errors.Wrap(err, "could not clear builder pending payment")
-	}
-
-	return nil
-}

beacon-chain/core/gloas/proposer_slashing_test.go

@@ -1,112 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	"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"
-	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestRemoveBuilderPendingPayment_CurrentEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*2 + 1
-	headerSlot := slotsPerEpoch * 2
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(slotsPerEpoch + headerSlot%slotsPerEpoch)
-
-	setPendingPayment(t, st, paymentIndex, 123)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	got := getPendingPayment(t, st, paymentIndex)
-	require.NotNil(t, got.Withdrawal)
-	require.DeepEqual(t, make([]byte, 20), got.Withdrawal.FeeRecipient)
-	require.Equal(t, uint64(0), uint64(got.Withdrawal.Amount))
-}
-
-func TestRemoveBuilderPendingPayment_PreviousEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*2 + 1
-	headerSlot := slotsPerEpoch + 7
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(headerSlot % slotsPerEpoch)
-
-	setPendingPayment(t, st, paymentIndex, 456)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	got := getPendingPayment(t, st, paymentIndex)
-	require.NotNil(t, got.Withdrawal)
-	require.DeepEqual(t, make([]byte, 20), got.Withdrawal.FeeRecipient)
-	require.Equal(t, uint64(0), uint64(got.Withdrawal.Amount))
-}
-
-func TestRemoveBuilderPendingPayment_OlderThanTwoEpoch(t *testing.T) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	stateSlot := slotsPerEpoch*4 + 1 // current epoch far ahead
-	headerSlot := slotsPerEpoch * 2  // two epochs behind
-
-	st := newGloasStateWithPayments(t, stateSlot)
-	paymentIndex := int(headerSlot % slotsPerEpoch)
-
-	original := getPendingPayment(t, st, paymentIndex)
-
-	err := RemoveBuilderPendingPayment(st, &eth.BeaconBlockHeader{Slot: headerSlot})
-	require.NoError(t, err)
-
-	after := getPendingPayment(t, st, paymentIndex)
-	require.DeepEqual(t, original.Withdrawal.FeeRecipient, after.Withdrawal.FeeRecipient)
-	require.Equal(t, original.Withdrawal.Amount, after.Withdrawal.Amount)
-}
-
-func newGloasStateWithPayments(t *testing.T, slot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	paymentCount := int(slotsPerEpoch * 2)
-	payments := make([]*eth.BuilderPendingPayment, paymentCount)
-	for i := range payments {
-		payments[i] = &eth.BuilderPendingPayment{
-			Withdrawal: &eth.BuilderPendingWithdrawal{
-				FeeRecipient: bytes.Repeat([]byte{0x01}, 20),
-				Amount:       1,
-			},
-		}
-	}
-
-	st, err := state_native.InitializeFromProtoUnsafeGloas(&eth.BeaconStateGloas{
-		Slot:                   slot,
-		BuilderPendingPayments: payments,
-	})
-	require.NoError(t, err)
-	return st
-}
-
-func setPendingPayment(t *testing.T, st state.BeaconState, index int, amount uint64) {
-	t.Helper()
-
-	payment := &eth.BuilderPendingPayment{
-		Withdrawal: &eth.BuilderPendingWithdrawal{
-			FeeRecipient: bytes.Repeat([]byte{0x02}, 20),
-			Amount:       primitives.Gwei(amount),
-		},
-	}
-	require.NoError(t, st.SetBuilderPendingPayment(primitives.Slot(index), payment))
-}
-
-func getPendingPayment(t *testing.T, st state.BeaconState, index int) *eth.BuilderPendingPayment {
-	t.Helper()
-
-	stateProto := st.ToProtoUnsafe().(*eth.BeaconStateGloas)
-
-	return stateProto.BuilderPendingPayments[index]
-}

beacon-chain/core/helpers/BUILD.bazel

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

beacon-chain/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",
@@ -72,7 +71,6 @@ go_test(
         "state_test.go",
         "trailing_slot_state_cache_test.go",
         "transition_fuzz_test.go",
-        "transition_gloas_test.go",
         "transition_no_verify_sig_test.go",
         "transition_test.go",
     ],
@@ -108,7 +106,6 @@ go_test(
         "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
-        "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto: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/core/transition/transition.go

@@ -142,18 +142,6 @@ func ProcessSlot(ctx context.Context, state state.BeaconState) (state.BeaconStat
 	); err != nil {
 		return nil, err
 	}
-
-	// Spec v1.6.1 (pseudocode):
-	// # [New in Gloas:EIP7732]
-	// # Unset the next payload availability
-	// state.execution_payload_availability[(state.slot + 1) % SLOTS_PER_HISTORICAL_ROOT] = 0b0
-	if state.Version() >= version.Gloas {
-		index := uint64((state.Slot() + 1) % params.BeaconConfig().SlotsPerHistoricalRoot)
-		if err := state.UpdateExecutionPayloadAvailabilityAtIndex(index, 0x0); err != nil {
-			return nil, err
-		}
-	}
-
 	return state, nil
 }
 

beacon-chain/core/transition/transition_gloas_test.go

@@ -1,141 +0,0 @@
-package transition
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/stretchr/testify/require"
-)
-
-func TestProcessSlot_GloasClearsNextPayloadAvailability(t *testing.T) {
-	slot := primitives.Slot(10)
-	cfg := params.BeaconConfig()
-	nextIdx := uint64((slot + 1) % cfg.SlotsPerHistoricalRoot)
-	byteIdx := nextIdx / 8
-	bitMask := byte(1 << (nextIdx % 8))
-	availability := bytes.Repeat([]byte{0xFF}, int(cfg.SlotsPerHistoricalRoot/8))
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	require.NoError(t, err)
-
-	post := st.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, byte(0xFF)&^bitMask, post.ExecutionPayloadAvailability[byteIdx])
-}
-
-func TestProcessSlot_GloasClearsNextPayloadAvailability_Wrap(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slot := primitives.Slot(cfg.SlotsPerHistoricalRoot - 1)
-	availability := bytes.Repeat([]byte{0xFF}, int(cfg.SlotsPerHistoricalRoot/8))
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	require.NoError(t, err)
-
-	post := st.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, byte(0xFE), post.ExecutionPayloadAvailability[0])
-}
-
-func TestProcessSlot_GloasAvailabilityUpdateError(t *testing.T) {
-	slot := primitives.Slot(7)
-	availability := make([]byte, 1)
-	st := newGloasState(t, slot, availability)
-
-	_, err := ProcessSlot(context.Background(), st)
-	cfg := params.BeaconConfig()
-	idx := uint64((slot + 1) % cfg.SlotsPerHistoricalRoot)
-	byteIdx := idx / 8
-	require.EqualError(t, err, fmt.Sprintf(
-		"bit index %d (byte index %d) out of range for execution payload availability length %d",
-		idx, byteIdx, len(availability),
-	))
-}
-
-func newGloasState(t *testing.T, slot primitives.Slot, availability []byte) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	protoState := &ethpb.BeaconStateGloas{
-		Slot:                         slot,
-		LatestBlockHeader:            testBeaconBlockHeader(),
-		BlockRoots:                   make([][]byte, cfg.SlotsPerHistoricalRoot),
-		StateRoots:                   make([][]byte, cfg.SlotsPerHistoricalRoot),
-		RandaoMixes:                  make([][]byte, fieldparams.RandaoMixesLength),
-		ExecutionPayloadAvailability: availability,
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, int(cfg.SlotsPerEpoch*2)),
-		LatestExecutionPayloadBid: &ethpb.ExecutionPayloadBid{
-			ParentBlockHash:        make([]byte, 32),
-			ParentBlockRoot:        make([]byte, 32),
-			BlockHash:              make([]byte, 32),
-			PrevRandao:             make([]byte, 32),
-			FeeRecipient:           make([]byte, 20),
-			BlobKzgCommitmentsRoot: make([]byte, 32),
-		},
-		Eth1Data: &ethpb.Eth1Data{
-			DepositRoot: make([]byte, 32),
-			BlockHash:   make([]byte, 32),
-		},
-		PreviousEpochParticipation:  []byte{},
-		CurrentEpochParticipation:   []byte{},
-		JustificationBits:           []byte{0},
-		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentJustifiedCheckpoint:  &ethpb.Checkpoint{Root: make([]byte, 32)},
-		FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
-		CurrentSyncCommittee:        &ethpb.SyncCommittee{},
-		NextSyncCommittee:           &ethpb.SyncCommittee{},
-	}
-
-	for i := range protoState.BlockRoots {
-		protoState.BlockRoots[i] = make([]byte, 32)
-	}
-	for i := range protoState.StateRoots {
-		protoState.StateRoots[i] = make([]byte, 32)
-	}
-	for i := range protoState.RandaoMixes {
-		protoState.RandaoMixes[i] = make([]byte, 32)
-	}
-
-	for i := range protoState.BuilderPendingPayments {
-		protoState.BuilderPendingPayments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-
-	pubkeys := make([][]byte, cfg.SyncCommitteeSize)
-	for i := range pubkeys {
-		pubkeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
-	}
-	aggPubkey := make([]byte, fieldparams.BLSPubkeyLength)
-	protoState.CurrentSyncCommittee = &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: aggPubkey,
-	}
-	protoState.NextSyncCommittee = &ethpb.SyncCommittee{
-		Pubkeys:         pubkeys,
-		AggregatePubkey: aggPubkey,
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(protoState)
-	require.NoError(t, err)
-	require.Equal(t, version.Gloas, st.Version())
-	return st
-}
-
-func testBeaconBlockHeader() *ethpb.BeaconBlockHeader {
-	return &ethpb.BeaconBlockHeader{
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}
-}

beacon-chain/db/filesystem/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "cache.go",
         "data_column.go",
         "data_column_cache.go",
+        "doc.go",
         "iteration.go",
         "layout.go",
         "layout_by_epoch.go",
@@ -14,8 +15,6 @@ go_library(
         "log.go",
         "metrics.go",
         "mock.go",
-        "proof.go",
-        "proof_cache.go",
         "pruner.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/db/filesystem",
@@ -31,7 +30,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/logging:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

beacon-chain/db/filesystem/data_column.go

@@ -512,11 +512,6 @@ func (dcs *DataColumnStorage) Get(root [fieldparams.RootLength]byte, indices []u
 	if err != nil {
 		return nil, errors.Wrap(err, "data column sidecars file path open")
 	}
-	defer func() {
-		if closeErr := file.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing file during Get")
-		}
-	}()
 
 	// Read file metadata.
 	metadata, err := dcs.metadata(file)

beacon-chain/db/filesystem/doc.go

@@ -0,0 +1,104 @@
+package filesystem
+
+// nolint:dupword
+/*
+Data column sidecars storage documentation
+==========================================
+
+File organisation
+-----------------
+- The first byte represents the version of the file structure (up to 0xff = 255).
+  We set it to 0x01.
+  Note: This is not strictly needed, but it will help a lot if, in the future,
+        we want to modify the file structure.
+- The next 4 bytes represents the size of a SSZ encoded data column sidecar.
+  (See the `Computation of the maximum size of a DataColumnSidecar` section to a description
+  of how this value is computed).
+- The next 128 bytes represent the index in the file of a given column.
+  The first bit of each byte in the index is set to 0 if there is no data column,
+  and set to 1 if there is a data column.
+  The remaining 7 bits (from 0 to 127) represent the index of the data column.
+  This sentinel bit is needed to distinguish between the column with index 0 and no column.
+  Example: If the column with index 5 is in the 3th position in the file, then indices[5] = 0x80 + 0x03 = 0x83.
+- The rest of the file is a repeat of the SSZ encoded data column sidecars.
+
+
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                Byte offset               |                                     Description                                    |
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                                        0 | version (1 byte) | sszEncodedDataColumnSidecarSize (4 bytes) | indices (128 bytes) |
+|133 +   0*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   1*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   2*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|                  ...                     |                                 ...                                                |
+|133 + 127*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|------------------------------------------|------------------------------------------------------------------------------------|
+
+Each file is named after the block root where the data columns were data columns are committed to.
+Example: `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
+
+Database organisation
+---------------------
+SSZ encoded data column sidecars are stored following the `by-epoch` layout.
+- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by the 4096.
+- The second layer is a directory corresponding to the epoch.
+- Then all files are stored in the epoch directory.
+
+Example:
+data-columns
+├── 0
+│   ├── 3638
+│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
+│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
+│   │   ├── ...
+│   │   ├── 0xeb78e2b2350a71c640f1e96fea9e42f38e65705ab7e6e100c8bc9c589f2c5f2b.sszs
+│   │   └── 0xeb7ee68da988fd20d773d45aad01dd62527734367a146e2b048715bd68a4e370.sszs
+│   └── 3639
+│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
+│       ├── 0x1bf5edff6b6ba2b65b1db325ff3312bbb57da461ef2ae651bd741af851aada3a.sszs
+│       ├── ...
+│       ├── 0xa156a527e631f858fee79fab7ef1fde3f6117a2e1201d47c09fbab0c6780c937.sszs
+│       └── 0xcd80bc535ddc467dea1d19e0c39c1160875ccd1989061bcd8ce206e3c1261c87.sszs
+└── 1
+    ├── 4096
+    │   ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
+    │   ├── 0x11f420928d8de41c50e735caab0369996824a5299c5f054e097965855925697d.sszs
+    │   ├── ...
+    │   ├── 0xbe91fc782877ed400d95c02c61aebfdd592635d11f8e64c94b46abd84f45c967.sszs
+    │   └── 0xf246189f078f02d30173ff74605cf31c9e65b5e463275ebdbeb40476638135ff.sszs
+    └── 4097
+        ├── 0x454d000674793c479e90504c0fe9827b50bb176ae022dab4e37d6a21471ab570.sszs
+        ├── 0xac5eb7437d7190c48cfa863e3c45f96a7f8af371d47ac12ccda07129a06af763.sszs
+        ├── ...
+        ├── 0xb7df30561d9d92ab5fafdd96bca8b44526497c8debf0fc425c7a0770b2abeb83.sszs
+        └── 0xc1dd0b1ae847b6ec62303a36d08c6a4a2e9e3ec4be3ff70551972a0ee3de9c14.sszs
+
+Computation of the maximum size of a DataColumnSidecar
+------------------------------------------------------
+https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#datacolumnsidecar
+
+
+class DataColumnSidecar(Container):
+    index: ColumnIndex  # Index of column in extended matrix
+    column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    signed_block_header: SignedBeaconBlockHeader
+    kzg_commitments_inclusion_proof: Vector[Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH]
+
+
+- index: 2 bytes (ColumnIndex)
+- `column`: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 64 (FIELD_ELEMENTS_PER_CELL) * 32 bytes (BYTES_PER_FIELD_ELEMENT) = 8,388,608 bytes
+- kzg_commitments: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGCommitment) = 196,608 bytes
+- kzg_proofs: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGProof) = 196,608 bytes
+- signed_block_header: 2 bytes (Slot) + 2 bytes (ValidatorIndex) + 3 * 2 bytes (Root) + 96 bytes (BLSSignature) = 106 bytes
+- kzg_commitments_inclusion_proof: 4 (KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH) * 32 bytes = 128 bytes
+
+TOTAL: 8,782,060 bytes = 70,256,480 bits
+log(70,256,480) / log(2) ~= 26.07
+
+==> 32 bits (4 bytes) are enough to store the maximum size of a data column sidecar.
+
+The maximum size of an SSZ encoded data column can be 2**32 bits = 536,879,912 bytes,
+which left a room of 536,879,912 bytes - 8,782,060 bytes ~= 503 mega bytes to store the extra data needed by SSZ encoding (which is more than enough.)
+*/

beacon-chain/db/filesystem/doc.md

@@ -1,197 +0,0 @@
-# Filesystem storage documentation
-
-This document describes the file formats and database organization for storing data column sidecars and execution proofs.
-
----
-
-# Data column sidecars
-
-## File organisation
-
-- The first byte represents the version of the file structure (up to `0xff = 255`).
-  We set it to `0x01`.
-
-  _(Note: This is not strictly needed, but it will help a lot if, in the future, we want to modify the file structure.)_
-
-- The next 4 bytes represents the size of a SSZ encoded data column sidecar.
-  (See the [Computation of the maximum size of a DataColumnSidecar](#computation-of-the-maximum-size-of-a-datacolumnsidecar) section for a description
-  of how this value is computed).
-
-- The next 128 bytes represent the index in the file of a given column.
-  The first bit of each byte in the index is set to 0 if there is no data column,
-  and set to 1 if there is a data column.
-  The remaining 7 bits (from 0 to 127) represent the index of the data column.
-  This sentinel bit is needed to distinguish between the column with index 0 and no column.
-
-  **Example:** If the column with index 5 is in the 3rd position in the file, then `indices[5] = 0x80 + 0x03 = 0x83`.
-
-- The rest of the file is a repeat of the SSZ encoded data column sidecars.
-
-### File layout
-
-| Byte offset | Description |
-|-------------|-------------|
-| `0` | `version (1 byte) \| sszEncodedDataColumnSidecarSize (4 bytes) \| indices (128 bytes)` |
-| `133 + 0×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| `133 + 1×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| `133 + 2×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-| ... | ... |
-| `133 + 127×sszEncodedDataColumnSidecarSize` | `sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)` |
-
-Each file is named after the block root where the data columns are committed to.
-
-**Example:** `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
-
-## Database organisation
-
-SSZ encoded data column sidecars are stored following the `by-epoch` layout.
-
-- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by 4096.
-- The second layer is a directory corresponding to the epoch.
-- Then all files are stored in the epoch directory.
-
-### Example directory structure
-
-```
-data-columns
-├── 0
-│   ├── 3638
-│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
-│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
-│   │   ├── ...
-│   │   ├── 0xeb78e2b2350a71c640f1e96fea9e42f38e65705ab7e6e100c8bc9c589f2c5f2b.sszs
-│   │   └── 0xeb7ee68da988fd20d773d45aad01dd62527734367a146e2b048715bd68a4e370.sszs
-│   └── 3639
-│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
-│       ├── 0x1bf5edff6b6ba2b65b1db325ff3312bbb57da461ef2ae651bd741af851aada3a.sszs
-│       ├── ...
-│       ├── 0xa156a527e631f858fee79fab7ef1fde3f6117a2e1201d47c09fbab0c6780c937.sszs
-│       └── 0xcd80bc535ddc467dea1d19e0c39c1160875ccd1989061bcd8ce206e3c1261c87.sszs
-└── 1
-    ├── 4096
-    │   ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
-    │   ├── 0x11f420928d8de41c50e735caab0369996824a5299c5f054e097965855925697d.sszs
-    │   ├── ...
-    │   ├── 0xbe91fc782877ed400d95c02c61aebfdd592635d11f8e64c94b46abd84f45c967.sszs
-    │   └── 0xf246189f078f02d30173ff74605cf31c9e65b5e463275ebdbeb40476638135ff.sszs
-    └── 4097
-        ├── 0x454d000674793c479e90504c0fe9827b50bb176ae022dab4e37d6a21471ab570.sszs
-        ├── 0xac5eb7437d7190c48cfa863e3c45f96a7f8af371d47ac12ccda07129a06af763.sszs
-        ├── ...
-        ├── 0xb7df30561d9d92ab5fafdd96bca8b44526497c8debf0fc425c7a0770b2abeb83.sszs
-        └── 0xc1dd0b1ae847b6ec62303a36d08c6a4a2e9e3ec4be3ff70551972a0ee3de9c14.sszs
-```
-
-## Computation of the maximum size of a `DataColumnSidecar`
-
-Reference: [Ethereum Consensus Specs - Fulu DAS Core](https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#datacolumnsidecar)
-
-```python
-class DataColumnSidecar(Container):
-    index: ColumnIndex  # Index of column in extended matrix
-    column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
-    signed_block_header: SignedBeaconBlockHeader
-    kzg_commitments_inclusion_proof: Vector[Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH]
-```
-
-### Size breakdown
-
-| Field | Calculation | Size |
-|-------|-------------|------|
-| `index` | `ColumnIndex` | `2 bytes` |
-| `column` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 64 (FIELD_ELEMENTS_PER_CELL) × 32 bytes (BYTES_PER_FIELD_ELEMENT)` | `8,388,608 bytes` |
-| `kzg_commitments` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 48 bytes (KZGCommitment)` | `196,608 bytes` |
-| `kzg_proofs` | `4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) × 48 bytes (KZGProof)` | `196,608 bytes` |
-| `signed_block_header` | `2 bytes (Slot) + 2 bytes (ValidatorIndex) + 3 × 2 bytes (Root) + 96 bytes (BLSSignature)` | `106 bytes` |
-| `kzg_commitments_inclusion_proof` | `4 (KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH) × 32 bytes` | `128 bytes` |
-
-**TOTAL:** `8,782,060 bytes = 70,256,480 bits`
-
-```
-log(70,256,480) / log(2) ≈ 26.07
-```
-
-**Conclusion:** 32 bits (4 bytes) are enough to store the maximum size of a data column sidecar.
-
-The maximum size of an SSZ encoded data column can be `2³² bits = 536,879,912 bytes`,
-which leaves a room of `536,879,912 bytes - 8,782,060 bytes ≈ 503 megabytes` to store the extra data needed by SSZ encoding (which is more than enough).
-
----
-
-# Execution proofs
-
-## File organisation
-
-Unlike data column sidecars (which have a fixed size per block), execution proofs have variable sizes.
-To handle this, we use an offset table that stores the position and size of each proof.
-
-- The first byte represents the version of the file structure (up to `0xff = 255`).
-  We set it to `0x01`.
-
-- The next 64 bytes represent the offset table with 8 slots (one per proof type).
-  Each slot contains:
-  - 4 bytes for the offset (relative to end of header)
-  - 4 bytes for the size of the SSZ-encoded proof
-
-  If the size is 0, the proof is not present.
-
-- The rest of the file contains the SSZ encoded proofs, stored contiguously.
-
-### File layout
-
-| Byte offset | Description |
-|-------------|-------------|
-| `0` | `version (1 byte) \| offsetTable (64 bytes)` |
-| `65 + offsetTable[0].offset` | `sszEncodedProof (offsetTable[0].size bytes)` |
-| `65 + offsetTable[1].offset` | `sszEncodedProof (offsetTable[1].size bytes)` |
-| ... | ... |
-| `65 + offsetTable[7].offset` | `sszEncodedProof (offsetTable[7].size bytes)` |
-
-**Header size:** 1 (version) + 64 (offset table) = **65 bytes**
-
-### Offset table entry format
-
-Each slot in the offset table (8 bytes per slot):
-- `offset` (4 bytes, big-endian): Offset from end of header where proof data begins
-- `size` (4 bytes, big-endian): Size of the SSZ-encoded proof in bytes
-
-**Note:** Offsets are relative to the end of the header (byte 65), not the start of the file.
-This maximizes the usable range of the 4-byte offset field.
-
-### Reading a proof with `proofID=N (O(1) access)`
-
-1. Read header (65 bytes)
-2. Check slot N: if `size == 0`, proof not present
-3. Seek to `(65 + offset)`, read `size` bytes, SSZ unmarshal
-
-Each file is named after the block root.
-
-**Example:** `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
-
-## Database Organisation
-
-SSZ encoded execution proofs are stored following the same `by-epoch` layout as data column sidecars.
-
-- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by 4096.
-- The second layer is a directory corresponding to the epoch.
-- Then all files are stored in the epoch directory.
-
-### Example Directory Structure
-
-```
-proofs
-├── 0
-│   ├── 100
-│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
-│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
-│   │   └── ...
-│   └── 101
-│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
-│       └── ...
-└── 1
-    └── 4096
-        ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
-        └── ...
-```

beacon-chain/db/filesystem/metrics.go

@@ -70,36 +70,4 @@ var (
 		Name: "data_column_prune_latency",
 		Help: "Latency of data column prune operations in milliseconds",
 	})
-
-	// Proofs
-	proofSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
-		Name:    "proof_storage_save_latency",
-		Help:    "Latency of proof storage save operations in milliseconds",
-		Buckets: []float64{3, 5, 7, 9, 11, 13, 20, 50},
-	})
-	proofFetchLatency = promauto.NewHistogram(prometheus.HistogramOpts{
-		Name:    "proof_storage_get_latency",
-		Help:    "Latency of proof storage get operations in milliseconds",
-		Buckets: []float64{3, 5, 7, 9, 11, 13},
-	})
-	proofPrunedCounter = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proof_pruned",
-		Help: "Number of proof files pruned.",
-	})
-	proofWrittenCounter = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "proof_written",
-		Help: "Number of proof files written",
-	})
-	proofDiskCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "proof_disk_count",
-		Help: "Approximate number of proof files in storage",
-	})
-	proofFileSyncLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "proof_file_sync_latency",
-		Help: "Latency of sync operations when saving proofs in milliseconds",
-	})
-	proofPruneLatency = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "proof_prune_latency",
-		Help: "Latency of proof prune operations in milliseconds",
-	})
 )

beacon-chain/db/filesystem/mock.go

@@ -144,45 +144,3 @@ func NewEphemeralDataColumnStorageWithMocker(t testing.TB) (*DataColumnMocker, *
 	fs, dcs := NewEphemeralDataColumnStorageAndFs(t)
 	return &DataColumnMocker{fs: fs, dcs: dcs}, dcs
 }
-
-// Proofs
-// ------
-
-// NewEphemeralProofStorage should only be used for tests.
-// The instance of ProofStorage returned is backed by an in-memory virtual filesystem,
-// improving test performance and simplifying cleanup.
-func NewEphemeralProofStorage(t testing.TB, opts ...ProofStorageOption) *ProofStorage {
-	return NewWarmedEphemeralProofStorageUsingFs(t, afero.NewMemMapFs(), opts...)
-}
-
-// NewEphemeralProofStorageAndFs can be used by tests that want access to the virtual filesystem
-// in order to interact with it outside the parameters of the ProofStorage API.
-func NewEphemeralProofStorageAndFs(t testing.TB, opts ...ProofStorageOption) (afero.Fs, *ProofStorage) {
-	fs := afero.NewMemMapFs()
-	ps := NewWarmedEphemeralProofStorageUsingFs(t, fs, opts...)
-	return fs, ps
-}
-
-// NewEphemeralProofStorageUsingFs creates a ProofStorage backed by the provided filesystem.
-func NewEphemeralProofStorageUsingFs(t testing.TB, fs afero.Fs, opts ...ProofStorageOption) *ProofStorage {
-	defaultOpts := []ProofStorageOption{
-		WithProofRetentionEpochs(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest),
-		WithProofFs(fs),
-	}
-	// User opts come last so they can override defaults
-	allOpts := append(defaultOpts, opts...)
-
-	ps, err := NewProofStorage(context.Background(), allOpts...)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return ps
-}
-
-// NewWarmedEphemeralProofStorageUsingFs creates a ProofStorage with a warmed cache.
-func NewWarmedEphemeralProofStorageUsingFs(t testing.TB, fs afero.Fs, opts ...ProofStorageOption) *ProofStorage {
-	ps := NewEphemeralProofStorageUsingFs(t, fs, opts...)
-	ps.WarmCache()
-	return ps
-}

beacon-chain/db/filesystem/proof.go

@@ -1,952 +0,0 @@
-package filesystem
-
-import (
-	"context"
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v7/async"
-	"github.com/OffchainLabs/prysm/v7/async/event"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/io/file"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/spf13/afero"
-)
-
-const (
-	proofVersion         = 0x01
-	proofVersionSize     = 1                                       // bytes
-	maxProofTypes        = 8                                       // ExecutionProofId max value (EXECUTION_PROOF_TYPE_COUNT)
-	proofOffsetSize      = 4                                       // bytes for offset (uint32)
-	proofSizeSize        = 4                                       // bytes for size (uint32)
-	proofSlotSize        = proofOffsetSize + proofSizeSize         // 8 bytes per slot
-	proofOffsetTableSize = maxProofTypes * proofSlotSize           // 64 bytes
-	proofHeaderSize      = proofVersionSize + proofOffsetTableSize // 65 bytes
-	proofsFileExtension  = "sszs"
-	proofPrunePeriod     = 1 * time.Minute
-)
-
-var (
-	errProofIDTooLarge        = errors.New("proof ID too large")
-	errWrongProofBytesWritten = errors.New("wrong number of bytes written")
-	errWrongProofVersion      = errors.New("wrong proof version")
-	errWrongProofBytesRead    = errors.New("wrong number of bytes read")
-	errNoProofBasePath        = errors.New("ProofStorage base path not specified in init")
-	errProofAlreadyExists     = errors.New("proof already exists")
-)
-
-type (
-	// ProofIdent is a unique identifier for a proof.
-	ProofIdent struct {
-		BlockRoot [fieldparams.RootLength]byte
-		Epoch     primitives.Epoch
-		ProofType uint8
-	}
-
-	// ProofsIdent is a collection of unique identifiers for proofs.
-	ProofsIdent struct {
-		BlockRoot  [fieldparams.RootLength]byte
-		Epoch      primitives.Epoch
-		ProofTypes []uint8
-	}
-
-	// ProofStorage is the concrete implementation of the filesystem backend for saving and retrieving ExecutionProofs.
-	ProofStorage struct {
-		base            string
-		retentionEpochs primitives.Epoch
-		fs              afero.Fs
-		cache           *proofCache
-		proofFeed       *event.Feed
-		pruneMu         sync.RWMutex
-
-		mu      sync.Mutex // protects muChans
-		muChans map[[fieldparams.RootLength]byte]*proofMuChan
-	}
-
-	// ProofStorageOption is a functional option for configuring a ProofStorage.
-	ProofStorageOption func(*ProofStorage) error
-
-	proofMuChan struct {
-		mu      *sync.RWMutex
-		toStore chan []blocks.VerifiedROSignedExecutionProof
-	}
-
-	// proofSlotEntry represents the offset and size for a proof in the file.
-	proofSlotEntry struct {
-		offset uint32
-		size   uint32
-	}
-
-	// proofOffsetTable is the offset table with 8 slots indexed by proofID.
-	proofOffsetTable [maxProofTypes]proofSlotEntry
-
-	// proofFileMetadata contains metadata extracted from a proof file path.
-	proofFileMetadata struct {
-		period    uint64
-		epoch     primitives.Epoch
-		blockRoot [fieldparams.RootLength]byte
-	}
-)
-
-// WithProofBasePath is a required option that sets the base path of proof storage.
-func WithProofBasePath(base string) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.base = base
-		return nil
-	}
-}
-
-// WithProofRetentionEpochs is an option that changes the number of epochs proofs will be persisted.
-func WithProofRetentionEpochs(e primitives.Epoch) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.retentionEpochs = e
-		return nil
-	}
-}
-
-// WithProofFs allows the afero.Fs implementation to be customized.
-// Used by tests to substitute an in-memory filesystem.
-func WithProofFs(fs afero.Fs) ProofStorageOption {
-	return func(ps *ProofStorage) error {
-		ps.fs = fs
-		return nil
-	}
-}
-
-// NewProofStorage creates a new instance of the ProofStorage object.
-func NewProofStorage(ctx context.Context, opts ...ProofStorageOption) (*ProofStorage, error) {
-	storage := &ProofStorage{
-		proofFeed: new(event.Feed),
-		muChans:   make(map[[fieldparams.RootLength]byte]*proofMuChan),
-	}
-
-	for _, o := range opts {
-		if err := o(storage); err != nil {
-			return nil, fmt.Errorf("failed to create proof storage: %w", err)
-		}
-	}
-
-	// Allow tests to set up a different fs using WithProofFs.
-	if storage.fs == nil {
-		if storage.base == "" {
-			return nil, errNoProofBasePath
-		}
-
-		storage.base = path.Clean(storage.base)
-		if err := file.MkdirAll(storage.base); err != nil {
-			return nil, fmt.Errorf("failed to create proof storage at %s: %w", storage.base, err)
-		}
-
-		storage.fs = afero.NewBasePathFs(afero.NewOsFs(), storage.base)
-	}
-
-	storage.cache = newProofCache()
-
-	async.RunEvery(ctx, proofPrunePeriod, func() {
-		storage.pruneMu.Lock()
-		defer storage.pruneMu.Unlock()
-
-		storage.prune()
-	})
-
-	return storage, nil
-}
-
-// WarmCache warms the cache of the proof filesystem.
-func (ps *ProofStorage) WarmCache() {
-	start := time.Now()
-	log.Info("Proof filesystem cache warm-up started")
-
-	ps.pruneMu.Lock()
-	defer ps.pruneMu.Unlock()
-
-	// List all period directories
-	periodFileInfos, err := afero.ReadDir(ps.fs, ".")
-	if err != nil {
-		log.WithError(err).Error("Error reading top directory during proof warm cache")
-		return
-	}
-
-	// Iterate through periods
-	for _, periodFileInfo := range periodFileInfos {
-		if !periodFileInfo.IsDir() {
-			continue
-		}
-
-		periodPath := periodFileInfo.Name()
-
-		// List all epoch directories in this period
-		epochFileInfos, err := afero.ReadDir(ps.fs, periodPath)
-		if err != nil {
-			log.WithError(err).WithField("period", periodPath).Error("Error reading period directory during proof warm cache")
-			continue
-		}
-
-		// Iterate through epochs
-		for _, epochFileInfo := range epochFileInfos {
-			if !epochFileInfo.IsDir() {
-				continue
-			}
-
-			epochPath := path.Join(periodPath, epochFileInfo.Name())
-
-			// List all .sszs files in this epoch
-			files, err := ps.listProofEpochFiles(epochPath)
-			if err != nil {
-				log.WithError(err).WithField("epoch", epochPath).Error("Error listing epoch files during proof warm cache")
-				continue
-			}
-
-			// Process all files in this epoch in parallel
-			ps.processProofEpochFiles(files)
-		}
-	}
-
-	// Prune the cache and the filesystem
-	ps.prune()
-
-	totalElapsed := time.Since(start)
-	log.WithField("elapsed", totalElapsed).Info("Proof filesystem cache warm-up complete")
-}
-
-// listProofEpochFiles lists all .sszs files in an epoch directory.
-func (ps *ProofStorage) listProofEpochFiles(epochPath string) ([]string, error) {
-	fileInfos, err := afero.ReadDir(ps.fs, epochPath)
-	if err != nil {
-		return nil, fmt.Errorf("read epoch directory: %w", err)
-	}
-
-	files := make([]string, 0, len(fileInfos))
-	for _, fileInfo := range fileInfos {
-		if fileInfo.IsDir() {
-			continue
-		}
-
-		fileName := fileInfo.Name()
-		if strings.HasSuffix(fileName, "."+proofsFileExtension) {
-			files = append(files, path.Join(epochPath, fileName))
-		}
-	}
-
-	return files, nil
-}
-
-// processProofEpochFiles processes all proof files in an epoch in parallel.
-func (ps *ProofStorage) processProofEpochFiles(files []string) {
-	var wg sync.WaitGroup
-
-	for _, filePath := range files {
-		wg.Go(func() {
-			if err := ps.processProofFile(filePath); err != nil {
-				log.WithError(err).WithField("file", filePath).Error("Error processing proof file during warm cache")
-			}
-		})
-	}
-
-	wg.Wait()
-}
-
-// processProofFile processes a single .sszs proof file for cache warming.
-func (ps *ProofStorage) processProofFile(filePath string) error {
-	// Extract metadata from the file path
-	fileMetadata, err := extractProofFileMetadata(filePath)
-	if err != nil {
-		return fmt.Errorf("extract proof file metadata: %w", err)
-	}
-
-	// Open the file
-	f, err := ps.fs.Open(filePath)
-	if err != nil {
-		return fmt.Errorf("open file: %w", err)
-	}
-
-	defer func() {
-		if closeErr := f.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing file during proof warm cache")
-		}
-	}()
-
-	// Read the offset table
-	offsetTable, _, err := ps.readHeader(f)
-	if err != nil {
-		return fmt.Errorf("read header: %w", err)
-	}
-
-	// Add all present proofs to the cache
-	for proofID, entry := range offsetTable {
-		if entry.size == 0 {
-			continue
-		}
-
-		proofIdent := ProofIdent{
-			BlockRoot: fileMetadata.blockRoot,
-			Epoch:     fileMetadata.epoch,
-			ProofType: uint8(proofID),
-		}
-
-		ps.cache.set(proofIdent)
-	}
-
-	return nil
-}
-
-// Summary returns the ProofStorageSummary for a given root.
-func (ps *ProofStorage) Summary(root [fieldparams.RootLength]byte) ProofStorageSummary {
-	return ps.cache.Summary(root)
-}
-
-// Save saves execution proofs into the database.
-// The proofs must all belong to the same block (same block root).
-func (ps *ProofStorage) Save(proofs []blocks.VerifiedROSignedExecutionProof) error {
-	startTime := time.Now()
-
-	if len(proofs) == 0 {
-		return nil
-	}
-
-	// Safely retrieve the block root and the epoch.
-	first := proofs[0]
-	blockRoot := first.BlockRoot()
-	epoch := first.Epoch()
-
-	proofTypes := make([]uint8, 0, len(proofs))
-	for _, proof := range proofs {
-		// Check if the proof ID is valid.
-		proofType := proof.Message.ProofType[0]
-		if proofType >= maxProofTypes {
-			return errProofIDTooLarge
-		}
-
-		// Save proofs in the filesystem.
-		if err := ps.saveFilesystem(proof.BlockRoot(), proof.Epoch(), proofs); err != nil {
-			return fmt.Errorf("save filesystem: %w", err)
-		}
-
-		proofTypes = append(proofTypes, proof.Message.ProofType[0])
-	}
-
-	// Compute the proofs ident.
-	proofsIdent := ProofsIdent{BlockRoot: blockRoot, Epoch: epoch, ProofTypes: proofTypes}
-
-	// Set proofs in the cache.
-	ps.cache.setMultiple(proofsIdent)
-
-	// Notify the proof feed.
-	ps.proofFeed.Send(proofsIdent)
-
-	proofSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-
-	return nil
-}
-
-// saveFilesystem saves proofs into the database.
-// This function expects all proofs to belong to the same block.
-func (ps *ProofStorage) saveFilesystem(root [fieldparams.RootLength]byte, epoch primitives.Epoch, proofs []blocks.VerifiedROSignedExecutionProof) error {
-	// Compute the file path.
-	filePath := proofFilePath(root, epoch)
-
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, toStore := ps.fileMutexChan(root)
-	toStore <- proofs
-
-	fileMu.Lock()
-	defer fileMu.Unlock()
-
-	// Check if the file exists.
-	exists, err := afero.Exists(ps.fs, filePath)
-	if err != nil {
-		return fmt.Errorf("afero exists: %w", err)
-	}
-
-	if exists {
-		if err := ps.saveProofExistingFile(filePath, toStore); err != nil {
-			return fmt.Errorf("save proof existing file: %w", err)
-		}
-
-		return nil
-	}
-
-	if err := ps.saveProofNewFile(filePath, toStore); err != nil {
-		return fmt.Errorf("save proof new file: %w", err)
-	}
-
-	return nil
-}
-
-// Subscribe subscribes to the proof feed.
-// It returns the subscription and a 1-size buffer channel to receive proof idents.
-func (ps *ProofStorage) Subscribe() (event.Subscription, <-chan ProofsIdent) {
-	identsChan := make(chan ProofsIdent, 1)
-	subscription := ps.proofFeed.Subscribe(identsChan)
-	return subscription, identsChan
-}
-
-// Get retrieves signed execution proofs from the database.
-// If one of the requested proofs is not found, it is just skipped.
-// If proofIDs is nil, then all stored proofs are returned.
-func (ps *ProofStorage) Get(root [fieldparams.RootLength]byte, proofIDs []uint8) ([]*ethpb.SignedExecutionProof, error) {
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, _ := ps.fileMutexChan(root)
-	fileMu.RLock()
-	defer fileMu.RUnlock()
-
-	startTime := time.Now()
-
-	// Build all proofIDs if none are provided.
-	if proofIDs == nil {
-		proofIDs = make([]uint8, maxProofTypes)
-		for i := range proofIDs {
-			proofIDs[i] = uint8(i)
-		}
-	}
-
-	summary, ok := ps.cache.get(root)
-	if !ok {
-		// Nothing found in db. Exit early.
-		return nil, nil
-	}
-
-	// Check if any requested proofID exists.
-	if !slices.ContainsFunc(proofIDs, summary.HasProof) {
-		return nil, nil
-	}
-
-	// Compute the file path.
-	filePath := proofFilePath(root, summary.epoch)
-
-	// Open the proof file.
-	file, err := ps.fs.Open(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("proof file open: %w", err)
-	}
-	defer func() {
-		if closeErr := file.Close(); closeErr != nil {
-			log.WithError(closeErr).WithField("file", filePath).Error("Error closing proof file")
-		}
-	}()
-
-	// Read the header.
-	offsetTable, _, err := ps.readHeader(file)
-	if err != nil {
-		return nil, fmt.Errorf("read header: %w", err)
-	}
-
-	// Retrieve proofs from the file.
-	proofs := make([]*ethpb.SignedExecutionProof, 0, len(proofIDs))
-	for _, proofID := range proofIDs {
-		if proofID >= maxProofTypes {
-			continue
-		}
-
-		entry := offsetTable[proofID]
-		// Skip if the proof is not saved.
-		if entry.size == 0 {
-			continue
-		}
-
-		// Seek to the proof offset (offset is relative to end of header).
-		_, err = file.Seek(proofHeaderSize+int64(entry.offset), io.SeekStart)
-		if err != nil {
-			return nil, fmt.Errorf("seek: %w", err)
-		}
-
-		// Read the SSZ encoded proof.
-		sszProof := make([]byte, entry.size)
-		n, err := io.ReadFull(file, sszProof)
-		if err != nil {
-			return nil, fmt.Errorf("read proof: %w", err)
-		}
-		if n != int(entry.size) {
-			return nil, errWrongProofBytesRead
-		}
-
-		// Unmarshal the signed proof.
-		proof := new(ethpb.SignedExecutionProof)
-		if err := proof.UnmarshalSSZ(sszProof); err != nil {
-			return nil, fmt.Errorf("unmarshal proof: %w", err)
-		}
-
-		proofs = append(proofs, proof)
-	}
-
-	proofFetchLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-
-	return proofs, nil
-}
-
-// Remove deletes all proofs for a given root.
-func (ps *ProofStorage) Remove(blockRoot [fieldparams.RootLength]byte) error {
-	ps.pruneMu.RLock()
-	defer ps.pruneMu.RUnlock()
-
-	fileMu, _ := ps.fileMutexChan(blockRoot)
-	fileMu.Lock()
-	defer fileMu.Unlock()
-
-	summary, ok := ps.cache.get(blockRoot)
-	if !ok {
-		// Nothing found in db. Exit early.
-		return nil
-	}
-
-	// Remove the proofs from the cache.
-	ps.cache.evict(blockRoot)
-
-	// Remove the proof file.
-	filePath := proofFilePath(blockRoot, summary.epoch)
-	if err := ps.fs.Remove(filePath); err != nil {
-		return fmt.Errorf("remove: %w", err)
-	}
-
-	return nil
-}
-
-// Clear deletes all files on the filesystem.
-func (ps *ProofStorage) Clear() error {
-	ps.pruneMu.Lock()
-	defer ps.pruneMu.Unlock()
-
-	dirs, err := listDir(ps.fs, ".")
-	if err != nil {
-		return fmt.Errorf("list dir: %w", err)
-	}
-
-	ps.cache.clear()
-
-	for _, dir := range dirs {
-		if err := ps.fs.RemoveAll(dir); err != nil {
-			return fmt.Errorf("remove all: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// saveProofNewFile saves proofs to a new file.
-func (ps *ProofStorage) saveProofNewFile(filePath string, inputProofs chan []blocks.VerifiedROSignedExecutionProof) (err error) {
-	// Initialize the offset table.
-	var offsetTable proofOffsetTable
-
-	var sszEncodedProofs []byte
-	currentOffset := uint32(0)
-
-	for {
-		proofs := pullProofChan(inputProofs)
-		if len(proofs) == 0 {
-			break
-		}
-
-		for _, proof := range proofs {
-			proofType := proof.Message.ProofType[0]
-			if proofType >= maxProofTypes {
-				continue
-			}
-
-			// Skip if already in offset table (duplicate).
-			if offsetTable[proofType].size != 0 {
-				continue
-			}
-
-			// SSZ encode the full signed proof.
-			sszProof, err := proof.SignedExecutionProof.MarshalSSZ()
-			if err != nil {
-				return fmt.Errorf("marshal proof SSZ: %w", err)
-			}
-
-			proofSize := uint32(len(sszProof))
-
-			// Update offset table.
-			offsetTable[proofType] = proofSlotEntry{
-				offset: currentOffset,
-				size:   proofSize,
-			}
-
-			// Append SSZ encoded proof.
-			sszEncodedProofs = append(sszEncodedProofs, sszProof...)
-			currentOffset += proofSize
-		}
-	}
-
-	if len(sszEncodedProofs) == 0 {
-		// Nothing to save.
-		return nil
-	}
-
-	// Create directory structure.
-	dir := filepath.Dir(filePath)
-	if err := ps.fs.MkdirAll(dir, directoryPermissions()); err != nil {
-		return fmt.Errorf("mkdir all: %w", err)
-	}
-
-	file, err := ps.fs.Create(filePath)
-	if err != nil {
-		return fmt.Errorf("create proof file: %w", err)
-	}
-
-	defer func() {
-		closeErr := file.Close()
-		if closeErr != nil && err == nil {
-			err = closeErr
-		}
-	}()
-
-	// Build the file content.
-	countToWrite := proofHeaderSize + len(sszEncodedProofs)
-	bytes := make([]byte, 0, countToWrite)
-
-	// Write version byte.
-	bytes = append(bytes, byte(proofVersion))
-
-	// Write offset table.
-	bytes = append(bytes, encodeOffsetTable(offsetTable)...)
-
-	// Write SSZ encoded proofs.
-	bytes = append(bytes, sszEncodedProofs...)
-
-	countWritten, err := file.Write(bytes)
-	if err != nil {
-		return fmt.Errorf("write: %w", err)
-	}
-	if countWritten != countToWrite {
-		return errWrongProofBytesWritten
-	}
-
-	syncStart := time.Now()
-	if err := file.Sync(); err != nil {
-		return fmt.Errorf("sync: %w", err)
-	}
-	proofFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-
-	return nil
-}
-
-// saveProofExistingFile saves proofs to an existing file.
-func (ps *ProofStorage) saveProofExistingFile(filePath string, inputProofs chan []blocks.VerifiedROSignedExecutionProof) (err error) {
-	// Open the file for read/write.
-	file, err := ps.fs.OpenFile(filePath, os.O_RDWR, os.FileMode(0600))
-	if err != nil {
-		return fmt.Errorf("open proof file: %w", err)
-	}
-
-	defer func() {
-		closeErr := file.Close()
-		if closeErr != nil && err == nil {
-			err = closeErr
-		}
-	}()
-
-	// Read current header.
-	offsetTable, fileSize, err := ps.readHeader(file)
-	if err != nil {
-		return fmt.Errorf("read header: %w", err)
-	}
-
-	var sszEncodedProofs []byte
-	currentOffset := uint32(fileSize - proofHeaderSize)
-	modified := false
-
-	for {
-		proofs := pullProofChan(inputProofs)
-		if len(proofs) == 0 {
-			break
-		}
-
-		for _, proof := range proofs {
-			proofType := proof.Message.ProofType[0]
-			if proofType >= maxProofTypes {
-				continue
-			}
-
-			// Skip if proof already exists.
-			if offsetTable[proofType].size != 0 {
-				continue
-			}
-
-			// SSZ encode the full signed proof.
-			sszProof, err := proof.SignedExecutionProof.MarshalSSZ()
-			if err != nil {
-				return fmt.Errorf("marshal proof SSZ: %w", err)
-			}
-
-			proofSize := uint32(len(sszProof))
-
-			// Update offset table.
-			offsetTable[proofType] = proofSlotEntry{
-				offset: currentOffset,
-				size:   proofSize,
-			}
-
-			// Append SSZ encoded proof.
-			sszEncodedProofs = append(sszEncodedProofs, sszProof...)
-			currentOffset += proofSize
-			modified = true
-		}
-	}
-
-	if !modified {
-		return nil
-	}
-
-	// Write updated offset table back to file (at position 1, after version byte).
-	encodedTable := encodeOffsetTable(offsetTable)
-	count, err := file.WriteAt(encodedTable, int64(proofVersionSize))
-	if err != nil {
-		return fmt.Errorf("write offset table: %w", err)
-	}
-	if count != proofOffsetTableSize {
-		return errWrongProofBytesWritten
-	}
-
-	// Append the SSZ encoded proofs to the end of the file.
-	count, err = file.WriteAt(sszEncodedProofs, fileSize)
-	if err != nil {
-		return fmt.Errorf("write SSZ encoded proofs: %w", err)
-	}
-	if count != len(sszEncodedProofs) {
-		return errWrongProofBytesWritten
-	}
-
-	syncStart := time.Now()
-	if err := file.Sync(); err != nil {
-		return fmt.Errorf("sync: %w", err)
-	}
-	proofFileSyncLatency.Observe(float64(time.Since(syncStart).Milliseconds()))
-
-	return nil
-}
-
-// readHeader reads the file header and returns the offset table and file size.
-func (ps *ProofStorage) readHeader(file afero.File) (proofOffsetTable, int64, error) {
-	var header [proofHeaderSize]byte
-	countRead, err := file.ReadAt(header[:], 0)
-	if err != nil {
-		return proofOffsetTable{}, 0, fmt.Errorf("read at: %w", err)
-	}
-	if countRead != proofHeaderSize {
-		return proofOffsetTable{}, 0, errWrongProofBytesRead
-	}
-
-	// Check version.
-	fileVersion := int(header[0])
-	if fileVersion != proofVersion {
-		return proofOffsetTable{}, 0, errWrongProofVersion
-	}
-
-	// Decode offset table and compute file size.
-	var offsetTable proofOffsetTable
-	fileSize := int64(proofHeaderSize)
-	for i := range offsetTable {
-		pos := proofVersionSize + i*proofSlotSize
-		offsetTable[i].offset = binary.BigEndian.Uint32(header[pos : pos+proofOffsetSize])
-		offsetTable[i].size = binary.BigEndian.Uint32(header[pos+proofOffsetSize : pos+proofSlotSize])
-		fileSize += int64(offsetTable[i].size)
-	}
-
-	return offsetTable, fileSize, nil
-}
-
-// prune cleans the cache, the filesystem and mutexes.
-func (ps *ProofStorage) prune() {
-	startTime := time.Now()
-	defer func() {
-		proofPruneLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-	}()
-
-	highestStoredEpoch := ps.cache.HighestEpoch()
-
-	// Check if we need to prune.
-	if highestStoredEpoch < ps.retentionEpochs {
-		return
-	}
-
-	highestEpochToPrune := highestStoredEpoch - ps.retentionEpochs
-	highestPeriodToPrune := proofPeriod(highestEpochToPrune)
-
-	// Prune the cache.
-	prunedCount := ps.cache.pruneUpTo(highestEpochToPrune)
-
-	if prunedCount == 0 {
-		return
-	}
-
-	proofPrunedCounter.Add(float64(prunedCount))
-
-	// Prune the filesystem.
-	periodFileInfos, err := afero.ReadDir(ps.fs, ".")
-	if err != nil {
-		log.WithError(err).Error("Error encountered while reading top directory during proof prune")
-		return
-	}
-
-	for _, periodFileInfo := range periodFileInfos {
-		periodStr := periodFileInfo.Name()
-		period, err := strconv.ParseUint(periodStr, 10, 64)
-		if err != nil {
-			log.WithError(err).Errorf("Error encountered while parsing period %s", periodStr)
-			continue
-		}
-
-		if period < highestPeriodToPrune {
-			// Remove everything lower than highest period to prune.
-			if err := ps.fs.RemoveAll(periodStr); err != nil {
-				log.WithError(err).Error("Error encountered while removing period directory during proof prune")
-			}
-			continue
-		}
-
-		if period > highestPeriodToPrune {
-			// Do not remove anything higher than highest period to prune.
-			continue
-		}
-
-		// if period == highestPeriodToPrune
-		epochFileInfos, err := afero.ReadDir(ps.fs, periodStr)
-		if err != nil {
-			log.WithError(err).Error("Error encountered while reading epoch directory during proof prune")
-			continue
-		}
-
-		for _, epochFileInfo := range epochFileInfos {
-			epochStr := epochFileInfo.Name()
-			epochDir := path.Join(periodStr, epochStr)
-
-			epoch, err := strconv.ParseUint(epochStr, 10, 64)
-			if err != nil {
-				log.WithError(err).Errorf("Error encountered while parsing epoch %s", epochStr)
-				continue
-			}
-
-			if primitives.Epoch(epoch) > highestEpochToPrune {
-				continue
-			}
-
-			if err := ps.fs.RemoveAll(epochDir); err != nil {
-				log.WithError(err).Error("Error encountered while removing epoch directory during proof prune")
-				continue
-			}
-		}
-	}
-
-	ps.mu.Lock()
-	defer ps.mu.Unlock()
-	clear(ps.muChans)
-}
-
-// fileMutexChan returns the file mutex and channel for a given block root.
-func (ps *ProofStorage) fileMutexChan(root [fieldparams.RootLength]byte) (*sync.RWMutex, chan []blocks.VerifiedROSignedExecutionProof) {
-	ps.mu.Lock()
-	defer ps.mu.Unlock()
-
-	mc, ok := ps.muChans[root]
-	if !ok {
-		mc = &proofMuChan{
-			mu:      new(sync.RWMutex),
-			toStore: make(chan []blocks.VerifiedROSignedExecutionProof, 1),
-		}
-		ps.muChans[root] = mc
-		return mc.mu, mc.toStore
-	}
-
-	return mc.mu, mc.toStore
-}
-
-// pullProofChan pulls proofs from the input channel until it is empty.
-func pullProofChan(inputProofs chan []blocks.VerifiedROSignedExecutionProof) []blocks.VerifiedROSignedExecutionProof {
-	proofs := make([]blocks.VerifiedROSignedExecutionProof, 0, maxProofTypes)
-
-	for {
-		select {
-		case batch := <-inputProofs:
-			proofs = append(proofs, batch...)
-		default:
-			return proofs
-		}
-	}
-}
-
-// proofFilePath builds the file path in database for a given root and epoch.
-func proofFilePath(root [fieldparams.RootLength]byte, epoch primitives.Epoch) string {
-	return path.Join(
-		fmt.Sprintf("%d", proofPeriod(epoch)),
-		fmt.Sprintf("%d", epoch),
-		fmt.Sprintf("%#x.%s", root, proofsFileExtension),
-	)
-}
-
-// extractProofFileMetadata extracts the metadata from a proof file path.
-func extractProofFileMetadata(path string) (*proofFileMetadata, error) {
-	// Use filepath.Separator to handle both Windows (\) and Unix (/) path separators
-	parts := strings.Split(path, string(filepath.Separator))
-	if len(parts) != 3 {
-		return nil, fmt.Errorf("unexpected proof file %s", path)
-	}
-
-	period, err := strconv.ParseUint(parts[0], 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse period from %s: %w", path, err)
-	}
-
-	epoch, err := strconv.ParseUint(parts[1], 10, 64)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse epoch from %s: %w", path, err)
-	}
-
-	partsRoot := strings.Split(parts[2], ".")
-	if len(partsRoot) != 2 {
-		return nil, fmt.Errorf("failed to parse root from %s", path)
-	}
-
-	blockRootString := partsRoot[0]
-	if len(blockRootString) != 2+2*fieldparams.RootLength || blockRootString[:2] != "0x" {
-		return nil, fmt.Errorf("unexpected proof file name %s", path)
-	}
-
-	if partsRoot[1] != proofsFileExtension {
-		return nil, fmt.Errorf("unexpected extension %s", path)
-	}
-
-	blockRootSlice, err := hex.DecodeString(blockRootString[2:])
-	if err != nil {
-		return nil, fmt.Errorf("decode string from %s: %w", path, err)
-	}
-
-	var blockRoot [fieldparams.RootLength]byte
-	copy(blockRoot[:], blockRootSlice)
-
-	result := &proofFileMetadata{period: period, epoch: primitives.Epoch(epoch), blockRoot: blockRoot}
-	return result, nil
-}
-
-// proofPeriod computes the period of a given epoch.
-func proofPeriod(epoch primitives.Epoch) uint64 {
-	return uint64(epoch / params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
-}
-
-// encodeOffsetTable encodes the offset table to bytes.
-func encodeOffsetTable(table proofOffsetTable) []byte {
-	result := make([]byte, proofOffsetTableSize)
-	for i, entry := range table {
-		offset := i * proofSlotSize
-		binary.BigEndian.PutUint32(result[offset:offset+proofOffsetSize], entry.offset)
-		binary.BigEndian.PutUint32(result[offset+proofOffsetSize:offset+proofSlotSize], entry.size)
-	}
-	return result
-}

beacon-chain/db/filesystem/proof_cache.go

@@ -1,206 +0,0 @@
-package filesystem
-
-import (
-	"slices"
-	"sync"
-
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-)
-
-// ProofStorageSummary represents cached information about the proofs on disk for each root the cache knows about.
-type ProofStorageSummary struct {
-	epoch      primitives.Epoch
-	proofTypes map[uint8]bool
-}
-
-// HasProof returns true if the proof with the given proofID is available in the filesystem.
-func (s ProofStorageSummary) HasProof(proofID uint8) bool {
-	if s.proofTypes == nil {
-		return false
-	}
-	_, ok := s.proofTypes[proofID]
-	return ok
-}
-
-// Count returns the number of available proofs.
-func (s ProofStorageSummary) Count() int {
-	return len(s.proofTypes)
-}
-
-// All returns all stored proofIDs sorted in ascending order.
-func (s ProofStorageSummary) All() []uint8 {
-	if s.proofTypes == nil {
-		return nil
-	}
-	proofTypes := make([]uint8, 0, len(s.proofTypes))
-	for proofType := range s.proofTypes {
-		proofTypes = append(proofTypes, proofType)
-	}
-	slices.Sort(proofTypes)
-	return proofTypes
-}
-
-type proofCache struct {
-	mu                 sync.RWMutex
-	proofCount         float64
-	lowestCachedEpoch  primitives.Epoch
-	highestCachedEpoch primitives.Epoch
-	cache              map[[fieldparams.RootLength]byte]ProofStorageSummary
-}
-
-func newProofCache() *proofCache {
-	return &proofCache{
-		cache:             make(map[[fieldparams.RootLength]byte]ProofStorageSummary),
-		lowestCachedEpoch: params.BeaconConfig().FarFutureEpoch,
-	}
-}
-
-// Summary returns the ProofStorageSummary for `root`.
-// The ProofStorageSummary can be used to check for the presence of proofs based on proofID.
-func (pc *proofCache) Summary(root [fieldparams.RootLength]byte) ProofStorageSummary {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	return pc.cache[root]
-}
-
-// HighestEpoch returns the highest cached epoch.
-func (pc *proofCache) HighestEpoch() primitives.Epoch {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	return pc.highestCachedEpoch
-}
-
-// set adds a proof to the cache.
-func (pc *proofCache) set(ident ProofIdent) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary := pc.cache[ident.BlockRoot]
-	if summary.proofTypes == nil {
-		summary.proofTypes = make(map[uint8]bool)
-	}
-	summary.epoch = ident.Epoch
-
-	if _, exists := summary.proofTypes[ident.ProofType]; exists {
-		pc.cache[ident.BlockRoot] = summary
-		return
-	}
-
-	summary.proofTypes[ident.ProofType] = true
-	pc.lowestCachedEpoch = min(pc.lowestCachedEpoch, ident.Epoch)
-	pc.highestCachedEpoch = max(pc.highestCachedEpoch, ident.Epoch)
-
-	pc.cache[ident.BlockRoot] = summary
-
-	pc.proofCount++
-	proofDiskCount.Set(pc.proofCount)
-	proofWrittenCounter.Inc()
-}
-
-// setMultiple adds multiple proofs to the cache.
-func (pc *proofCache) setMultiple(ident ProofsIdent) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary := pc.cache[ident.BlockRoot]
-	if summary.proofTypes == nil {
-		summary.proofTypes = make(map[uint8]bool)
-	}
-	summary.epoch = ident.Epoch
-
-	addedCount := 0
-	for _, proofID := range ident.ProofTypes {
-		if _, exists := summary.proofTypes[proofID]; exists {
-			continue
-		}
-		summary.proofTypes[proofID] = true
-		addedCount++
-	}
-
-	if addedCount == 0 {
-		pc.cache[ident.BlockRoot] = summary
-		return
-	}
-
-	pc.lowestCachedEpoch = min(pc.lowestCachedEpoch, ident.Epoch)
-	pc.highestCachedEpoch = max(pc.highestCachedEpoch, ident.Epoch)
-
-	pc.cache[ident.BlockRoot] = summary
-
-	pc.proofCount += float64(addedCount)
-	proofDiskCount.Set(pc.proofCount)
-	proofWrittenCounter.Add(float64(addedCount))
-}
-
-// get returns the ProofStorageSummary for the given block root.
-// If the root is not in the cache, the second return value will be false.
-func (pc *proofCache) get(blockRoot [fieldparams.RootLength]byte) (ProofStorageSummary, bool) {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-
-	summary, ok := pc.cache[blockRoot]
-	return summary, ok
-}
-
-// evict removes the ProofStorageSummary for the given block root from the cache.
-func (pc *proofCache) evict(blockRoot [fieldparams.RootLength]byte) int {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	summary, ok := pc.cache[blockRoot]
-	if !ok {
-		return 0
-	}
-
-	deleted := len(summary.proofTypes)
-	delete(pc.cache, blockRoot)
-
-	if deleted > 0 {
-		pc.proofCount -= float64(deleted)
-		proofDiskCount.Set(pc.proofCount)
-	}
-
-	return deleted
-}
-
-// pruneUpTo removes all entries from the cache up to the given target epoch included.
-func (pc *proofCache) pruneUpTo(targetEpoch primitives.Epoch) uint64 {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-
-	prunedCount := uint64(0)
-	newLowestCachedEpoch := params.BeaconConfig().FarFutureEpoch
-	newHighestCachedEpoch := primitives.Epoch(0)
-
-	for blockRoot, summary := range pc.cache {
-		epoch := summary.epoch
-
-		if epoch > targetEpoch {
-			newLowestCachedEpoch = min(newLowestCachedEpoch, epoch)
-			newHighestCachedEpoch = max(newHighestCachedEpoch, epoch)
-		}
-
-		if epoch <= targetEpoch {
-			prunedCount += uint64(len(summary.proofTypes))
-			delete(pc.cache, blockRoot)
-		}
-	}
-
-	if prunedCount > 0 {
-		pc.lowestCachedEpoch = newLowestCachedEpoch
-		pc.highestCachedEpoch = newHighestCachedEpoch
-		pc.proofCount -= float64(prunedCount)
-		proofDiskCount.Set(pc.proofCount)
-	}
-
-	return prunedCount
-}
-
-// clear removes all entries from the cache.
-func (pc *proofCache) clear() uint64 {
-	return pc.pruneUpTo(params.BeaconConfig().FarFutureEpoch)
-}

beacon-chain/db/kv/error.go

@@ -22,10 +22,6 @@ var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
 // ErrNotFoundMetadataSeqNum is a not found error specifically for the metadata sequence number getter
 var ErrNotFoundMetadataSeqNum = errors.Wrap(ErrNotFound, "metadata sequence number")
 
-// ErrStateDiffIncompatible is returned when state-diff feature is enabled
-// but the database was created without state-diff support.
-var ErrStateDiffIncompatible = errors.New("state-diff feature enabled but database was created without state-diff support")
-
 var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
 var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
 var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")

beacon-chain/db/kv/genesis.go

@@ -42,10 +42,6 @@ func (s *Store) SaveGenesisData(ctx context.Context, genesisState state.BeaconSt
 	if err := s.SaveGenesisBlockRoot(ctx, genesisBlkRoot); err != nil {
 		return errors.Wrap(err, "could not save genesis block root")
 	}
-
-	if err := s.initializeStateDiff(0, genesisState); err != nil {
-		return errors.Wrap(err, "failed to initialize state diff for genesis")
-	}
 	return nil
 }
 

beacon-chain/db/kv/kv.go

@@ -203,47 +203,17 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		return nil, err
 	}
 
-	if err := kv.startStateDiff(ctx); err != nil {
-		if errors.Is(err, ErrStateDiffIncompatible) {
-			return kv, err
+	if features.Get().EnableStateDiff {
+		sdCache, err := newStateDiffCache(kv)
+		if err != nil {
+			return nil, err
 		}
-		return nil, err
+		kv.stateDiffCache = sdCache
 	}
+
 	return kv, nil
 }
 
-func (kv *Store) startStateDiff(ctx context.Context) error {
-	if !features.Get().EnableStateDiff {
-		return nil
-	}
-	// Check if offset already exists (existing state-diff database).
-	hasOffset, err := kv.hasStateDiffOffset()
-	if err != nil {
-		return err
-	}
-
-	if hasOffset {
-		// Existing state-diff database - restarts not yet supported.
-		return errors.New("restarting with existing state-diff database not yet supported")
-	}
-
-	// Check if this is a new database (no head block).
-	headBlock, err := kv.HeadBlock(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get head block")
-	}
-
-	if headBlock == nil {
-		// New database - will be initialized later during checkpoint/genesis sync.
-		// stateDiffCache stays nil until SaveOrigin or SaveGenesisData initializes it.
-		log.Info("State-diff enabled: will be initialized during checkpoint or genesis sync")
-	} else {
-		// Existing database without state-diff - return store with error for caller to handle.
-		return ErrStateDiffIncompatible
-	}
-	return nil
-}
-
 // ClearDB removes the previously stored database in the data directory.
 func (s *Store) ClearDB() error {
 	if err := s.Close(); err != nil {

beacon-chain/db/kv/state.go

@@ -1053,10 +1053,6 @@ func (s *Store) getStateUsingStateDiff(ctx context.Context, blockRoot [32]byte)
 		return nil, err
 	}
 
-	if uint64(slot) < s.getOffset() {
-		return nil, ErrSlotBeforeOffset
-	}
-
 	st, err := s.stateByDiff(ctx, slot)
 	if err != nil {
 		return nil, err
@@ -1074,10 +1070,6 @@ func (s *Store) hasStateUsingStateDiff(ctx context.Context, blockRoot [32]byte)
 		return false, err
 	}
 
-	if uint64(slot) < s.getOffset() {
-		return false, ErrSlotBeforeOffset
-	}
-
 	stateLvl := computeLevel(s.getOffset(), slot)
 	return stateLvl != -1, nil
 }

beacon-chain/db/kv/state_diff.go

@@ -24,7 +24,7 @@ const (
 */
 
 // SlotInDiffTree returns whether the given slot is a saving point in the diff tree.
-// If it is, it also returns the offset and level in the tree.
+// It it is, it also returns the offset and level in the tree.
 func (s *Store) SlotInDiffTree(slot primitives.Slot) (uint64, int, error) {
 	offset := s.getOffset()
 	if uint64(slot) < offset {

beacon-chain/db/kv/state_diff_cache.go

@@ -25,7 +25,7 @@ func newStateDiffCache(s *Store) (*stateDiffCache, error) {
 			return bbolt.ErrBucketNotFound
 		}
 
-		offsetBytes := bucket.Get(offsetKey)
+		offsetBytes := bucket.Get([]byte("offset"))
 		if offsetBytes == nil {
 			return errors.New("state diff cache: offset not found")
 		}

beacon-chain/db/kv/state_diff_helpers.go

@@ -9,19 +9,17 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	statenative "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v7/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/hdiff"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/math"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	pkgerrors "github.com/pkg/errors"
 	"go.etcd.io/bbolt"
 )
 
 var (
 	offsetKey           = []byte("offset")
-	ErrSlotBeforeOffset = errors.New("slot is before state-diff root offset")
+	ErrSlotBeforeOffset = errors.New("slot is before root offset")
 )
 
 func makeKeyForStateDiffTree(level int, slot uint64) []byte {
@@ -75,9 +73,6 @@ func (s *Store) getAnchorState(offset uint64, lvl int, slot primitives.Slot) (an
 
 // computeLevel computes the level in the diff tree. Returns -1 in case slot should not be in tree.
 func computeLevel(offset uint64, slot primitives.Slot) int {
-	if uint64(slot) < offset {
-		return -1
-	}
 	rel := uint64(slot) - offset
 	for i, exp := range flags.Get().StateDiffExponents {
 		if exp < 2 || exp >= 64 {
@@ -124,66 +119,6 @@ func (s *Store) getOffset() uint64 {
 	return s.stateDiffCache.getOffset()
 }
 
-// hasStateDiffOffset checks if the state-diff offset has been set in the database.
-// This is used to detect if an existing database has state-diff enabled.
-func (s *Store) hasStateDiffOffset() (bool, error) {
-	var hasOffset bool
-	err := s.db.View(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return nil
-		}
-		hasOffset = bucket.Get(offsetKey) != nil
-		return nil
-	})
-	return hasOffset, err
-}
-
-// initializeStateDiff sets up the state-diff schema for a new database.
-// This should be called during checkpoint sync or genesis sync.
-func (s *Store) initializeStateDiff(slot primitives.Slot, initialState state.ReadOnlyBeaconState) error {
-	// Return early if the feature is not set
-	if !features.Get().EnableStateDiff {
-		return nil
-	}
-	// Only reinitialize if the offset is different
-	if s.stateDiffCache != nil {
-		if s.stateDiffCache.getOffset() == uint64(slot) {
-			log.WithField("offset", slot).Warning("Ignoring state diff cache reinitialization")
-			return nil
-		}
-	}
-	// Write offset directly to the database (without using cache which doesn't exist yet).
-	err := s.db.Update(func(tx *bbolt.Tx) error {
-		bucket := tx.Bucket(stateDiffBucket)
-		if bucket == nil {
-			return bbolt.ErrBucketNotFound
-		}
-
-		offsetBytes := make([]byte, 8)
-		binary.LittleEndian.PutUint64(offsetBytes, uint64(slot))
-		return bucket.Put(offsetKey, offsetBytes)
-	})
-	if err != nil {
-		return pkgerrors.Wrap(err, "failed to set offset")
-	}
-
-	// Create the state diff cache (this will read the offset from the database).
-	sdCache, err := newStateDiffCache(s)
-	if err != nil {
-		return pkgerrors.Wrap(err, "failed to create state diff cache")
-	}
-	s.stateDiffCache = sdCache
-
-	// Save the initial state as a full snapshot.
-	if err := s.saveFullSnapshot(initialState); err != nil {
-		return pkgerrors.Wrap(err, "failed to save initial snapshot")
-	}
-
-	log.WithField("offset", slot).Info("Initialized state-diff cache")
-	return nil
-}
-
 func keyForSnapshot(v int) ([]byte, error) {
 	switch v {
 	case version.Fulu:

beacon-chain/db/kv/state_diff_test.go

@@ -43,12 +43,8 @@ func TestStateDiff_ComputeLevel(t *testing.T) {
 
 	offset := db.getOffset()
 
-	// should be -1. slot < offset
-	lvl := computeLevel(10, primitives.Slot(9))
-	require.Equal(t, -1, lvl)
-
 	// 2 ** 21
-	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(21)))
+	lvl := computeLevel(offset, primitives.Slot(math.PowerOf2(21)))
 	require.Equal(t, 0, lvl)
 
 	// 2 ** 21 * 3

beacon-chain/db/kv/state_test.go

@@ -1395,23 +1395,6 @@ func TestStore_CanSaveRetrieveStateUsingStateDiff(t *testing.T) {
 		require.IsNil(t, readSt)
 	})
 
-	t.Run("slot before offset", func(t *testing.T) {
-		db := setupDB(t)
-		setDefaultStateDiffExponents()
-
-		err := setOffsetInDB(db, 10)
-		require.NoError(t, err)
-
-		r := bytesutil.ToBytes32([]byte{'A'})
-		ss := &ethpb.StateSummary{Slot: 9, Root: r[:]}
-		err = db.SaveStateSummary(t.Context(), ss)
-		require.NoError(t, err)
-
-		st, err := db.getStateUsingStateDiff(t.Context(), r)
-		require.ErrorIs(t, err, ErrSlotBeforeOffset)
-		require.IsNil(t, st)
-	})
-
 	t.Run("Full state snapshot", func(t *testing.T) {
 		t.Run("using state summary", func(t *testing.T) {
 			for v := range version.All() {
@@ -1644,21 +1627,4 @@ func TestStore_HasStateUsingStateDiff(t *testing.T) {
 		}
 
 	})
-
-	t.Run("slot before offset", func(t *testing.T) {
-		db := setupDB(t)
-		setDefaultStateDiffExponents()
-
-		err := setOffsetInDB(db, 10)
-		require.NoError(t, err)
-
-		r := bytesutil.ToBytes32([]byte{'B'})
-		ss := &ethpb.StateSummary{Slot: 0, Root: r[:]}
-		err = db.SaveStateSummary(t.Context(), ss)
-		require.NoError(t, err)
-
-		hasState, err := db.hasStateUsingStateDiff(t.Context(), r)
-		require.ErrorIs(t, err, ErrSlotBeforeOffset)
-		require.Equal(t, false, hasState)
-	})
 }

beacon-chain/db/kv/wss.go

@@ -110,8 +110,6 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
 		return errors.Wrap(err, "save finalized checkpoint")
 	}
-	if err := s.initializeStateDiff(state.Slot(), state); err != nil {
-		return errors.Wrap(err, "failed to initialize state diff")
-	}
+
 	return 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"
@@ -123,8 +124,6 @@ type BeaconNode struct {
 	BlobStorageOptions       []filesystem.BlobStorageOption
 	DataColumnStorage        *filesystem.DataColumnStorage
 	DataColumnStorageOptions []filesystem.DataColumnStorageOption
-	ProofStorage             *filesystem.ProofStorage
-	ProofStorageOptions      []filesystem.ProofStorageOption
 	verifyInitWaiter         *verification.InitializerWaiter
 	lhsp                     *verification.LazyHeadStateProvider
 	syncChecker              *initialsync.SyncChecker
@@ -229,15 +228,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		return nil, errors.Wrap(err, "could not clear data column storage")
 	}
 
-	if beacon.ProofStorage == nil {
-		proofStorage, err := filesystem.NewProofStorage(cliCtx.Context, beacon.ProofStorageOptions...)
-		if err != nil {
-			return nil, errors.Wrap(err, "new proof storage")
-		}
-
-		beacon.ProofStorage = proofStorage
-	}
-
 	bfs, err := startBaseServices(cliCtx, beacon, depositAddress, dbClearer)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not start modules")
@@ -479,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
@@ -546,12 +540,7 @@ func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store,
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
 	d, err := kv.NewKVStore(ctx, dbPath)
-	if errors.Is(err, kv.ErrStateDiffIncompatible) {
-		log.WithError(err).Warn("Disabling state-diff feature")
-		cfg := features.Get()
-		cfg.EnableStateDiff = false
-		features.Init(cfg)
-	} else if err != nil {
+	if err != nil {
 		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}
 
@@ -758,13 +747,11 @@ func (b *BeaconNode) registerBlockchainService(fc forkchoice.ForkChoicer, gs *st
 		blockchain.WithSyncComplete(syncComplete),
 		blockchain.WithBlobStorage(b.BlobStorage),
 		blockchain.WithDataColumnStorage(b.DataColumnStorage),
-		blockchain.WithProofStorage(b.ProofStorage),
 		blockchain.WithTrackedValidatorsCache(b.trackedValidatorsCache),
 		blockchain.WithPayloadIDCache(b.payloadIDCache),
 		blockchain.WithSyncChecker(b.syncChecker),
 		blockchain.WithSlasherEnabled(b.slasherEnabled),
 		blockchain.WithLightClientStore(b.lcStore),
-		blockchain.WithOperationNotifier(b),
 	)
 
 	blockchainService, err := blockchain.NewService(b.ctx, opts...)
@@ -849,7 +836,6 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}, bFil
 		regularsync.WithStateNotifier(b),
 		regularsync.WithBlobStorage(b.BlobStorage),
 		regularsync.WithDataColumnStorage(b.DataColumnStorage),
-		regularsync.WithExecutionProofStorage(b.ProofStorage),
 		regularsync.WithVerifierWaiter(b.verifyInitWaiter),
 		regularsync.WithAvailableBlocker(bFillStore),
 		regularsync.WithTrackedValidatorsCache(b.trackedValidatorsCache),
@@ -976,7 +962,6 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		BlockReceiver:             chainService,
 		BlobReceiver:              chainService,
 		DataColumnReceiver:        chainService,
-		ProofReceiver:             chainService,
 		AttestationReceiver:       chainService,
 		GenesisTimeFetcher:        chainService,
 		GenesisFetcher:            chainService,

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/node/options.go

@@ -35,13 +35,6 @@ func WithBuilderFlagOptions(opts []builder.Option) Option {
 	}
 }
 
-func WithConfigOptions(opt ...params.Option) Option {
-	return func(bn *BeaconNode) error {
-		bn.ConfigOptions = append(bn.ConfigOptions, opt...)
-		return nil
-	}
-}
-
 // WithBlobStorage sets the BlobStorage backend for the BeaconNode
 func WithBlobStorage(bs *filesystem.BlobStorage) Option {
 	return func(bn *BeaconNode) error {
@@ -59,6 +52,13 @@ func WithBlobStorageOptions(opt ...filesystem.BlobStorageOption) Option {
 	}
 }
 
+func WithConfigOptions(opt ...params.Option) Option {
+	return func(bn *BeaconNode) error {
+		bn.ConfigOptions = append(bn.ConfigOptions, opt...)
+		return nil
+	}
+}
+
 // WithDataColumnStorage sets the DataColumnStorage backend for the BeaconNode
 func WithDataColumnStorage(bs *filesystem.DataColumnStorage) Option {
 	return func(bn *BeaconNode) error {
@@ -75,20 +75,3 @@ func WithDataColumnStorageOptions(opt ...filesystem.DataColumnStorageOption) Opt
 		return nil
 	}
 }
-
-// WithDataColumnStorage sets the DataColumnStorage backend for the BeaconNode
-func WithProofStorage(bs *filesystem.ProofStorage) Option {
-	return func(bn *BeaconNode) error {
-		bn.ProofStorage = bs
-		return nil
-	}
-}
-
-// WithDataColumnStorageOptions appends 1 or more filesystem.DataColumnStorageOption on the beacon node,
-// to be used when initializing data column storage.
-func WithProofStorageOption(opt ...filesystem.ProofStorageOption) Option {
-	return func(bn *BeaconNode) error {
-		bn.ProofStorageOptions = append(bn.ProofStorageOptions, opt...)
-		return nil
-	}
-}

beacon-chain/p2p/BUILD.bazel

@@ -166,7 +166,6 @@ go_test(
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state/stategen/mock:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/p2p/discovery.go

@@ -589,11 +589,6 @@ func (s *Service) createLocalNode(
 		localNode.Set(quicEntry)
 	}
 
-	if features.Get().EnableZkvm {
-		zkvmKeyEntry := enr.WithEntry(zkvmEnabledKeyEnrKey, true)
-		localNode.Set(zkvmKeyEntry)
-	}
-
 	localNode.SetFallbackIP(ipAddr)
 	localNode.SetFallbackUDP(udpPort)
 

beacon-chain/p2p/discovery_test.go

@@ -25,7 +25,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/peers/scorers"
 	testp2p "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/wrapper"
 	leakybucket "github.com/OffchainLabs/prysm/v7/container/leaky-bucket"
@@ -244,19 +243,12 @@ func TestCreateLocalNode(t *testing.T) {
 		name          string
 		cfg           *Config
 		expectedError bool
-		zkvmEnabled   bool
 	}{
 		{
 			name:          "valid config",
 			cfg:           &Config{},
 			expectedError: false,
 		},
-		{
-			name:          "valid config with zkVM enabled",
-			cfg:           &Config{},
-			expectedError: false,
-			zkvmEnabled:   true,
-		},
 		{
 			name:          "invalid host address",
 			cfg:           &Config{HostAddress: "invalid"},
@@ -281,15 +273,6 @@ func TestCreateLocalNode(t *testing.T) {
 
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
-			if tt.zkvmEnabled {
-				resetCfg := features.InitWithReset(&features.Flags{
-					EnableZkvm: true,
-				})
-				t.Cleanup(func() {
-					resetCfg()
-				})
-			}
-
 			// Define ports. Use unique ports since this test validates ENR content.
 			const (
 				udpPort  = 3100
@@ -365,14 +348,6 @@ func TestCreateLocalNode(t *testing.T) {
 			custodyGroupCount := new(uint64)
 			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().CustodyGroupCountKey, custodyGroupCount)))
 			require.Equal(t, custodyRequirement, *custodyGroupCount)
-
-			// Check zkVM enabled key if applicable.
-			if tt.zkvmEnabled {
-				zkvmEnabled := new(bool)
-				require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, zkvmEnabled)))
-				require.Equal(t, features.Get().EnableZkvm, *zkvmEnabled)
-			}
-
 		})
 	}
 }

beacon-chain/p2p/gossip_scoring_params.go

@@ -52,9 +52,6 @@ const (
 	// lightClientFinalityUpdateWeight specifies the scoring weight that we apply to
 	// our light client finality update topic.
 	lightClientFinalityUpdateWeight = 0.05
-	// executionProofWeight specifies the scoring weight that we apply to
-	// our execution proof topic.
-	executionProofWeight = 0.05
 
 	// maxInMeshScore describes the max score a peer can attain from being in the mesh.
 	maxInMeshScore = 10
@@ -148,8 +145,6 @@ func (s *Service) topicScoreParams(topic string) (*pubsub.TopicScoreParams, erro
 		return defaultLightClientOptimisticUpdateTopicParams(), nil
 	case strings.Contains(topic, GossipLightClientFinalityUpdateMessage):
 		return defaultLightClientFinalityUpdateTopicParams(), nil
-	case strings.Contains(topic, GossipExecutionProofMessage):
-		return defaultExecutionProofTopicParams(), nil
 	default:
 		return nil, errors.Errorf("unrecognized topic provided for parameter registration: %s", topic)
 	}
@@ -515,28 +510,6 @@ func defaultBlsToExecutionChangeTopicParams() *pubsub.TopicScoreParams {
 	}
 }
 
-func defaultExecutionProofTopicParams() *pubsub.TopicScoreParams {
-	return &pubsub.TopicScoreParams{
-		TopicWeight:                     executionProofWeight,
-		TimeInMeshWeight:                maxInMeshScore / inMeshCap(),
-		TimeInMeshQuantum:               inMeshTime(),
-		TimeInMeshCap:                   inMeshCap(),
-		FirstMessageDeliveriesWeight:    2,
-		FirstMessageDeliveriesDecay:     scoreDecay(oneHundredEpochs),
-		FirstMessageDeliveriesCap:       5,
-		MeshMessageDeliveriesWeight:     0,
-		MeshMessageDeliveriesDecay:      0,
-		MeshMessageDeliveriesCap:        0,
-		MeshMessageDeliveriesThreshold:  0,
-		MeshMessageDeliveriesWindow:     0,
-		MeshMessageDeliveriesActivation: 0,
-		MeshFailurePenaltyWeight:        0,
-		MeshFailurePenaltyDecay:         0,
-		InvalidMessageDeliveriesWeight:  -2000,
-		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
-	}
-}
-
 func defaultLightClientOptimisticUpdateTopicParams() *pubsub.TopicScoreParams {
 	return &pubsub.TopicScoreParams{
 		TopicWeight:                     lightClientOptimisticUpdateWeight,

beacon-chain/p2p/gossip_topic_mappings.go

@@ -25,7 +25,6 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	LightClientOptimisticUpdateTopicFormat:    func() proto.Message { return &ethpb.LightClientOptimisticUpdateAltair{} },
 	LightClientFinalityUpdateTopicFormat:      func() proto.Message { return &ethpb.LightClientFinalityUpdateAltair{} },
 	DataColumnSubnetTopicFormat:               func() proto.Message { return &ethpb.DataColumnSidecar{} },
-	ExecutionProofSubnetTopicFormat:           func() proto.Message { return &ethpb.ExecutionProof{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type

beacon-chain/p2p/peers/status.go

@@ -602,33 +602,6 @@ func (p *Status) All() []peer.ID {
 	return pids
 }
 
-// ZkvmEnabledPeers returns all connected peers that have zkvm enabled in their ENR.
-func (p *Status) ZkvmEnabledPeers() []peer.ID {
-	p.store.RLock()
-	defer p.store.RUnlock()
-
-	peers := make([]peer.ID, 0)
-	for pid, peerData := range p.store.Peers() {
-		if peerData.ConnState != Connected {
-			continue
-		}
-		if peerData.Enr == nil {
-			continue
-		}
-
-		var enabled bool
-		entry := enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, &enabled)
-		if err := peerData.Enr.Load(entry); err != nil {
-			continue
-		}
-
-		if enabled {
-			peers = append(peers, pid)
-		}
-	}
-	return peers
-}
-
 // Prune clears out and removes outdated and disconnected peers.
 func (p *Status) Prune() {
 	p.store.Lock()

beacon-chain/p2p/peers/status_test.go

@@ -1341,75 +1341,3 @@ func createPeer(t *testing.T, p *peers.Status, addr ma.Multiaddr,
 	p.SetConnectionState(id, state)
 	return id
 }
-
-func TestZkvmEnabledPeers(t *testing.T) {
-	p := peers.NewStatus(t.Context(), &peers.StatusConfig{
-		PeerLimit: 30,
-		ScorerParams: &scorers.Config{
-			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-				Threshold: 1,
-			},
-		},
-	})
-
-	// Create peer 1: Connected, zkVM enabled
-	pid1 := addPeer(t, p, peers.Connected)
-	record1 := new(enr.Record)
-	zkvmEnabled := true
-	record1.Set(enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, &zkvmEnabled))
-	p.Add(record1, pid1, nil, network.DirOutbound)
-	p.SetConnectionState(pid1, peers.Connected)
-
-	// Create peer 2: Connected, zkVM disabled
-	pid2 := addPeer(t, p, peers.Connected)
-	record2 := new(enr.Record)
-	zkvmDisabled := false
-	record2.Set(enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, &zkvmDisabled))
-	p.Add(record2, pid2, nil, network.DirOutbound)
-	p.SetConnectionState(pid2, peers.Connected)
-
-	// Create peer 3: Connected, zkVM enabled
-	pid3 := addPeer(t, p, peers.Connected)
-	record3 := new(enr.Record)
-	record3.Set(enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, &zkvmEnabled))
-	p.Add(record3, pid3, nil, network.DirOutbound)
-	p.SetConnectionState(pid3, peers.Connected)
-
-	// Create peer 4: Disconnected, zkVM enabled (should not be included)
-	pid4 := addPeer(t, p, peers.Disconnected)
-	record4 := new(enr.Record)
-	record4.Set(enr.WithEntry(params.BeaconNetworkConfig().ZkvmEnabledKey, &zkvmEnabled))
-	p.Add(record4, pid4, nil, network.DirOutbound)
-	p.SetConnectionState(pid4, peers.Disconnected)
-
-	// Create peer 5: Connected, no ENR (should not be included)
-	pid5 := addPeer(t, p, peers.Connected)
-	p.Add(nil, pid5, nil, network.DirOutbound)
-	p.SetConnectionState(pid5, peers.Connected)
-
-	// Create peer 6: Connected, no zkVM key in ENR (should not be included)
-	pid6 := addPeer(t, p, peers.Connected)
-	record6 := new(enr.Record)
-	record6.Set(enr.WithEntry("other_key", "other_value"))
-	p.Add(record6, pid6, nil, network.DirOutbound)
-	p.SetConnectionState(pid6, peers.Connected)
-
-	// Get zkVM enabled peers
-	zkvmPeers := p.ZkvmEnabledPeers()
-
-	// Should return only pid1 and pid3 (connected peers with zkVM enabled)
-	assert.Equal(t, 2, len(zkvmPeers), "Expected 2 zkVM enabled peers")
-
-	// Verify the returned peers are correct
-	zkvmPeerMap := make(map[peer.ID]bool)
-	for _, pid := range zkvmPeers {
-		zkvmPeerMap[pid] = true
-	}
-
-	assert.Equal(t, true, zkvmPeerMap[pid1], "pid1 should be in zkVM enabled peers")
-	assert.Equal(t, true, zkvmPeerMap[pid3], "pid3 should be in zkVM enabled peers")
-	assert.Equal(t, false, zkvmPeerMap[pid2], "pid2 should not be in zkVM enabled peers (disabled)")
-	assert.Equal(t, false, zkvmPeerMap[pid4], "pid4 should not be in zkVM enabled peers (disconnected)")
-	assert.Equal(t, false, zkvmPeerMap[pid5], "pid5 should not be in zkVM enabled peers (no ENR)")
-	assert.Equal(t, false, zkvmPeerMap[pid6], "pid6 should not be in zkVM enabled peers (no zkVM key)")
-}

beacon-chain/p2p/rpc_topic_mappings.go

@@ -67,9 +67,6 @@ const (
 
 	// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
 	DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
-
-	// ExecutionProofsByRootName is the name for the ExecutionProofsByRoot v1 message topic.
-	ExecutionProofsByRootName = "/execution_proofs_by_root"
 )
 
 const (
@@ -109,9 +106,6 @@ const (
 	// RPCDataColumnSidecarsByRangeTopicV1 is a topic for requesting data column sidecars by their slot.
 	// /eth2/beacon_chain/req/data_column_sidecars_by_range/1 - New in Fulu.
 	RPCDataColumnSidecarsByRangeTopicV1 = protocolPrefix + DataColumnSidecarsByRangeName + SchemaVersionV1
-	// RPCExecutionProofsByRootTopicV1 is a topic for requesting execution proofs by their block root.
-	// /eth2/beacon_chain/req/execution_proofs_by_root/1 - New in Fulu.
-	RPCExecutionProofsByRootTopicV1 = protocolPrefix + ExecutionProofsByRootName + SchemaVersionV1
 
 	// V2 RPC Topics
 	// RPCStatusTopicV2 defines the v1 topic for the status rpc method.
@@ -176,9 +170,6 @@ var (
 
 		// DataColumnSidecarsByRoot v1 Message
 		RPCDataColumnSidecarsByRootTopicV1: p2ptypes.DataColumnsByRootIdentifiers{},
-
-		// ExecutionProofsByRoot v1 Message
-		RPCExecutionProofsByRootTopicV1: new(pb.ExecutionProofsByRootRequest),
 	}
 
 	// Maps all registered protocol prefixes.
@@ -202,7 +193,6 @@ var (
 		LightClientOptimisticUpdateName: true,
 		DataColumnSidecarsByRootName:    true,
 		DataColumnSidecarsByRangeName:   true,
-		ExecutionProofsByRootName:       true,
 	}
 
 	// Maps all the RPC messages which are to updated in altair.

beacon-chain/p2p/subnets.go

@@ -36,7 +36,6 @@ var (
 	attSubnetEnrKey         = params.BeaconNetworkConfig().AttSubnetKey
 	syncCommsSubnetEnrKey   = params.BeaconNetworkConfig().SyncCommsSubnetKey
 	custodyGroupCountEnrKey = params.BeaconNetworkConfig().CustodyGroupCountKey
-	zkvmEnabledKeyEnrKey    = params.BeaconNetworkConfig().ZkvmEnabledKey
 )
 
 // The value used with the subnet, in order

beacon-chain/p2p/topics.go

@@ -46,8 +46,6 @@ const (
 	GossipLightClientOptimisticUpdateMessage = "light_client_optimistic_update"
 	// GossipDataColumnSidecarMessage is the name for the data column sidecar message type.
 	GossipDataColumnSidecarMessage = "data_column_sidecar"
-	// GossipExecutionProofMessage is the name for the execution proof message type.
-	GossipExecutionProofMessage = "execution_proof"
 
 	// Topic Formats
 	//
@@ -77,8 +75,6 @@ const (
 	LightClientOptimisticUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientOptimisticUpdateMessage
 	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
 	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
-	// ExecutionProofSubnetTopicFormat is the topic format for the execution proof subnet.
-	ExecutionProofSubnetTopicFormat = GossipProtocolAndDigest + GossipExecutionProofMessage // + "_%d" (PoC only have one global topic)
 )
 
 // topic is a struct representing a single gossipsub topic.
@@ -162,7 +158,6 @@ func (s *Service) allTopics() []topic {
 		newTopic(altair, future, empty, GossipLightClientOptimisticUpdateMessage),
 		newTopic(altair, future, empty, GossipLightClientFinalityUpdateMessage),
 		newTopic(capella, future, empty, GossipBlsToExecutionChangeMessage),
-		newTopic(fulu, future, empty, GossipExecutionProofMessage),
 	}
 	last := params.GetNetworkScheduleEntry(genesis)
 	schedule := []params.NetworkScheduleEntry{last}

beacon-chain/rpc/BUILD.bazel

@@ -38,7 +38,6 @@ go_library(
         "//beacon-chain/rpc/eth/events:go_default_library",
         "//beacon-chain/rpc/eth/light-client:go_default_library",
         "//beacon-chain/rpc/eth/node:go_default_library",
-        "//beacon-chain/rpc/eth/prover:go_default_library",
         "//beacon-chain/rpc/eth/rewards:go_default_library",
         "//beacon-chain/rpc/eth/validator:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",

beacon-chain/rpc/endpoints.go

@@ -13,7 +13,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/events"
 	lightclient "github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/light-client"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/node"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/prover"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/rewards"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/validator"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/lookup"
@@ -99,7 +98,6 @@ func (s *Service) endpoints(
 	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater, blocker, coreService)...)
 	endpoints = append(endpoints, s.prysmNodeEndpoints()...)
 	endpoints = append(endpoints, s.prysmValidatorEndpoints(stater, coreService)...)
-	endpoints = append(endpoints, s.proverEndpoints()...)
 
 	if features.Get().EnableLightClient {
 		endpoints = append(endpoints, s.lightClientEndpoints()...)
@@ -1290,22 +1288,3 @@ func (s *Service) prysmValidatorEndpoints(stater lookup.Stater, coreService *cor
 		},
 	}
 }
-
-func (*Service) proverEndpoints() []endpoint {
-	server := &prover.Server{}
-
-	const namespace = "prover"
-	return []endpoint{
-		{
-			template: "/eth/v1/prover/execution_proofs",
-			name:     namespace + ".SubmitExecutionProof",
-			middleware: []middleware.Middleware{
-				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.SubmitExecutionProof,
-			methods: []string{http.MethodPost},
-		},
-	}
-}

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

@@ -50,14 +50,6 @@ import (
 	"go.uber.org/mock/gomock"
 )
 
-// fillGloasBlockTestData populates a Gloas block with non-zero test values for the
-// Gloas-specific fields: SignedExecutionPayloadBid and PayloadAttestations.
-func fillGloasBlockTestData(b *eth.SignedBeaconBlockGloas, numPayloadAttestations int) {
-	slot := b.Block.Slot
-	b.Block.Body.SignedExecutionPayloadBid = util.GenerateTestSignedExecutionPayloadBid(slot)
-	b.Block.Body.PayloadAttestations = util.GenerateTestPayloadAttestations(numPayloadAttestations, slot)
-}
-
 func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (*eth.SignedBeaconBlock, []*eth.BeaconBlockContainer) {
 	parentRoot := [32]byte{1, 2, 3}
 	genBlk := util.NewBeaconBlock()
@@ -343,50 +335,6 @@ func TestGetBlockV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, blk, b)
 	})
-	t.Run("gloas", func(t *testing.T) {
-		b := util.NewBeaconBlockGloas()
-		b.Block.Slot = 123
-		fillGloasBlockTestData(b, 2)
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &chainMock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		s := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request.SetPathValue("block_id", "head")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBlockV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetBlockV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, version.String(version.Gloas), resp.Version)
-		sbb := &structs.SignedBeaconBlockGloas{Message: &structs.BeaconBlockGloas{}}
-		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
-		sbb.Signature = resp.Data.Signature
-		blk, err := sbb.ToConsensus()
-		require.NoError(t, err)
-		assert.DeepEqual(t, blk, b)
-
-		// Verify Gloas-specific fields are correctly serialized/deserialized
-		require.NotNil(t, blk.Block.Body.SignedExecutionPayloadBid)
-		assert.Equal(t, primitives.Slot(123), blk.Block.Body.SignedExecutionPayloadBid.Message.Slot)
-		assert.Equal(t, primitives.BuilderIndex(1), blk.Block.Body.SignedExecutionPayloadBid.Message.BuilderIndex)
-		require.Equal(t, 2, len(blk.Block.Body.PayloadAttestations))
-		for _, att := range blk.Block.Body.PayloadAttestations {
-			assert.Equal(t, primitives.Slot(123), att.Data.Slot)
-			assert.Equal(t, true, att.Data.PayloadPresent)
-			assert.Equal(t, true, att.Data.BlobDataAvailable)
-		}
-	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		b := util.NewBeaconBlockBellatrix()
 		sb, err := blocks.NewSignedBeaconBlock(b)
@@ -626,37 +574,6 @@ func TestGetBlockSSZV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
 	})
-	t.Run("gloas", func(t *testing.T) {
-		b := util.NewBeaconBlockGloas()
-		b.Block.Slot = 123
-		fillGloasBlockTestData(b, 2)
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		s := &Server{
-			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request.SetPathValue("block_id", "head")
-		request.Header.Set("Accept", api.OctetStreamMediaType)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBlockV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		assert.Equal(t, version.String(version.Gloas), writer.Header().Get(api.VersionHeader))
-		sszExpected, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
-
-		// Verify SSZ round-trip preserves Gloas-specific fields
-		decoded := &eth.SignedBeaconBlockGloas{}
-		require.NoError(t, decoded.UnmarshalSSZ(writer.Body.Bytes()))
-		require.NotNil(t, decoded.Block.Body.SignedExecutionPayloadBid)
-		assert.Equal(t, primitives.Slot(123), decoded.Block.Body.SignedExecutionPayloadBid.Message.Slot)
-		require.Equal(t, 2, len(decoded.Block.Body.PayloadAttestations))
-	})
 }
 
 func TestGetBlockAttestationsV2(t *testing.T) {
@@ -2592,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()
@@ -2611,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,
 			},
 			{
@@ -2659,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,
 			},
 			{
@@ -2672,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,
 			},
 		}
@@ -2720,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)
@@ -2759,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/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api/server/structs:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",

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

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v7/network/httputil"
@@ -182,16 +181,6 @@ func prepareConfigSpec() (map[string]any, error) {
 		data[tag] = convertValueForJSON(val, tag)
 	}
 
-	// Add Fulu preset values. These are compile-time constants from fieldparams,
-	// not runtime configs, but are required by the /eth/v1/config/spec API.
-	data["NUMBER_OF_COLUMNS"] = convertValueForJSON(reflect.ValueOf(uint64(fieldparams.NumberOfColumns)), "NUMBER_OF_COLUMNS")
-	data["CELLS_PER_EXT_BLOB"] = convertValueForJSON(reflect.ValueOf(uint64(fieldparams.NumberOfColumns)), "CELLS_PER_EXT_BLOB")
-	data["FIELD_ELEMENTS_PER_CELL"] = convertValueForJSON(reflect.ValueOf(uint64(fieldparams.CellsPerBlob)), "FIELD_ELEMENTS_PER_CELL")
-	data["FIELD_ELEMENTS_PER_EXT_BLOB"] = convertValueForJSON(reflect.ValueOf(config.FieldElementsPerBlob*2), "FIELD_ELEMENTS_PER_EXT_BLOB")
-	data["KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH"] = convertValueForJSON(reflect.ValueOf(uint64(4)), "KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH")
-	// UPDATE_TIMEOUT is derived from SLOTS_PER_EPOCH * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-	data["UPDATE_TIMEOUT"] = convertValueForJSON(reflect.ValueOf(uint64(config.SlotsPerEpoch)*uint64(config.EpochsPerSyncCommitteePeriod)), "UPDATE_TIMEOUT")
-
 	return data, 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
@@ -133,12 +132,8 @@ func TestGetSpec(t *testing.T) {
 	config.MinSyncCommitteeParticipants = 71
 	config.ProposerReorgCutoffBPS = primitives.BP(121)
 	config.AttestationDueBPS = primitives.BP(122)
-	config.AggregateDueBPS = primitives.BP(123)
+	config.AggregrateDueBPS = 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"
@@ -173,15 +168,6 @@ func TestGetSpec(t *testing.T) {
 	config.BlobsidecarSubnetCount = 101
 	config.BlobsidecarSubnetCountElectra = 102
 	config.SyncMessageDueBPS = 103
-	config.BuilderWithdrawalPrefixByte = byte('b')
-	config.BuilderIndexSelfBuild = primitives.BuilderIndex(125)
-	config.BuilderPaymentThresholdNumerator = 104
-	config.BuilderPaymentThresholdDenominator = 105
-
-	// EIP-8025
-	config.MaxProofDataBytes = 200
-	config.MinEpochsForExecutionProofRequests = 201
-	config.MinProofsRequired = 202
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -204,12 +190,6 @@ func TestGetSpec(t *testing.T) {
 	var daap [4]byte
 	copy(daap[:], []byte{'0', '0', '0', '7'})
 	config.DomainAggregateAndProof = daap
-	var dbb [4]byte
-	copy(dbb[:], []byte{'0', '0', '0', '8'})
-	config.DomainBeaconBuilder = dbb
-	var dptc [4]byte
-	copy(dptc[:], []byte{'0', '0', '0', '8'})
-	config.DomainPTCAttester = dptc
 	var dam [4]byte
 	copy(dam[:], []byte{'1', '0', '0', '0'})
 	config.DomainApplicationMask = dam
@@ -225,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, 192, len(data))
+	assert.Equal(t, 175, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -305,8 +285,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":
@@ -429,8 +407,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x30303036", v)
 			case "DOMAIN_AGGREGATE_AND_PROOF":
 				assert.Equal(t, "0x30303037", v)
-			case "DOMAIN_PTC_ATTESTER":
-				assert.Equal(t, "0x30303038", v)
 			case "DOMAIN_APPLICATION_MASK":
 				assert.Equal(t, "0x31303030", v)
 			case "DOMAIN_SYNC_COMMITTEE":
@@ -443,14 +419,8 @@ 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, "0x30303038", v)
 			case "DOMAIN_BLOB_SIDECAR":
 				assert.Equal(t, "0x00000000", v)
-			case "BUILDER_WITHDRAWAL_PREFIX":
-				assert.Equal(t, "0x62", v)
-			case "BUILDER_INDEX_SELF_BUILD":
-				assert.Equal(t, "125", v)
 			case "TRANSITION_TOTAL_DIFFICULTY":
 				assert.Equal(t, "0", v)
 			case "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH":
@@ -487,18 +457,10 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "121", v)
 			case "ATTESTATION_DUE_BPS":
 				assert.Equal(t, "122", v)
-			case "AGGREGATE_DUE_BPS":
+			case "AGGREGRATE_DUE_BPS":
 				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":
@@ -615,32 +577,10 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "102", v)
 			case "SYNC_MESSAGE_DUE_BPS":
 				assert.Equal(t, "103", v)
-			case "MAX_PROOF_DATA_BYTES":
-				assert.Equal(t, "200", v)
-			case "MIN_EPOCHS_FOR_EXECUTION_PROOF_REQUESTS":
-				assert.Equal(t, "201", v)
-			case "MIN_PROOFS_REQUIRED":
-				assert.Equal(t, "202", v)
-			case "BUILDER_PAYMENT_THRESHOLD_NUMERATOR":
-				assert.Equal(t, "104", v)
-			case "BUILDER_PAYMENT_THRESHOLD_DENOMINATOR":
-				assert.Equal(t, "105", v)
 			case "BLOB_SCHEDULE":
 				blobSchedule, ok := v.([]any)
 				assert.Equal(t, true, ok)
 				assert.Equal(t, 2, len(blobSchedule))
-			case "FIELD_ELEMENTS_PER_CELL":
-				assert.Equal(t, "64", v) // From fieldparams.CellsPerBlob
-			case "FIELD_ELEMENTS_PER_EXT_BLOB":
-				assert.Equal(t, "198", v) // FieldElementsPerBlob (99) * 2
-			case "KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH":
-				assert.Equal(t, "4", v) // Preset value
-			case "CELLS_PER_EXT_BLOB":
-				assert.Equal(t, "128", v) // From fieldparams.NumberOfColumns
-			case "NUMBER_OF_COLUMNS":
-				assert.Equal(t, "128", v) // From fieldparams.NumberOfColumns
-			case "UPDATE_TIMEOUT":
-				assert.Equal(t, "1782", v) // SlotsPerEpoch (27) * EpochsPerSyncCommitteePeriod (66)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}

beacon-chain/rpc/eth/prover/BUILD.bazel

@@ -1,17 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "handlers.go",
-        "log.go",
-        "server.go",
-    ],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/eth/prover",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//monitoring/tracing/trace:go_default_library",
-        "//network/httputil:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)

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

@@ -1,39 +0,0 @@
-package prover
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-
-	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	"github.com/OffchainLabs/prysm/v7/network/httputil"
-)
-
-// SubmitExecutionProof handles POST requests to /eth/v1/prover/execution_proofs.
-// It receives execution proofs from provers and logs them.
-func (s *Server) SubmitExecutionProof(w http.ResponseWriter, r *http.Request) {
-	_, span := trace.StartSpan(r.Context(), "prover.SubmitExecutionProof")
-	defer span.End()
-
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		httputil.HandleError(w, "Could not read request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if len(body) == 0 {
-		httputil.HandleError(w, "No data submitted", http.StatusBadRequest)
-		return
-	}
-
-	// Parse the JSON to extract fields for logging
-	var proof map[string]any
-	if err := json.Unmarshal(body, &proof); err != nil {
-		httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	log.Info("Received execution proof")
-
-	w.WriteHeader(http.StatusOK)
-}

beacon-chain/rpc/eth/prover/log.go

@@ -1,5 +0,0 @@
-package prover
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("package", "beacon-chain/rpc/eth/prover")

beacon-chain/rpc/eth/prover/server.go

@@ -1,5 +0,0 @@
-// Package prover defines handlers for the prover API endpoints.
-package prover
-
-// Server defines a server implementation for the prover API endpoints.
-type Server struct{}

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/prysm/v1alpha1/node/BUILD.bazel

@@ -48,7 +48,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
-        "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/node/server.go

@@ -35,19 +35,18 @@ import (
 // providing RPC endpoints for verifying a beacon node's sync status, genesis and
 // version information, and services the node implements and runs.
 type Server struct {
-	LogsStreamer          logs.Streamer
-	StreamLogsBufferSize  int
-	SyncChecker           sync.Checker
-	Server                *grpc.Server
-	BeaconDB              db.ReadOnlyDatabase
-	PeersFetcher          p2p.PeersProvider
-	PeerManager           p2p.PeerManager
-	GenesisTimeFetcher    blockchain.TimeFetcher
-	GenesisFetcher        blockchain.GenesisFetcher
-	POWChainInfoFetcher   execution.ChainInfoFetcher
-	BeaconMonitoringHost  string
-	BeaconMonitoringPort  int
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
+	LogsStreamer         logs.Streamer
+	StreamLogsBufferSize int
+	SyncChecker          sync.Checker
+	Server               *grpc.Server
+	BeaconDB             db.ReadOnlyDatabase
+	PeersFetcher         p2p.PeersProvider
+	PeerManager          p2p.PeerManager
+	GenesisTimeFetcher   blockchain.TimeFetcher
+	GenesisFetcher       blockchain.GenesisFetcher
+	POWChainInfoFetcher  execution.ChainInfoFetcher
+	BeaconMonitoringHost string
+	BeaconMonitoringPort int
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
@@ -62,28 +61,21 @@ func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (
 	ctx, cancel := context.WithTimeout(ctx, timeoutDuration)
 	defer cancel() // Important to avoid a context leak
 
-	// Check optimistic status - validators should not participate when optimistic
-	isOptimistic, err := ns.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		return &empty.Empty{}, status.Errorf(codes.Internal, "Could not check optimistic status: %v", err)
-	}
-
-	if ns.SyncChecker.Synced() && !isOptimistic {
+	if ns.SyncChecker.Synced() {
 		return &empty.Empty{}, nil
 	}
 	if ns.SyncChecker.Syncing() || ns.SyncChecker.Initialized() {
-		// Set header for REST API clients (via gRPC-gateway)
-		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
+		if request.SyncingStatus != 0 {
+			// override the 200 success with the provided request status
+			if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(request.SyncingStatus, 10))); err != nil {
+				return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
+			}
+			return &empty.Empty{}, nil
 		}
-		return &empty.Empty{}, status.Error(codes.Unavailable, "node is syncing")
-	}
-	if isOptimistic {
-		// Set header for REST API clients (via gRPC-gateway)
 		if err := grpc.SetHeader(ctx, metadata.Pairs("x-http-code", strconv.FormatUint(http.StatusPartialContent, 10))); err != nil {
-			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set status code header: %v", err)
+			return &empty.Empty{}, status.Errorf(codes.Internal, "Could not set custom success code header: %v", err)
 		}
-		return &empty.Empty{}, status.Error(codes.Unavailable, "node is optimistic")
+		return &empty.Empty{}, nil
 	}
 	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
 }

beacon-chain/rpc/prysm/v1alpha1/node/server_test.go

@@ -2,7 +2,6 @@ package node
 
 import (
 	"errors"
-	"maps"
 	"testing"
 	"time"
 
@@ -22,7 +21,6 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -189,71 +187,32 @@ func TestNodeServer_GetETH1ConnectionStatus(t *testing.T) {
 	assert.Equal(t, errStr, res.CurrentConnectionError)
 }
 
-// mockServerTransportStream implements grpc.ServerTransportStream for testing
-type mockServerTransportStream struct {
-	headers map[string][]string
-}
-
-func (m *mockServerTransportStream) Method() string { return "" }
-func (m *mockServerTransportStream) SetHeader(md metadata.MD) error {
-	maps.Copy(m.headers, md)
-	return nil
-}
-func (m *mockServerTransportStream) SendHeader(metadata.MD) error { return nil }
-func (m *mockServerTransportStream) SetTrailer(metadata.MD) error { return nil }
-
 func TestNodeServer_GetHealth(t *testing.T) {
 	tests := []struct {
 		name         string
 		input        *mockSync.Sync
-		isOptimistic bool
+		customStatus uint64
 		wantedErr    string
 	}{
 		{
-			name:         "happy path - synced and not optimistic",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
-			isOptimistic: false,
+			name:  "happy path",
+			input: &mockSync.Sync{IsSyncing: false, IsSynced: true},
 		},
 		{
-			name:         "returns error when not synced and not syncing",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: false},
-			isOptimistic: false,
-			wantedErr:    "service unavailable",
-		},
-		{
-			name:         "returns error when syncing",
-			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
-			isOptimistic: false,
-			wantedErr:    "node is syncing",
-		},
-		{
-			name:         "returns error when synced but optimistic",
-			input:        &mockSync.Sync{IsSyncing: false, IsSynced: true},
-			isOptimistic: true,
-			wantedErr:    "node is optimistic",
-		},
-		{
-			name:         "returns error when syncing and optimistic",
-			input:        &mockSync.Sync{IsSyncing: true, IsSynced: false},
-			isOptimistic: true,
-			wantedErr:    "node is syncing",
+			name:      "syncing",
+			input:     &mockSync.Sync{IsSyncing: false},
+			wantedErr: "service unavailable",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			server := grpc.NewServer()
 			ns := &Server{
-				SyncChecker:           tt.input,
-				OptimisticModeFetcher: &mock.ChainService{Optimistic: tt.isOptimistic},
+				SyncChecker: tt.input,
 			}
 			ethpb.RegisterNodeServer(server, ns)
 			reflection.Register(server)
-
-			// Create context with mock transport stream so grpc.SetHeader works
-			stream := &mockServerTransportStream{headers: make(map[string][]string)}
-			ctx := grpc.NewContextWithServerTransportStream(t.Context(), stream)
-
-			_, err := ns.GetHealth(ctx, &ethpb.HealthRequest{})
+			_, err := ns.GetHealth(t.Context(), &ethpb.HealthRequest{SyncingStatus: tt.customStatus})
 			if tt.wantedErr == "" {
 				require.NoError(t, err)
 				return

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -42,7 +42,6 @@ go_library(
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/electra:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -70,7 +70,6 @@ type Server struct {
 	BlockReceiver           blockchain.BlockReceiver
 	BlobReceiver            blockchain.BlobReceiver
 	DataColumnReceiver      blockchain.DataColumnReceiver
-	ProofReceiver           blockchain.ProofReceiver
 	MockEth1Votes           bool
 	Eth1BlockFetcher        execution.POWBlockFetcher
 	PendingDepositsFetcher  depositsnapshot.PendingDepositsFetcher

beacon-chain/rpc/service.go

@@ -90,7 +90,6 @@ type Config struct {
 	BlockReceiver             blockchain.BlockReceiver
 	BlobReceiver              blockchain.BlobReceiver
 	DataColumnReceiver        blockchain.DataColumnReceiver
-	ProofReceiver             blockchain.ProofReceiver
 	ExecutionChainService     execution.Chain
 	ChainStartFetcher         execution.ChainStartFetcher
 	ExecutionChainInfoFetcher execution.ChainInfoFetcher
@@ -241,7 +240,6 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		BlockReceiver:           s.cfg.BlockReceiver,
 		BlobReceiver:            s.cfg.BlobReceiver,
 		DataColumnReceiver:      s.cfg.DataColumnReceiver,
-		ProofReceiver:           s.cfg.ProofReceiver,
 		MockEth1Votes:           s.cfg.MockEth1Votes,
 		Eth1BlockFetcher:        s.cfg.ExecutionChainService,
 		PendingDepositsFetcher:  s.cfg.PendingDepositFetcher,
@@ -261,19 +259,18 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 	}
 	s.validatorServer = validatorServer
 	nodeServer := &nodev1alpha1.Server{
-		LogsStreamer:          logs.NewStreamServer(),
-		StreamLogsBufferSize:  1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
-		BeaconDB:              s.cfg.BeaconDB,
-		Server:                s.grpcServer,
-		SyncChecker:           s.cfg.SyncService,
-		GenesisTimeFetcher:    s.cfg.GenesisTimeFetcher,
-		PeersFetcher:          s.cfg.PeersFetcher,
-		PeerManager:           s.cfg.PeerManager,
-		GenesisFetcher:        s.cfg.GenesisFetcher,
-		POWChainInfoFetcher:   s.cfg.ExecutionChainInfoFetcher,
-		BeaconMonitoringHost:  s.cfg.BeaconMonitoringHost,
-		BeaconMonitoringPort:  s.cfg.BeaconMonitoringPort,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		LogsStreamer:         logs.NewStreamServer(),
+		StreamLogsBufferSize: 1000, // Enough to handle bursts of beacon node logs for gRPC streaming.
+		BeaconDB:             s.cfg.BeaconDB,
+		Server:               s.grpcServer,
+		SyncChecker:          s.cfg.SyncService,
+		GenesisTimeFetcher:   s.cfg.GenesisTimeFetcher,
+		PeersFetcher:         s.cfg.PeersFetcher,
+		PeerManager:          s.cfg.PeerManager,
+		GenesisFetcher:       s.cfg.GenesisFetcher,
+		POWChainInfoFetcher:  s.cfg.ExecutionChainInfoFetcher,
+		BeaconMonitoringHost: s.cfg.BeaconMonitoringHost,
+		BeaconMonitoringPort: s.cfg.BeaconMonitoringPort,
 	}
 	beaconChainServer := &beaconv1alpha1.Server{
 		Ctx:                         s.ctx,

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/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",