fix: bazel build failure on macOS (hashtree patch) (#16281 )

**What type of PR is this?** Bug fix **What does this PR do? Why is it needed?** It appears that #16216 introduced hashtree integration but broke builds on macOS Intel (darwin_amd64). ``` Error: Undefined symbols for architecture x86_64: "_github.com/OffchainLabs/hashtree.HashtreeHash" ``` The Bazel patch for hashtree was missing `wrapper_darwin_amd64.s`. So, `//go:noescape` in `bindings.go` assumes that symbols are available elsewhere, and while on other platforms optimized version is used, on Darwin we have stub (symbol still must be available), which needs to be referenced -- hence, this PR. **Other notes for review** I've re-checked using `bazel clean && bazel build //cmd/beacon-chain` -- it was failing before, works now. cc @potuz as original patch author **Acknowledgements** - [x] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md). - [x] I have included a uniquely named [changelog fragment file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd). - [x] I have added a description with sufficient context for reviewers to understand this PR. - [x] I have tested that my changes work as expected and I added a testing plan to the PR description (if applicable). Co-authored-by: Potuz <potuz@prysmaticlabs.com>
gloas: add duty timing BPS and fork epoch gating (#16291 )
2026-01-27 14:18:13 -05:00 · 2026-01-27 16:40:29 +00:00 · 2026-01-27 15:29:37 +00:00 · 2026-01-27 13:30:52 +00:00 · 2026-01-27 10:37:23 +00:00 · 2026-01-27 03:34:12 +00:00
55 changed files with 1842 additions and 43 deletions
--- a/api/server/structs/block.go
+++ b/api/server/structs/block.go
@@ -503,3 +503,77 @@ 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
+}
--- a/api/server/structs/conversions_block.go
+++ b/api/server/structs/conversions_block.go
@@ -268,6 +268,8 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockFuluFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockFulu:
 		return SignedBeaconBlockFuluFromConsensus(pbStruct)
+	case *eth.SignedBeaconBlockGloas:
+		return SignedBeaconBlockGloasFromConsensus(pbStruct)
 	default:
 		return nil, ErrUnsupportedConversion
 	}
@@ -2885,3 +2887,379 @@ 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
+}
--- a/beacon-chain/core/gloas/BUILD.bazel
+++ b/beacon-chain/core/gloas/BUILD.bazel
@@ -4,6 +4,7 @@ go_library(
    name = "go_default_library",
    srcs = [
        "bid.go",
+        "payload_attestation.go",
        "pending_payment.go",
        "proposer_slashing.go",
    ],
@@ -14,12 +15,16 @@ go_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",
@@ -30,6 +35,7 @@ go_test(
    name = "go_default_test",
    srcs = [
        "bid_test.go",
+        "payload_attestation_test.go",
        "pending_payment_test.go",
        "proposer_slashing_test.go",
    ],
@@ -40,6 +46,7 @@ go_test(
        "//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",
@@ -50,8 +57,10 @@ go_test(
        "//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",
    ],
 )
--- a/beacon-chain/core/gloas/payload_attestation.go
+++ b/beacon-chain/core/gloas/payload_attestation.go
@@ -0,0 +1,253 @@
+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
+}
--- a/beacon-chain/core/gloas/payload_attestation_test.go
+++ b/beacon-chain/core/gloas/payload_attestation_test.go
@@ -0,0 +1,305 @@
+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)
+}
--- a/beacon-chain/db/kv/error.go
+++ b/beacon-chain/db/kv/error.go
@@ -22,6 +22,10 @@ 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")
--- a/beacon-chain/db/kv/genesis.go
+++ b/beacon-chain/db/kv/genesis.go
@@ -42,6 +42,10 @@ 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
 }

--- a/beacon-chain/db/kv/kv.go
+++ b/beacon-chain/db/kv/kv.go
@@ -203,15 +203,45 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		return nil, err
 	}

-	if features.Get().EnableStateDiff {
-		sdCache, err := newStateDiffCache(kv)
-		if err != nil {
-			return nil, err
+	if err := kv.startStateDiff(ctx); err != nil {
+		if errors.Is(err, ErrStateDiffIncompatible) {
+			return kv, err
 		}
-		kv.stateDiffCache = sdCache
+		return nil, err
+	}
+	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
 	}

-	return kv, nil
+	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.
--- a/beacon-chain/db/kv/state_diff_helpers.go
+++ b/beacon-chain/db/kv/state_diff_helpers.go
@@ -9,11 +9,13 @@ 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"
 )

@@ -122,6 +124,66 @@ 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:
--- a/beacon-chain/db/kv/wss.go
+++ b/beacon-chain/db/kv/wss.go
@@ -110,6 +110,8 @@ 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
 }
--- a/beacon-chain/node/node.go
+++ b/beacon-chain/node/node.go
@@ -535,7 +535,12 @@ 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 err != nil {
+	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 {
 		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}

--- a/beacon-chain/rpc/eth/beacon/handlers_test.go
+++ b/beacon-chain/rpc/eth/beacon/handlers_test.go
@@ -50,6 +50,14 @@ 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()
@@ -335,6 +343,50 @@ 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)
@@ -574,6 +626,37 @@ 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) {
--- a/beacon-chain/rpc/eth/config/handlers_test.go
+++ b/beacon-chain/rpc/eth/config/handlers_test.go
@@ -83,6 +83,7 @@ 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
@@ -134,6 +135,10 @@ func TestGetSpec(t *testing.T) {
 	config.AttestationDueBPS = primitives.BP(122)
 	config.AggregateDueBPS = primitives.BP(123)
 	config.ContributionDueBPS = primitives.BP(124)
+	config.AttestationDueBPSGloas = primitives.BP(126)
+	config.AggregateDueBPSGloas = primitives.BP(127)
+	config.SyncMessageDueBPSGloas = primitives.BP(128)
+	config.ContributionDueBPSGloas = primitives.BP(129)
 	config.TerminalBlockHash = common.HexToHash("TerminalBlockHash")
 	config.TerminalBlockHashActivationEpoch = 72
 	config.TerminalTotalDifficulty = "73"
@@ -197,6 +202,9 @@ func TestGetSpec(t *testing.T) {
 	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
@@ -212,7 +220,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, 186, len(data))
+	assert.Equal(t, 192, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -292,6 +300,8 @@ 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":
@@ -414,6 +424,8 @@ 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":
@@ -474,6 +486,14 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "123", v)
 			case "CONTRIBUTION_DUE_BPS":
 				assert.Equal(t, "124", v)
+			case "ATTESTATION_DUE_BPS_GLOAS":
+				assert.Equal(t, "126", v)
+			case "AGGREGATE_DUE_BPS_GLOAS":
+				assert.Equal(t, "127", v)
+			case "SYNC_MESSAGE_DUE_BPS_GLOAS":
+				assert.Equal(t, "128", v)
+			case "CONTRIBUTION_DUE_BPS_GLOAS":
+				assert.Equal(t, "129", v)
 			case "MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT":
 				assert.Equal(t, "8", v)
 			case "MAX_REQUEST_LIGHT_CLIENT_UPDATES":
--- a/beacon-chain/state/stategen/migrate.go
+++ b/beacon-chain/state/stategen/migrate.go
@@ -137,7 +137,7 @@ func (s *State) migrateToColdHdiff(ctx context.Context, fRoot [32]byte) error {
 		if ctx.Err() != nil {
 			return ctx.Err()
 		}
-		_, lvl, err := s.beaconDB.SlotInDiffTree(slot)
+		offset, lvl, err := s.beaconDB.SlotInDiffTree(slot)
 		if err != nil {
 			log.WithError(err).Errorf("could not determine if slot %d is in diff tree", slot)
 			continue
@@ -145,6 +145,9 @@ func (s *State) migrateToColdHdiff(ctx context.Context, fRoot [32]byte) error {
 		if lvl == -1 {
 			continue
 		}
+		if uint64(slot) == offset {
+			continue
+		}
 		// The state needs to be saved.
 		// Try the epoch boundary cache first.
 		cached, exists, err := s.epochBoundaryStateCache.getBySlot(slot)
--- a/changelog/bastin_path-ephemeral-log.md
+++ b/changelog/bastin_path-ephemeral-log.md
@@ -0,0 +1,3 @@
+### Ignored
+
+- Added a field `path` for the ephemeral log file initialization log.
--- a/changelog/farazdagi_fix-hashtree-darwin-amd64.md
+++ b/changelog/farazdagi_fix-hashtree-darwin-amd64.md
@@ -0,0 +1,3 @@
+### Fixed
+
+- Fix Bazel build failure on macOS x86_64 (darwin_amd64) (adds missing assembly stub to hashtree patch).
--- a/changelog/james-prysm_gloas-getblockv2-rest.md
+++ b/changelog/james-prysm_gloas-getblockv2-rest.md
@@ -0,0 +1,3 @@
+### Added
+
+- gloas block return support for /eth/v2/beacon/blocks/{block_id} and /eth/v1/beacon/blocks/{block_id}/root endpoints.
--- a/changelog/potuz_hdiff_start_db.md
+++ b/changelog/potuz_hdiff_start_db.md
@@ -0,0 +1,3 @@
+### Added
+
+- Initialize db with state-diff feature flag. 
--- a/changelog/terencechain_gloas-duty-timings.md
+++ b/changelog/terencechain_gloas-duty-timings.md
@@ -0,0 +1,2 @@
+### Added
+- Gloas-specific timing intervals for validator attestation, aggregation, and sync duties.
--- a/changelog/ttsao_add-gloas-process-payload-att.md
+++ b/changelog/ttsao_add-gloas-process-payload-att.md
@@ -0,0 +1,3 @@
+### Added
+
+- Add Gloas process payload attestation
--- a/cmd/beacon-chain/main.go
+++ b/cmd/beacon-chain/main.go
@@ -160,6 +160,7 @@ var appFlags = []cli.Flag{
 	dasFlags.BackfillOldestSlot,
 	dasFlags.BlobRetentionEpochFlag,
 	flags.BatchVerifierLimit,
+	flags.StateDiffExponents,
 	flags.DisableEphemeralLogFile,
 }

--- a/cmd/beacon-chain/usage.go
+++ b/cmd/beacon-chain/usage.go
@@ -74,6 +74,7 @@ var appHelpFlagGroups = []flagGroup{
 			flags.RPCHost,
 			flags.RPCPort,
 			flags.BatchVerifierLimit,
+			flags.StateDiffExponents,
 		},
 	},
 	{
--- a/config/features/flags.go
+++ b/config/features/flags.go
@@ -280,6 +280,7 @@ var BeaconChainFlags = combinedFlags([]cli.Flag{
 	DisableQUIC,
 	EnableDiscoveryReboot,
 	enableExperimentalAttestationPool,
+	EnableStateDiff,
 	forceHeadFlag,
 	blacklistRoots,
 	enableHashtree,
--- a/config/fieldparams/mainnet.go
+++ b/config/fieldparams/mainnet.go
@@ -50,4 +50,7 @@ const (
 	// Introduced in Fulu network upgrade.
 	NumberOfColumns = 128 // NumberOfColumns refers to the specified number of data columns that can exist in a network.
 	CellsPerBlob    = 64  // CellsPerBlob refers to the number of cells in a (non-extended) blob.
+
+	// Introduced in Gloas network upgrade.
+	PTCSize = 512 // PTCSize is the size of the payload timeliness committee.
 )
--- a/config/fieldparams/minimal.go
+++ b/config/fieldparams/minimal.go
@@ -50,4 +50,7 @@ const (
 	// Introduced in Fulu network upgrade.
 	NumberOfColumns = 128 // NumberOfColumns refers to the specified number of data columns that can exist in a network.
 	CellsPerBlob    = 64  // CellsPerBlob refers to the number of cells in a (non-extended) blob.
+
+	// Introduced in Gloas network upgrade.
+	PTCSize = 2 // PTCSize is the size of the payload timeliness committee.
 )
--- a/config/params/config.go
+++ b/config/params/config.go
@@ -91,6 +91,10 @@ type BeaconChainConfig struct {
 	AggregateDueBPS                 primitives.BP    `yaml:"AGGREGATE_DUE_BPS" spec:"true"`                   // AggregateDueBPS defines the aggregate due time in basis points of the slot.
 	SyncMessageDueBPS               primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS" spec:"true"`                // SyncMessageDueBPS defines the sync message due time in basis points of the slot.
 	ContributionDueBPS              primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS" spec:"true"`                // ContributionDueBPS defines the contribution due time in basis points of the slot.
+	AttestationDueBPSGloas          primitives.BP    `yaml:"ATTESTATION_DUE_BPS_GLOAS" spec:"true"`           // AttestationDueBPSGloas defines the attestation due time in basis points of the slot (Gloas).
+	AggregateDueBPSGloas            primitives.BP    `yaml:"AGGREGATE_DUE_BPS_GLOAS" spec:"true"`             // AggregateDueBPSGloas defines the aggregate due time in basis points of the slot (Gloas).
+	SyncMessageDueBPSGloas          primitives.BP    `yaml:"SYNC_MESSAGE_DUE_BPS_GLOAS" spec:"true"`          // SyncMessageDueBPSGloas defines the sync message due time in basis points of the slot (Gloas).
+	ContributionDueBPSGloas         primitives.BP    `yaml:"CONTRIBUTION_DUE_BPS_GLOAS" spec:"true"`          // ContributionDueBPSGloas defines the contribution due time in basis points of the slot (Gloas).

 	// Ethereum PoW parameters.
 	DepositChainID         uint64 `yaml:"DEPOSIT_CHAIN_ID" spec:"true"`         // DepositChainID of the eth1 network. This used for replay protection.
@@ -142,6 +146,7 @@ type BeaconChainConfig struct {
 	DomainApplicationBuilder          [4]byte `yaml:"DOMAIN_APPLICATION_BUILDER" spec:"true"`            // DomainApplicationBuilder defines the BLS signature domain for application builder.
 	DomainBLSToExecutionChange        [4]byte `yaml:"DOMAIN_BLS_TO_EXECUTION_CHANGE" spec:"true"`        // DomainBLSToExecutionChange defines the BLS signature domain to change withdrawal addresses to ETH1 prefix
 	DomainBeaconBuilder               [4]byte `yaml:"DOMAIN_BEACON_BUILDER" spec:"true"`                 // DomainBeaconBuilder defines the BLS signature domain for beacon block builder.
+	DomainPTCAttester                 [4]byte `yaml:"DOMAIN_PTC_ATTESTER" spec:"true"`                   // DomainPTCAttester defines the BLS signature domain for payload transaction committee attester.

 	// Prysm constants.
 	GenesisValidatorsRoot          [32]byte        // GenesisValidatorsRoot is the root hash of the genesis validators.
@@ -187,6 +192,7 @@ type BeaconChainConfig struct {
 	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for electra.
 	FuluForkVersion      []byte           `yaml:"FULU_FORK_VERSION" spec:"true"`      // FuluForkVersion is used to represent the fork version for fulu.
 	FuluForkEpoch        primitives.Epoch `yaml:"FULU_FORK_EPOCH" spec:"true"`        // FuluForkEpoch is used to represent the assigned fork epoch for fulu.
+	GloasForkEpoch       primitives.Epoch `yaml:"GLOAS_FORK_EPOCH" spec:"true"`       // GloasForkEpoch is used to represent the assigned fork epoch for gloas.

 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -342,6 +348,7 @@ func (b *BeaconChainConfig) VersionToForkEpochMap() map[int]primitives.Epoch {
 		version.Deneb:     b.DenebForkEpoch,
 		version.Electra:   b.ElectraForkEpoch,
 		version.Fulu:      b.FuluForkEpoch,
+		version.Gloas:     b.GloasForkEpoch,
 	}
 }

--- a/config/params/loader.go
+++ b/config/params/loader.go
@@ -224,6 +224,7 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("ELECTRA_FORK_VERSION: %#x", cfg.ElectraForkVersion),
 		fmt.Sprintf("FULU_FORK_EPOCH: %d", cfg.FuluForkEpoch),
 		fmt.Sprintf("FULU_FORK_VERSION: %#x", cfg.FuluForkVersion),
+		fmt.Sprintf("GLOAS_FORK_EPOCH: %d", cfg.GloasForkEpoch),
 		fmt.Sprintf("EPOCHS_PER_SUBNET_SUBSCRIPTION: %d", cfg.EpochsPerSubnetSubscription),
 		fmt.Sprintf("ATTESTATION_SUBNET_EXTRA_BITS: %d", cfg.AttestationSubnetExtraBits),
 		fmt.Sprintf("ATTESTATION_SUBNET_PREFIX_BITS: %d", cfg.AttestationSubnetPrefixBits),
@@ -246,6 +247,10 @@ func ConfigToYaml(cfg *BeaconChainConfig) []byte {
 		fmt.Sprintf("AGGREGATE_DUE_BPS: %d", cfg.AggregateDueBPS),
 		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS: %d", cfg.SyncMessageDueBPS),
 		fmt.Sprintf("CONTRIBUTION_DUE_BPS: %d", cfg.ContributionDueBPS),
+		fmt.Sprintf("ATTESTATION_DUE_BPS_GLOAS: %d", cfg.AttestationDueBPSGloas),
+		fmt.Sprintf("AGGREGATE_DUE_BPS_GLOAS: %d", cfg.AggregateDueBPSGloas),
+		fmt.Sprintf("SYNC_MESSAGE_DUE_BPS_GLOAS: %d", cfg.SyncMessageDueBPSGloas),
+		fmt.Sprintf("CONTRIBUTION_DUE_BPS_GLOAS: %d", cfg.ContributionDueBPSGloas),
 	}

 	if len(cfg.BlobSchedule) > 0 {
--- a/config/params/loader_test.go
+++ b/config/params/loader_test.go
@@ -24,12 +24,9 @@ import (
 // These are variables that we don't use in Prysm. (i.e. future hardfork, light client... etc)
 // IMPORTANT: Use one field per line and sort these alphabetically to reduce conflicts.
 var placeholderFields = []string{
-	"AGGREGATE_DUE_BPS_GLOAS",
 	"ATTESTATION_DEADLINE",
-	"ATTESTATION_DUE_BPS_GLOAS",
 	"BLOB_SIDECAR_SUBNET_COUNT_FULU",
 	"CELLS_PER_EXT_BLOB",
-	"CONTRIBUTION_DUE_BPS_GLOAS",
 	"EIP6110_FORK_EPOCH",
 	"EIP6110_FORK_VERSION",
 	"EIP7002_FORK_EPOCH",
@@ -45,7 +42,6 @@ var placeholderFields = []string{
 	"EPOCHS_PER_SHUFFLING_PHASE",
 	"FIELD_ELEMENTS_PER_CELL",     // Configured as a constant in config/fieldparams/mainnet.go
 	"FIELD_ELEMENTS_PER_EXT_BLOB", // Configured in proto/ssz_proto_library.bzl
-	"GLOAS_FORK_EPOCH",
 	"GLOAS_FORK_VERSION",
 	"INCLUSION_LIST_SUBMISSION_DEADLINE",
 	"INCLUSION_LIST_SUBMISSION_DUE_BPS",
@@ -60,7 +56,6 @@ var placeholderFields = []string{
 	"PROPOSER_INCLUSION_LIST_CUTOFF",
 	"PROPOSER_INCLUSION_LIST_CUTOFF_BPS",
 	"PROPOSER_SELECTION_GAP",
-	"SYNC_MESSAGE_DUE_BPS_GLOAS",
 	"TARGET_NUMBER_OF_PEERS",
 	"UPDATE_TIMEOUT",
 	"VIEW_FREEZE_CUTOFF_BPS",
--- a/config/params/mainnet_config.go
+++ b/config/params/mainnet_config.go
@@ -32,6 +32,8 @@ const (
 	mainnetElectraForkEpoch = 364032 // May 7, 2025, 10:05:11 UTC
 	// Fulu Fork Epoch for mainnet config
 	mainnetFuluForkEpoch = 411392 // December 3, 2025, 09:49:11pm UTC
+	// Gloas Fork Epoch for mainnet config
+	mainnetGloasForkEpoch = math.MaxUint64
 )

 var mainnetNetworkConfig = &NetworkConfig{
@@ -121,11 +123,15 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	IntervalsPerSlot:                3,

 	// Time-based protocol parameters.
-	ProposerReorgCutoffBPS: primitives.BP(1667),
-	AttestationDueBPS:      primitives.BP(3333),
-	AggregateDueBPS:        primitives.BP(6667),
-	SyncMessageDueBPS:      primitives.BP(3333),
-	ContributionDueBPS:     primitives.BP(6667),
+	ProposerReorgCutoffBPS:  primitives.BP(1667),
+	AttestationDueBPS:       primitives.BP(3333),
+	AggregateDueBPS:         primitives.BP(6667),
+	SyncMessageDueBPS:       primitives.BP(3333),
+	ContributionDueBPS:      primitives.BP(6667),
+	AttestationDueBPSGloas:  primitives.BP(2500),
+	AggregateDueBPSGloas:    primitives.BP(5000),
+	SyncMessageDueBPSGloas:  primitives.BP(2500),
+	ContributionDueBPSGloas: primitives.BP(5000),

 	// Ethereum PoW parameters.
 	DepositChainID:         1, // Chain ID of eth1 mainnet.
@@ -185,6 +191,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainApplicationBuilder:          bytesutil.Uint32ToBytes4(0x00000001),
 	DomainBLSToExecutionChange:        bytesutil.Uint32ToBytes4(0x0A000000),
 	DomainBeaconBuilder:               bytesutil.Uint32ToBytes4(0x0B000000),
+	DomainPTCAttester:                 bytesutil.Uint32ToBytes4(0x0C000000),

 	// Prysm constants.
 	GenesisValidatorsRoot:          [32]byte{75, 54, 61, 185, 78, 40, 97, 32, 215, 110, 185, 5, 52, 15, 221, 78, 84, 191, 233, 240, 107, 243, 63, 246, 207, 90, 210, 127, 81, 27, 254, 149},
@@ -234,6 +241,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	ElectraForkEpoch:     mainnetElectraForkEpoch,
 	FuluForkVersion:      []byte{6, 0, 0, 0},
 	FuluForkEpoch:        mainnetFuluForkEpoch,
+	GloasForkEpoch:       mainnetGloasForkEpoch,

 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.
--- a/config/params/minimal_config.go
+++ b/config/params/minimal_config.go
@@ -35,6 +35,10 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	// Time parameters
 	minimalConfig.SecondsPerSlot = 6
 	minimalConfig.SlotDurationMilliseconds = 6000
+	minimalConfig.AttestationDueBPSGloas = 2500
+	minimalConfig.AggregateDueBPSGloas = 5000
+	minimalConfig.SyncMessageDueBPSGloas = 2500
+	minimalConfig.ContributionDueBPSGloas = 5000
 	minimalConfig.MinAttestationInclusionDelay = 1
 	minimalConfig.SlotsPerEpoch = 8
 	minimalConfig.SqrRootSlotsPerEpoch = 2
@@ -98,6 +102,7 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.ElectraForkEpoch = math.MaxUint64
 	minimalConfig.FuluForkVersion = []byte{6, 0, 0, 1}
 	minimalConfig.FuluForkEpoch = math.MaxUint64
+	minimalConfig.GloasForkEpoch = minimalConfig.FarFutureEpoch

 	minimalConfig.SyncCommitteeSize = 32
 	minimalConfig.InactivityScoreBias = 4
--- a/consensus-types/BUILD.bazel
+++ b/consensus-types/BUILD.bazel
@@ -2,10 +2,15 @@ load("@prysm//tools/go:def.bzl", "go_library")

 go_library(
    name = "go_default_library",
-    srcs = ["types.go"],
+    srcs = [
+        "indexed_payload_attestation.go",
+        "types.go",
+    ],
    importpath = "github.com/OffchainLabs/prysm/v7/consensus-types",
    visibility = ["//visibility:public"],
    deps = [
+        "//consensus-types/primitives:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
        "//runtime/version:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
    ],
--- a/consensus-types/indexed_payload_attestation.go
+++ b/consensus-types/indexed_payload_attestation.go
@@ -0,0 +1,36 @@
+package consensus_types
+
+import (
+	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+)
+
+type IndexedPayloadAttestation struct {
+	AttestingIndices []primitives.ValidatorIndex
+	Data             *eth.PayloadAttestationData
+	Signature        []byte
+}
+
+// GetAttestingIndices returns the attesting indices or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetAttestingIndices() []primitives.ValidatorIndex {
+	if x == nil {
+		return nil
+	}
+	return x.AttestingIndices
+}
+
+// GetData returns the attestation data or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetData() *eth.PayloadAttestationData {
+	if x == nil {
+		return nil
+	}
+	return x.Data
+}
+
+// GetSignature returns the signature bytes or nil when the receiver is nil.
+func (x *IndexedPayloadAttestation) GetSignature() []byte {
+	if x == nil {
+		return nil
+	}
+	return x.Signature
+}
--- a/io/logs/logutil.go
+++ b/io/logs/logutil.go
@@ -103,7 +103,7 @@ func ConfigureEphemeralLogFile(datadirPath string, app string) error {
 		AllowedLevels: logrus.AllLevels[:ephemeralLogFileVerbosity+1],
 	})

-	logrus.Debug("Ephemeral log file initialized")
+	logrus.WithField("path", logFilePath).Debug("Ephemeral log file initialized")
 	return nil
 }

--- a/testing/endtoend/BUILD.bazel
+++ b/testing/endtoend/BUILD.bazel
@@ -97,6 +97,7 @@ go_test(
        "endtoend_setup_test.go",
        "endtoend_test.go",
        "minimal_e2e_test.go",
+        "minimal_hdiff_e2e_test.go",
        "minimal_slashing_e2e_test.go",
        "slasher_simulator_e2e_test.go",
    ],
--- a/testing/endtoend/minimal_hdiff_e2e_test.go
+++ b/testing/endtoend/minimal_hdiff_e2e_test.go
@@ -0,0 +1,16 @@
+package endtoend
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	"github.com/OffchainLabs/prysm/v7/testing/endtoend/types"
+)
+
+func TestEndToEnd_MinimalConfig_WithStateDiff(t *testing.T) {
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()),
+		types.WithStateDiff(),
+	)
+	r.run()
+}
--- a/testing/endtoend/types/types.go
+++ b/testing/endtoend/types/types.go
@@ -76,6 +76,15 @@ func WithSSZOnly() E2EConfigOpt {
 	}
 }

+func WithStateDiff() E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.BeaconFlags = append(cfg.BeaconFlags,
+			"--enable-state-diff",
+			"--state-diff-exponents=6,5", // Small exponents for quick testing
+		)
+	}
+}
+
 // WithExitEpoch sets a custom epoch for voluntary exit submission.
 // This affects ProposeVoluntaryExit, ValidatorsHaveExited, SubmitWithdrawal, and ValidatorsHaveWithdrawn evaluators.
 func WithExitEpoch(e primitives.Epoch) E2EConfigOpt {
--- a/testing/spectest/mainnet/BUILD.bazel
+++ b/testing/spectest/mainnet/BUILD.bazel
@@ -202,6 +202,7 @@ go_test(
        "fulu__ssz_static__ssz_static_test.go",
        "gloas__epoch_processing__process_builder_pending_payments_test.go",
        "gloas__operations__execution_payload_header_test.go",
+        "gloas__operations__payload_attestation_test.go",
        "gloas__operations__proposer_slashing_test.go",
        "gloas__sanity__slots_test.go",
        "gloas__ssz_static__ssz_static_test.go",
--- a/testing/spectest/mainnet/gloasoperationspayload_attestation_test.go
+++ b/testing/spectest/mainnet/gloasoperationspayload_attestation_test.go
@@ -0,0 +1,11 @@
+package mainnet
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
+)
+
+func TestMainnet_Gloas_Operations_PayloadAttestation(t *testing.T) {
+	operations.RunPayloadAttestationTest(t, "mainnet")
+}
--- a/testing/spectest/minimal/BUILD.bazel
+++ b/testing/spectest/minimal/BUILD.bazel
@@ -208,6 +208,7 @@ go_test(
        "fulu__ssz_static__ssz_static_test.go",
        "gloas__epoch_processing__process_builder_pending_payments_test.go",
        "gloas__operations__execution_payload_bid_test.go",
+        "gloas__operations__payload_attestation_test.go",
        "gloas__operations__proposer_slashing_test.go",
        "gloas__sanity__slots_test.go",
        "gloas__ssz_static__ssz_static_test.go",
--- a/testing/spectest/minimal/gloasoperationspayload_attestation_test.go
+++ b/testing/spectest/minimal/gloasoperationspayload_attestation_test.go
@@ -0,0 +1,11 @@
+package minimal
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
+)
+
+func TestMinimal_Gloas_Operations_PayloadAttestation(t *testing.T) {
+	operations.RunPayloadAttestationTest(t, "minimal")
+}
--- a/testing/spectest/shared/common/operations/BUILD.bazel
+++ b/testing/spectest/shared/common/operations/BUILD.bazel
@@ -13,6 +13,7 @@ go_library(
        "deposit_request.go",
        "execution_payload.go",
        "execution_payload_bid.go",
+        "payload_attestation.go",
        "proposer_slashing.go",
        "slashing.go",
        "sync_aggregate.go",
--- a/testing/spectest/shared/common/operations/payload_attestation.go
+++ b/testing/spectest/shared/common/operations/payload_attestation.go
@@ -0,0 +1,122 @@
+package operations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	eth "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/golang/snappy"
+)
+
+type PayloadAttestationOperation func(ctx context.Context, s state.BeaconState, att *eth.PayloadAttestation) (state.BeaconState, error)
+
+func RunPayloadAttestationTest(t *testing.T, config string, fork string, sszToState SSZToState) {
+	runPayloadAttestationTest(t, config, fork, "payload_attestation", sszToState, func(ctx context.Context, s state.BeaconState, att *eth.PayloadAttestation) (state.BeaconState, error) {
+		// Create a mock block body with the payload attestation
+		body, err := createMockBlockBodyWithPayloadAttestation(att)
+		if err != nil {
+			return s, err
+		}
+		// Wrap the protobuf body in the interface
+		wrappedBody, err := blocks.NewBeaconBlockBody(body)
+		if err != nil {
+			return s, err
+		}
+		err = gloas.ProcessPayloadAttestations(ctx, s, wrappedBody)
+		return s, err
+	})
+}
+
+func runPayloadAttestationTest(t *testing.T, config string, fork string, objName string, sszToState SSZToState, operationFn PayloadAttestationOperation) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, fork, "operations/"+objName+"/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, fork, "operations/"+objName+"/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+			folderPath := path.Join(testsFolderPath, folder.Name())
+
+			// Load payload attestation from payload_attestation.ssz_snappy
+			attestationFile, err := util.BazelFileBytes(folderPath, "payload_attestation.ssz_snappy")
+			require.NoError(t, err)
+			attestationSSZ, err := snappy.Decode(nil /* dst */, attestationFile)
+			require.NoError(t, err, "Failed to decompress payload attestation")
+
+			// Unmarshal payload attestation
+			att := &eth.PayloadAttestation{}
+			err = att.UnmarshalSSZ(attestationSSZ)
+			require.NoError(t, err, "Failed to unmarshal payload attestation")
+
+			runPayloadAttestationOperationTest(t, folderPath, att, sszToState, operationFn)
+		})
+	}
+}
+
+// runPayloadAttestationOperationTest runs a single payload attestation operation test
+func runPayloadAttestationOperationTest(t *testing.T, folderPath string, att *eth.PayloadAttestation, sszToState SSZToState, operationFn PayloadAttestationOperation) {
+	preBeaconStateFile, err := util.BazelFileBytes(folderPath, "pre.ssz_snappy")
+	require.NoError(t, err)
+	preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	beaconState, err := sszToState(preBeaconStateSSZ)
+	require.NoError(t, err)
+
+	// Check if post state exists
+	postStateExists := true
+	postBeaconStateFile, err := util.BazelFileBytes(folderPath, "post.ssz_snappy")
+	if err != nil {
+		postStateExists = false
+	}
+
+	ctx := t.Context()
+	resultState, err := operationFn(ctx, beaconState, att)
+
+	if postStateExists {
+		// Test should succeed
+		require.NoError(t, err, "Operation should succeed")
+
+		// Compare with expected post state
+		postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+		require.NoError(t, err, "Failed to decompress post state")
+		expectedState, err := sszToState(postBeaconStateSSZ)
+		require.NoError(t, err)
+
+		expectedRoot, err := expectedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		resultRoot, err := resultState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		require.DeepEqual(t, expectedRoot, resultRoot, "Post state does not match expected")
+	} else {
+		// Test should fail (no post.ssz_snappy means the operation should error)
+		require.NotNil(t, err, "Operation should fail but succeeded")
+	}
+}
+
+// createMockBlockBodyWithPayloadAttestation creates a mock block body containing the payload attestation
+func createMockBlockBodyWithPayloadAttestation(att *eth.PayloadAttestation) (*eth.BeaconBlockBodyGloas, error) {
+	body := &eth.BeaconBlockBodyGloas{
+		PayloadAttestations: []*eth.PayloadAttestation{att},
+		// Default values
+		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{},
+	}
+	return body, nil
+}
--- a/testing/spectest/shared/gloas/operations/BUILD.bazel
+++ b/testing/spectest/shared/gloas/operations/BUILD.bazel
@@ -6,6 +6,7 @@ go_library(
    srcs = [
        "execution_payload_bid.go",
        "helpers.go",
+        "payload_attestation.go",
        "proposer_slashing.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
--- a/testing/spectest/shared/gloas/operations/helpers.go
+++ b/testing/spectest/shared/gloas/operations/helpers.go
@@ -15,7 +15,6 @@ func sszToState(b []byte) (state.BeaconState, error) {
 	}
 	return state_native.InitializeFromProtoGloas(base)
 }
-
 func sszToBlock(b []byte) (interfaces.SignedBeaconBlock, error) {
 	base := &ethpb.BeaconBlockGloas{}
 	if err := base.UnmarshalSSZ(b); err != nil {
--- a/testing/spectest/shared/gloas/operations/payload_attestation.go
+++ b/testing/spectest/shared/gloas/operations/payload_attestation.go
@@ -0,0 +1,12 @@
+package operations
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	common "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/common/operations"
+)
+
+func RunPayloadAttestationTest(t *testing.T, config string) {
+	common.RunPayloadAttestationTest(t, config, version.String(version.Gloas), sszToState)
+}
--- a/testing/util/block.go
+++ b/testing/util/block.go
@@ -1473,3 +1473,185 @@ func HydrateBlindedBeaconBlockBodyFulu(b *ethpb.BlindedBeaconBlockBodyElectra) *
 	b.ExecutionRequests = HydrateExecutionRequests(b.ExecutionRequests)
 	return b
 }
+
+// HydrateSignedBeaconBlockGloas hydrates a signed beacon block with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateSignedBeaconBlockGloas(b *ethpb.SignedBeaconBlockGloas) *ethpb.SignedBeaconBlockGloas {
+	if b == nil {
+		b = &ethpb.SignedBeaconBlockGloas{}
+	}
+	if b.Signature == nil {
+		b.Signature = make([]byte, fieldparams.BLSSignatureLength)
+	}
+	b.Block = HydrateBeaconBlockGloas(b.Block)
+	return b
+}
+
+// HydrateBeaconBlockGloas hydrates a beacon block with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateBeaconBlockGloas(b *ethpb.BeaconBlockGloas) *ethpb.BeaconBlockGloas {
+	if b == nil {
+		b = &ethpb.BeaconBlockGloas{}
+	}
+	if b.ParentRoot == nil {
+		b.ParentRoot = make([]byte, fieldparams.RootLength)
+	}
+	if b.StateRoot == nil {
+		b.StateRoot = make([]byte, fieldparams.RootLength)
+	}
+	b.Body = HydrateBeaconBlockBodyGloas(b.Body)
+	return b
+}
+
+// HydrateBeaconBlockBodyGloas hydrates a beacon block body with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateBeaconBlockBodyGloas(b *ethpb.BeaconBlockBodyGloas) *ethpb.BeaconBlockBodyGloas {
+	if b == nil {
+		b = &ethpb.BeaconBlockBodyGloas{}
+	}
+	if b.RandaoReveal == nil {
+		b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
+	}
+	if b.Graffiti == nil {
+		b.Graffiti = make([]byte, fieldparams.RootLength)
+	}
+	if b.Eth1Data == nil {
+		b.Eth1Data = &ethpb.Eth1Data{
+			DepositRoot: make([]byte, fieldparams.RootLength),
+			BlockHash:   make([]byte, fieldparams.RootLength),
+		}
+	}
+	if b.SyncAggregate == nil {
+		b.SyncAggregate = &ethpb.SyncAggregate{
+			SyncCommitteeBits:      make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
+			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+		}
+	}
+	b.SignedExecutionPayloadBid = HydrateSignedExecutionPayloadBid(b.SignedExecutionPayloadBid)
+	if b.PayloadAttestations == nil {
+		b.PayloadAttestations = make([]*ethpb.PayloadAttestation, 0)
+	}
+	return b
+}
+
+// HydrateSignedExecutionPayloadBid hydrates a signed execution payload bid with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateSignedExecutionPayloadBid(b *ethpb.SignedExecutionPayloadBid) *ethpb.SignedExecutionPayloadBid {
+	if b == nil {
+		b = &ethpb.SignedExecutionPayloadBid{}
+	}
+	if b.Signature == nil {
+		b.Signature = make([]byte, fieldparams.BLSSignatureLength)
+	}
+	b.Message = HydrateExecutionPayloadBid(b.Message)
+	return b
+}
+
+// HydrateExecutionPayloadBid hydrates an execution payload bid with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateExecutionPayloadBid(b *ethpb.ExecutionPayloadBid) *ethpb.ExecutionPayloadBid {
+	if b == nil {
+		b = &ethpb.ExecutionPayloadBid{}
+	}
+	if b.ParentBlockHash == nil {
+		b.ParentBlockHash = make([]byte, fieldparams.RootLength)
+	}
+	if b.ParentBlockRoot == nil {
+		b.ParentBlockRoot = make([]byte, fieldparams.RootLength)
+	}
+	if b.BlockHash == nil {
+		b.BlockHash = make([]byte, fieldparams.RootLength)
+	}
+	if b.PrevRandao == nil {
+		b.PrevRandao = make([]byte, fieldparams.RootLength)
+	}
+	if b.FeeRecipient == nil {
+		b.FeeRecipient = make([]byte, fieldparams.FeeRecipientLength)
+	}
+	if b.BlobKzgCommitmentsRoot == nil {
+		b.BlobKzgCommitmentsRoot = make([]byte, fieldparams.RootLength)
+	}
+	return b
+}
+
+// HydratePayloadAttestation hydrates a payload attestation with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydratePayloadAttestation(p *ethpb.PayloadAttestation) *ethpb.PayloadAttestation {
+	if p == nil {
+		p = &ethpb.PayloadAttestation{}
+	}
+	if p.AggregationBits == nil {
+		p.AggregationBits = make([]byte, 64)
+	}
+	if p.Signature == nil {
+		p.Signature = make([]byte, fieldparams.BLSSignatureLength)
+	}
+	p.Data = HydratePayloadAttestationData(p.Data)
+	return p
+}
+
+// HydratePayloadAttestationData hydrates a payload attestation data with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydratePayloadAttestationData(d *ethpb.PayloadAttestationData) *ethpb.PayloadAttestationData {
+	if d == nil {
+		d = &ethpb.PayloadAttestationData{}
+	}
+	if d.BeaconBlockRoot == nil {
+		d.BeaconBlockRoot = make([]byte, fieldparams.RootLength)
+	}
+	return d
+}
+
+// GenerateTestPayloadAttestations generates a slice of payload attestations with non-zero test values.
+// This is useful for testing Gloas-specific fields.
+func GenerateTestPayloadAttestations(count int, slot primitives.Slot) []*ethpb.PayloadAttestation {
+	attestations := make([]*ethpb.PayloadAttestation, count)
+	for i := range count {
+		aggregationBits := make([]byte, 64)
+		aggregationBits[0] = 0x01 // Set at least one bit
+		signature := make([]byte, fieldparams.BLSSignatureLength)
+		signature[0] = byte(i + 1) // Make each signature unique
+		beaconBlockRoot := make([]byte, fieldparams.RootLength)
+		beaconBlockRoot[0] = byte(i + 1) // Make each root unique
+
+		attestations[i] = &ethpb.PayloadAttestation{
+			AggregationBits: aggregationBits,
+			Signature:       signature,
+			Data: &ethpb.PayloadAttestationData{
+				BeaconBlockRoot:   beaconBlockRoot,
+				Slot:              slot,
+				PayloadPresent:    true,
+				BlobDataAvailable: true,
+			},
+		}
+	}
+	return attestations
+}
+
+// GenerateTestSignedExecutionPayloadBid generates a signed execution payload bid with non-zero test values.
+// This is useful for testing Gloas-specific fields.
+func GenerateTestSignedExecutionPayloadBid(slot primitives.Slot) *ethpb.SignedExecutionPayloadBid {
+	parentBlockHash := bytesutil.PadTo([]byte{0x01}, fieldparams.RootLength)
+	parentBlockRoot := bytesutil.PadTo([]byte{0x02}, fieldparams.RootLength)
+	blockHash := bytesutil.PadTo([]byte{0x03}, fieldparams.RootLength)
+	prevRandao := bytesutil.PadTo([]byte{0x04}, fieldparams.RootLength)
+	feeRecipient := bytesutil.PadTo([]byte{0x05}, fieldparams.FeeRecipientLength)
+	blobKzgRoot := bytesutil.PadTo([]byte{0x06}, fieldparams.RootLength)
+	signature := bytesutil.PadTo([]byte{0x07}, fieldparams.BLSSignatureLength)
+
+	return &ethpb.SignedExecutionPayloadBid{
+		Message: &ethpb.ExecutionPayloadBid{
+			Slot:                   slot,
+			BuilderIndex:           1,
+			ParentBlockHash:        parentBlockHash,
+			ParentBlockRoot:        parentBlockRoot,
+			BlockHash:              blockHash,
+			GasLimit:               30000000,
+			PrevRandao:             prevRandao,
+			FeeRecipient:           feeRecipient,
+			Value:                  1000000,
+			BlobKzgCommitmentsRoot: blobKzgRoot,
+		},
+		Signature: signature,
+	}
+}
--- a/testing/util/block_test.go
+++ b/testing/util/block_test.go
@@ -348,3 +348,81 @@ func Test_PostDenebPbGenericBlock_ErrorsForPlainBlock(t *testing.T) {
 		require.ErrorContains(t, "PbGenericBlock() only supports block content type but got", err)
 	})
 }
+
+func TestHydrateSignedBeaconBlockGloas_NoError(t *testing.T) {
+	b := &ethpbalpha.SignedBeaconBlockGloas{}
+	b = HydrateSignedBeaconBlockGloas(b)
+	_, err := b.HashTreeRoot()
+	require.NoError(t, err)
+	_, err = b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	_, err = b.Block.Body.HashTreeRoot()
+	require.NoError(t, err)
+}
+
+func TestHydratePayloadAttestation_NoError(t *testing.T) {
+	p := &ethpbalpha.PayloadAttestation{}
+	p = HydratePayloadAttestation(p)
+	_, err := p.HashTreeRoot()
+	require.NoError(t, err)
+	_, err = p.Data.HashTreeRoot()
+	require.NoError(t, err)
+}
+
+func TestGenerateTestPayloadAttestations(t *testing.T) {
+	slot := primitives.Slot(123)
+	attestations := GenerateTestPayloadAttestations(3, slot)
+
+	require.Equal(t, 3, len(attestations))
+	for i, att := range attestations {
+		// Verify non-nil fields
+		require.NotNil(t, att.AggregationBits)
+		require.NotNil(t, att.Signature)
+		require.NotNil(t, att.Data)
+		require.NotNil(t, att.Data.BeaconBlockRoot)
+
+		// Verify slot is set correctly
+		require.Equal(t, slot, att.Data.Slot)
+
+		// Verify PayloadPresent and BlobDataAvailable are set
+		require.Equal(t, true, att.Data.PayloadPresent)
+		require.Equal(t, true, att.Data.BlobDataAvailable)
+
+		// Verify unique values
+		require.Equal(t, byte(i+1), att.Signature[0])
+		require.Equal(t, byte(i+1), att.Data.BeaconBlockRoot[0])
+
+		// Verify HashTreeRoot works
+		_, err := att.HashTreeRoot()
+		require.NoError(t, err)
+	}
+}
+
+func TestGenerateTestSignedExecutionPayloadBid(t *testing.T) {
+	slot := primitives.Slot(456)
+	bid := GenerateTestSignedExecutionPayloadBid(slot)
+
+	require.NotNil(t, bid)
+	require.NotNil(t, bid.Message)
+	require.NotNil(t, bid.Signature)
+
+	// Verify slot is set correctly
+	require.Equal(t, slot, bid.Message.Slot)
+
+	// Verify non-zero test values
+	require.Equal(t, primitives.BuilderIndex(1), bid.Message.BuilderIndex)
+	require.Equal(t, uint64(30000000), bid.Message.GasLimit)
+	require.Equal(t, primitives.Gwei(1000000), bid.Message.Value)
+
+	// Verify fields are populated
+	require.NotNil(t, bid.Message.ParentBlockHash)
+	require.NotNil(t, bid.Message.ParentBlockRoot)
+	require.NotNil(t, bid.Message.BlockHash)
+	require.NotNil(t, bid.Message.PrevRandao)
+	require.NotNil(t, bid.Message.FeeRecipient)
+	require.NotNil(t, bid.Message.BlobKzgCommitmentsRoot)
+
+	// Verify HashTreeRoot works
+	_, err := bid.HashTreeRoot()
+	require.NoError(t, err)
+}
--- a/testing/util/merge.go
+++ b/testing/util/merge.go
@@ -88,3 +88,12 @@ func NewBeaconBlockContentsFulu() *ethpb.SignedBeaconBlockContentsFulu {
 func NewBlindedBeaconBlockFulu() *ethpb.SignedBlindedBeaconBlockFulu {
 	return HydrateSignedBlindedBeaconBlockFulu(&ethpb.SignedBlindedBeaconBlockFulu{})
 }
+
+// ----------------------------------------------------------------------------
+// Gloas
+// ----------------------------------------------------------------------------
+
+// NewBeaconBlockGloas creates a beacon block with minimum marshalable fields.
+func NewBeaconBlockGloas() *ethpb.SignedBeaconBlockGloas {
+	return HydrateSignedBeaconBlockGloas(&ethpb.SignedBeaconBlockGloas{})
+}
--- a/third_party/com_github_offchainlabs_hashtree.patch
+++ b/third_party/com_github_offchainlabs_hashtree.patch
@@ -1,7 +1,7 @@
 diff -urN a/BUILD.bazel b/BUILD.bazel
 --- a/BUILD.bazel	1969-12-31 18:00:00.000000000 -0600
 +++ b/BUILD.bazel	2025-01-05 12:00:00.000000000 -0600
-@@ -0,0 +1,89 @@
+@@ -0,0 +1,90 @@
 +load("@io_bazel_rules_go//go:def.bzl", "go_library")
 +
 +go_library(
@@ -32,6 +32,7 @@ diff -urN a/BUILD.bazel b/BUILD.bazel
 +        ],
 +        "@io_bazel_rules_go//go/platform:darwin_amd64": [
 +            "bindings_darwin_amd64.go",
+            "wrapper_darwin_amd64.s",
 +        ],
 +        "//conditions:default": [],
 +    }),
--- a/validator/client/aggregate.go
+++ b/validator/client/aggregate.go
@@ -66,7 +66,7 @@ func (v *validator) SubmitAggregateAndProof(ctx context.Context, slot primitives
 	// As specified in spec, an aggregator should wait until two thirds of the way through slot
 	// to broadcast the best aggregate to the global aggregate channel.
 	// https://github.com/ethereum/consensus-specs/blob/v0.9.3/specs/validator/0_beacon-chain-validator.md#broadcast-aggregate
-	v.waitToSlotTwoThirds(ctx, slot)
+	v.waitUntilAggregateDue(ctx, slot)

 	// In a DV setup, selection proofs need to be agreed upon by the DV.
 	// Checking for selection proofs at slot 0 of the epoch will result in an error, as the call to the DV executes slower than the start of this function.
@@ -203,11 +203,18 @@ func (v *validator) signSlotWithSelectionProof(ctx context.Context, pubKey [fiel
 	return sig.Marshal(), nil
 }

-// waitToSlotTwoThirds waits until two third through the current slot period
-// such that any attestations from this slot have time to reach the beacon node
-// before creating the aggregated attestation.
-func (v *validator) waitToSlotTwoThirds(ctx context.Context, slot primitives.Slot) {
-	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().AggregateDueBPS)
+// waitUntilAggregateDue waits until the configured aggregation due time within the current slot
+// such that any attestations from this slot have time to reach the beacon node before creating
+// the aggregated attestation.
+//
+// Note: Historically this was ~2/3 of the slot, but may differ across forks (e.g. Gloas).
+func (v *validator) waitUntilAggregateDue(ctx context.Context, slot primitives.Slot) {
+	cfg := params.BeaconConfig()
+	component := cfg.AggregateDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.AggregateDueBPSGloas
+	}
+	v.waitUntilSlotComponent(ctx, slot, component)
 }

 // This returns the signature of validator signing over aggregate and
--- a/validator/client/aggregate_test.go
+++ b/validator/client/aggregate_test.go
@@ -260,7 +260,7 @@ func TestWaitForSlotTwoThird_WaitCorrectly(t *testing.T) {
 			timeToSleep := params.BeaconConfig().SlotComponentDuration(params.BeaconConfig().AggregateDueBPS)

 			twoThirdTime := currentTime.Add(timeToSleep)
-			validator.waitToSlotTwoThirds(t.Context(), numOfSlots)
+			validator.waitUntilAggregateDue(t.Context(), numOfSlots)
 			currentTime = time.Now()
 			assert.Equal(t, twoThirdTime.Unix(), currentTime.Unix())
 		})
@@ -280,7 +280,7 @@ func TestWaitForSlotTwoThird_DoneContext_ReturnsImmediately(t *testing.T) {
 			expectedTime := time.Now()
 			ctx, cancel := context.WithCancel(t.Context())
 			cancel()
-			validator.waitToSlotTwoThirds(ctx, numOfSlots)
+			validator.waitUntilAggregateDue(ctx, numOfSlots)
 			currentTime = time.Now()
 			assert.Equal(t, expectedTime.Unix(), currentTime.Unix())
 		})
--- a/validator/client/attest.go
+++ b/validator/client/attest.go
@@ -37,7 +37,7 @@ func (v *validator) SubmitAttestation(ctx context.Context, slot primitives.Slot,
 	defer span.End()
 	span.SetAttributes(trace.StringAttribute("validator", fmt.Sprintf("%#x", pubKey)))

-	v.waitOneThirdOrValidBlock(ctx, slot)
+	v.waitUntilAttestationDueOrValidBlock(ctx, slot)

 	var b strings.Builder
 	if err := b.WriteByte(byte(iface.RoleAttester)); err != nil {
@@ -259,12 +259,12 @@ func (v *validator) setHighestSlot(slot primitives.Slot) {
 	}
 }

-// waitOneThirdOrValidBlock waits until (a) or (b) whichever comes first:
+// waitUntilAttestationDueOrValidBlock waits until (a) or (b) whichever comes first:
 //
 //	(a) the validator has received a valid block that is the same slot as input slot
-//	(b) one-third of the slot has transpired (SECONDS_PER_SLOT / 3 seconds after the start of slot)
-func (v *validator) waitOneThirdOrValidBlock(ctx context.Context, slot primitives.Slot) {
-	ctx, span := trace.StartSpan(ctx, "validator.waitOneThirdOrValidBlock")
+//	(b) the configured attestation due time has transpired (as basis points of the slot duration)
+func (v *validator) waitUntilAttestationDueOrValidBlock(ctx context.Context, slot primitives.Slot) {
+	ctx, span := trace.StartSpan(ctx, "validator.waitUntilAttestationDueOrValidBlock")
 	defer span.End()

 	// Don't need to wait if requested slot is the same as highest valid slot.
@@ -272,7 +272,12 @@ func (v *validator) waitOneThirdOrValidBlock(ctx context.Context, slot primitive
 		return
 	}

-	finalTime, err := v.slotComponentDeadline(slot, params.BeaconConfig().AttestationDueBPS)
+	cfg := params.BeaconConfig()
+	component := cfg.AttestationDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.AttestationDueBPSGloas
+	}
+	finalTime, err := v.slotComponentDeadline(slot, component)
 	if err != nil {
 		log.WithError(err).WithField("slot", slot).Error("Slot overflows, unable to wait for attestation deadline")
 		return
--- a/validator/client/attest_test.go
+++ b/validator/client/attest_test.go
@@ -706,7 +706,7 @@ func TestServer_WaitToSlotOneThird_CanWait(t *testing.T) {

 	timeToSleep := params.BeaconConfig().SecondsPerSlot / 3
 	oneThird := currentTime.Add(time.Duration(timeToSleep) * time.Second)
-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)

 	if oneThird.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", oneThird, currentTime)
@@ -724,7 +724,7 @@ func TestServer_WaitToSlotOneThird_SameReqSlot(t *testing.T) {
 		highestValidSlot: currentSlot,
 	}

-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)

 	if currentTime.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", time.Now(), currentTime)
@@ -750,7 +750,7 @@ func TestServer_WaitToSlotOneThird_ReceiveBlockSlot(t *testing.T) {
 		v.slotFeed.Send(currentSlot)
 	})

-	v.waitOneThirdOrValidBlock(t.Context(), currentSlot)
+	v.waitUntilAttestationDueOrValidBlock(t.Context(), currentSlot)

 	if currentTime.Sub(time.Now()) > 10*time.Millisecond { // Allow for small diff due to execution time.
 		t.Errorf("Wanted %s time for slot one third but got %s", time.Now(), currentTime)
--- a/validator/client/sync_committee.go
+++ b/validator/client/sync_committee.go
@@ -29,7 +29,7 @@ func (v *validator) SubmitSyncCommitteeMessage(ctx context.Context, slot primiti
 	defer span.End()
 	span.SetAttributes(trace.StringAttribute("validator", fmt.Sprintf("%#x", pubKey)))

-	v.waitOneThirdOrValidBlock(ctx, slot)
+	v.waitUntilAttestationDueOrValidBlock(ctx, slot)

 	res, err := v.validatorClient.SyncMessageBlockRoot(ctx, &emptypb.Empty{})
 	if err != nil {
@@ -127,7 +127,12 @@ func (v *validator) SubmitSignedContributionAndProof(ctx context.Context, slot p
 		return
 	}

-	v.waitUntilSlotComponent(ctx, slot, params.BeaconConfig().ContributionDueBPS)
+	cfg := params.BeaconConfig()
+	component := cfg.ContributionDueBPS
+	if slots.ToEpoch(slot) >= cfg.GloasForkEpoch {
+		component = cfg.ContributionDueBPSGloas
+	}
+	v.waitUntilSlotComponent(ctx, slot, component)

 	coveredSubnets := make(map[uint64]bool)
 	for i, comIdx := range indexRes.Indices {
--- a/validator/client/wait_helpers.go
+++ b/validator/client/wait_helpers.go
@@ -51,12 +51,20 @@ func (v *validator) slotComponentSpanName(component primitives.BP) string {
 	switch component {
 	case cfg.AttestationDueBPS:
 		return "validator.waitAttestationWindow"
+	case cfg.AttestationDueBPSGloas:
+		return "validator.waitAttestationWindow"
 	case cfg.AggregateDueBPS:
 		return "validator.waitAggregateWindow"
+	case cfg.AggregateDueBPSGloas:
+		return "validator.waitAggregateWindow"
 	case cfg.SyncMessageDueBPS:
 		return "validator.waitSyncMessageWindow"
+	case cfg.SyncMessageDueBPSGloas:
+		return "validator.waitSyncMessageWindow"
 	case cfg.ContributionDueBPS:
 		return "validator.waitContributionWindow"
+	case cfg.ContributionDueBPSGloas:
+		return "validator.waitContributionWindow"
 	case cfg.ProposerReorgCutoffBPS:
 		return "validator.waitProposerReorgWindow"
 	default:
Author	SHA1	Message	Date
Victor Farazdagi	1c65c8866a	fix: bazel build failure on macOS (hashtree patch) (#16281 ) What type of PR is this? Bug fix What does this PR do? Why is it needed? It appears that #16216 introduced hashtree integration but broke builds on macOS Intel (darwin_amd64). ``` Error: Undefined symbols for architecture x86_64: "_github.com/OffchainLabs/hashtree.HashtreeHash" ``` The Bazel patch for hashtree was missing `wrapper_darwin_amd64.s`. So, `//go:noescape` in `bindings.go` assumes that symbols are available elsewhere, and while on other platforms optimized version is used, on Darwin we have stub (symbol still must be available), which needs to be referenced -- hence, this PR. Other notes for review I've re-checked using `bazel clean && bazel build //cmd/beacon-chain` -- it was failing before, works now. cc @potuz as original patch author Acknowledgements - [x] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md). - [x] I have included a uniquely named [changelog fragment file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd). - [x] I have added a description with sufficient context for reviewers to understand this PR. - [x] I have tested that my changes work as expected and I added a testing plan to the PR description (if applicable). Co-authored-by: Potuz <potuz@prysmaticlabs.com>	2026-01-27 16:40:29 +00:00
terence	14a4b97d57	gloas: add duty timing BPS and fork epoch gating (#16291 ) This PR adds gloas specific time basis points for validator duties (attestation, aggregation, and sync contribution) and wires the validator client to use them once `GloasForkEpoch` is active. For now, `GloasForkEpoch` is set to far-future so behavior is unchanged until the fork epoch is configured Note to the rev: today sync message duty uses `waitOneThirdOrValidBlock` which shares with attestation dead line, that's why sync message bps is not used	2026-01-27 15:29:37 +00:00
Potuz	0e537694c3	Hdiff start database (#16203 ) Initialize state-diff database on new node startup When starting a node with --enable-state-diff feature flag, the database is now initialized appropriately based on the startup scenario: - New database + checkpoint sync: Set offset to checkpoint state slot, save checkpoint state as full snapshot - New database + genesis sync: Set offset to 0, save genesis state as full snapshot - Existing database without state-diff: Log warning that feature is ignored due to old schema - Existing database with state-diff: Return error (restarts will be handled in a future PR) Review after #16049 has merged --------- Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com> Co-authored-by: Bastin <43618253+Inspector-Butters@users.noreply.github.com>	2026-01-27 13:30:52 +00:00
Bastin	1b190e966e	add path field for ephemeral log file initialization (#16289 ) What does this PR do? Why is it needed? Add a field `path` to the initialization log of ephemeral-logfile feature: before: ``` [2026-01-26 19:49:34.64] DEBUG Ephemeral log file initialized ``` after: ``` [2026-01-26 19:49:34.64] DEBUG Ephemeral log file initialized path=../eth/datadir/logs/beacon-chain.log ```	2026-01-27 10:37:23 +00:00
terence	2cbb743606	gloas: add new payload attestation processing (#15650 ) This PR implements [process_payload_attestation](https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/beacon-chain.md#new-process_payload_attestation) and spec tests	2026-01-27 03:34:12 +00:00
james-prysm	ce9c968dcc	adding gloas block support to /eth/v2/beacon/blocks/{block_id} and /eth/v1/beacon/blocks/{block_id}/root (#16278 ) What type of PR is this? Feature What does this PR do? Why is it needed? adding gloas block return on `/eth/v2/beacon/blocks/{block_id}` endpoint - [/eth/v1/beacon/blocks/{block_id}/root](https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlockRoot) should inherit this as well reference https://github.com/ethereum/beacon-APIs/pull/552/files#r2722805266 Which issues(s) does this PR fix? Fixes # Other notes for review Acknowledgements - [x] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md). - [x] I have included a uniquely named [changelog fragment file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd). - [x] I have added a description with sufficient context for reviewers to understand this PR. - [x] I have tested that my changes work as expected and I added a testing plan to the PR description (if applicable).	2026-01-27 00:02:16 +00:00