Light Client: Electra finality branch

api/server/structs/conversions_lightclient.go

@@ -20,29 +20,39 @@ func LightClientUpdateFromConsensus(update interfaces.LightClientUpdate) (*Light
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal finalized light client header")
 	}
-	finalityBranch := update.FinalityBranch()
 
 	var scBranch [][32]byte
+	var finalityBranch [][32]byte
 	if update.Version() >= version.Electra {
-		b, err := update.NextSyncCommitteeBranchElectra()
+		scb, err := update.NextSyncCommitteeBranchElectra()
 		if err != nil {
 			return nil, err
 		}
-		scBranch = b[:]
+		scBranch = scb[:]
+		fb, err := update.FinalityBranchElectra()
+		if err != nil {
+			return nil, err
+		}
+		finalityBranch = fb[:]
 	} else {
 		b, err := update.NextSyncCommitteeBranch()
 		if err != nil {
 			return nil, err
 		}
 		scBranch = b[:]
+		fb, err := update.FinalityBranch()
+		if err != nil {
+			return nil, err
+		}
+		finalityBranch = fb[:]
 	}
 
 	return &LightClientUpdate{
 		AttestedHeader:          attestedHeader,
 		NextSyncCommittee:       SyncCommitteeFromConsensus(update.NextSyncCommittee()),
 		NextSyncCommitteeBranch: branchToJSON(scBranch),
 		FinalizedHeader:         finalizedHeader,
-		FinalityBranch:          branchToJSON(finalityBranch[:]),
+		FinalityBranch:          branchToJSON(finalityBranch),
 		SyncAggregate:           SyncAggregateFromConsensus(update.SyncAggregate()),
 		SignatureSlot:           fmt.Sprintf("%d", update.SignatureSlot()),
 	}, nil
@@ -57,12 +67,26 @@ func LightClientFinalityUpdateFromConsensus(update interfaces.LightClientFinalit
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal finalized light client header")
 	}
-	finalityBranch := update.FinalityBranch()
+
+	var finalityBranch [][32]byte
+	if update.Version() >= version.Electra {
+		b, err := update.FinalityBranchElectra()
+		if err != nil {
+			return nil, err
+		}
+		finalityBranch = b[:]
+	} else {
+		b, err := update.FinalityBranch()
+		if err != nil {
+			return nil, err
+		}
+		finalityBranch = b[:]
+	}
 
 	return &LightClientFinalityUpdate{
 		AttestedHeader:  attestedHeader,
 		FinalizedHeader: finalizedHeader,
-		FinalityBranch:  branchToJSON(finalityBranch[:]),
+		FinalityBranch:  branchToJSON(finalityBranch),
 		SyncAggregate:   SyncAggregateFromConsensus(update.SyncAggregate()),
 		SignatureSlot:   fmt.Sprintf("%d", update.SignatureSlot()),
 	}, nil

beacon-chain/core/light-client/lightclient.go

@@ -23,10 +23,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-const (
-	FinalityBranchNumOfLeaves = 6
-)
-
 func NewLightClientFinalityUpdateFromBeaconState(
 	ctx context.Context,
 	currentSlot primitives.Slot,
@@ -159,7 +155,7 @@ func NewLightClientUpdateFromBeaconState(
 	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedBlock.Block().Slot()))
 
 	// update = LightClientUpdate()
-	result, err := CreateDefaultLightClientUpdate(currentSlot)
+	result, err := CreateDefaultLightClientUpdate(currentSlot, attestedBlock)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not create default light client update")
 	}
@@ -243,7 +239,7 @@ func NewLightClientUpdateFromBeaconState(
 	return result, nil
 }
 
-func CreateDefaultLightClientUpdate(currentSlot primitives.Slot) (interfaces.LightClientUpdate, error) {
+func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientUpdate, error) {
 	currentEpoch := slots.ToEpoch(currentSlot)
 
 	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
@@ -270,8 +266,14 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot) (interfaces.Lig
 	for i := 0; i < fieldparams.ExecutionBranchDepth; i++ {
 		executionBranch[i] = make([]byte, 32)
 	}
-	finalityBranch := make([][]byte, fieldparams.FinalityBranchDepth)
-	for i := 0; i < fieldparams.FinalityBranchDepth; i++ {
+
+	var finalityBranch [][]byte
+	if attestedBlock.Version() >= version.Electra {
+		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepthElectra)
+	} else {
+		finalityBranch = make([][]byte, fieldparams.FinalityBranchDepth)
+	}
+	for i := 0; i < len(finalityBranch); i++ {
 		finalityBranch[i] = make([]byte, 32)
 	}
 
@@ -308,15 +310,28 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot) (interfaces.Lig
 			FinalityBranch:          finalityBranch,
 		}
 	} else {
-		m = &pb.LightClientUpdateElectra{
-			AttestedHeader: &pb.LightClientHeaderDeneb{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
-				ExecutionBranch: executionBranch,
-			},
-			NextSyncCommittee:       nextSyncCommittee,
-			NextSyncCommitteeBranch: nextSyncCommitteeBranch,
-			FinalityBranch:          finalityBranch,
+		if attestedBlock.Version() >= version.Electra {
+			m = &pb.LightClientUpdateElectra{
+				AttestedHeader: &pb.LightClientHeaderDeneb{
+					Beacon:          &pb.BeaconBlockHeader{},
+					Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+					ExecutionBranch: executionBranch,
+				},
+				NextSyncCommittee:       nextSyncCommittee,
+				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+				FinalityBranch:          finalityBranch,
+			}
+		} else {
+			m = &pb.LightClientUpdateDeneb{
+				AttestedHeader: &pb.LightClientHeaderDeneb{
+					Beacon:          &pb.BeaconBlockHeader{},
+					Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+					ExecutionBranch: executionBranch,
+				},
+				NextSyncCommittee:       nextSyncCommittee,
+				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
+				FinalityBranch:          finalityBranch,
+			}
 		}
 	}
 

beacon-chain/rpc/eth/light-client/helpers.go

@@ -6,17 +6,17 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 
 	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -147,8 +147,20 @@ func HasRelevantSyncCommittee(update interfaces.LightClientUpdate) (bool, error)
 	return !reflect.DeepEqual(branch, interfaces.LightClientSyncCommitteeBranch{}), nil
 }
 
-func HasFinality(update interfaces.LightClientUpdate) bool {
-	return !reflect.DeepEqual(update.FinalityBranch(), interfaces.LightClientFinalityBranch{})
+func HasFinality(update interfaces.LightClientUpdate) (bool, error) {
+	if update.Version() >= version.Electra {
+		b, err := update.FinalityBranchElectra()
+		if err != nil {
+			return false, err
+		}
+		return !reflect.DeepEqual(b, interfaces.LightClientFinalityBranchElectra{}), nil
+	}
+
+	b, err := update.FinalityBranch()
+	if err != nil {
+		return false, err
+	}
+	return !reflect.DeepEqual(b, interfaces.LightClientFinalityBranch{}), nil
 }
 
 func IsBetterUpdate(newUpdate, oldUpdate interfaces.LightClientUpdate) (bool, error) {
@@ -187,8 +199,14 @@ func IsBetterUpdate(newUpdate, oldUpdate interfaces.LightClientUpdate) (bool, er
 	}
 
 	// Compare indication of any finality
-	newHasFinality := HasFinality(newUpdate)
-	oldHasFinality := HasFinality(oldUpdate)
+	newHasFinality, err := HasFinality(newUpdate)
+	if err != nil {
+		return false, err
+	}
+	oldHasFinality, err := HasFinality(oldUpdate)
+	if err != nil {
+		return false, err
+	}
 	if newHasFinality != oldHasFinality {
 		return newHasFinality, nil
 	}

config/fieldparams/mainnet.go

@@ -37,6 +37,7 @@ const (
 	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
 	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
 	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
+	FinalityBranchDepthElectra            = 7             // FinalityBranchDepthElectra defines the number of leaves in a merkle proof of the finalized checkpoint root.
 	PendingDepositsLimit                  = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 134217728     // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 262144        // Maximum number of pending consolidations in the beacon state.

consensus-types/interfaces/light_client.go

@@ -12,6 +12,7 @@ type LightClientExecutionBranch = [fieldparams.ExecutionBranchDepth][fieldparams
 type LightClientSyncCommitteeBranch = [fieldparams.SyncCommitteeBranchDepth][fieldparams.RootLength]byte
 type LightClientSyncCommitteeBranchElectra = [fieldparams.SyncCommitteeBranchDepthElectra][fieldparams.RootLength]byte
 type LightClientFinalityBranch = [fieldparams.FinalityBranchDepth][fieldparams.RootLength]byte
+type LightClientFinalityBranchElectra = [fieldparams.FinalityBranchDepthElectra][fieldparams.RootLength]byte
 
 type LightClientHeader interface {
 	ssz.Marshaler
@@ -45,7 +46,8 @@ type LightClientUpdate interface {
 	SetNextSyncCommitteeBranchElectra(branch [][]byte) error
 	FinalizedHeader() LightClientHeader
 	SetFinalizedHeader(header LightClientHeader) error
-	FinalityBranch() LightClientFinalityBranch
+	FinalityBranch() (LightClientFinalityBranch, error)
+	FinalityBranchElectra() (LightClientFinalityBranchElectra, error)
 	SetFinalityBranch(branch [][]byte) error
 	SyncAggregate() *pb.SyncAggregate
 	SetSyncAggregate(sa *pb.SyncAggregate)
@@ -59,7 +61,8 @@ type LightClientFinalityUpdate interface {
 	Version() int
 	AttestedHeader() LightClientHeader
 	FinalizedHeader() LightClientHeader
-	FinalityBranch() LightClientFinalityBranch
+	FinalityBranch() (LightClientFinalityBranch, error)
+	FinalityBranchElectra() (LightClientFinalityBranchElectra, error)
 	SyncAggregate() *pb.SyncAggregate
 	SignatureSlot() primitives.Slot
 }

consensus-types/light-client/BUILD.bazel

@@ -14,13 +14,15 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//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",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

consensus-types/light-client/bootstrap.go

@@ -41,7 +41,7 @@ func NewWrappedBootstrapAltair(p *pb.LightClientBootstrapAltair) (interfaces.Lig
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderAltair(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -105,7 +105,7 @@ func NewWrappedBootstrapCapella(p *pb.LightClientBootstrapCapella) (interfaces.L
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderCapella(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -169,7 +169,7 @@ func NewWrappedBootstrapDeneb(p *pb.LightClientBootstrapDeneb) (interfaces.Light
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderDeneb(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}
@@ -233,7 +233,7 @@ func NewWrappedBootstrapElectra(p *pb.LightClientBootstrapElectra) (interfaces.L
 	if p == nil {
 		return nil, consensustypes.ErrNilObjectWrapped
 	}
-	header, err := NewWrappedHeaderDeneb(p.Header)
+	header, err := NewWrappedHeader(p.Header)
 	if err != nil {
 		return nil, err
 	}