Light Client consensus types (#14518)

* protos/SSZ

* interfaces

* types

* cleanup/dedup

* changelog

* use createBranch in headers

* error handling

---------

Co-authored-by: rkapka <radoslaw.kapka@gmail.com>

consensus-types/light-client/BUILD.bazel

@@ -0,0 +1,26 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bootstrap.go",
+        "finality_update.go",
+        "header.go",
+        "helpers.go",
+        "optimistic_update.go",
+        "update.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//config/fieldparams: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",
+        "@org_golang_google_protobuf//proto:go_default_library",
+    ],
+)

consensus-types/light-client/bootstrap.go

@@ -0,0 +1,208 @@
+package light_client
+
+import (
+	"fmt"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+func NewWrappedBootstrap(m proto.Message) (interfaces.LightClientBootstrap, error) {
+	if m == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	switch t := m.(type) {
+	case *pb.LightClientBootstrapAltair:
+		return NewWrappedBootstrapAltair(t)
+	case *pb.LightClientBootstrapCapella:
+		return NewWrappedBootstrapCapella(t)
+	case *pb.LightClientBootstrapDeneb:
+		return NewWrappedBootstrapDeneb(t)
+	default:
+		return nil, fmt.Errorf("cannot construct light client bootstrap from type %T", t)
+	}
+}
+
+type bootstrapAltair struct {
+	p                          *pb.LightClientBootstrapAltair
+	header                     interfaces.LightClientHeader
+	currentSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+}
+
+var _ interfaces.LightClientBootstrap = &bootstrapAltair{}
+
+func NewWrappedBootstrapAltair(p *pb.LightClientBootstrapAltair) (interfaces.LightClientBootstrap, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	header, err := NewWrappedHeaderAltair(p.Header)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.CurrentSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &bootstrapAltair{
+		p:                          p,
+		header:                     header,
+		currentSyncCommitteeBranch: branch,
+	}, nil
+}
+
+func (h *bootstrapAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *bootstrapAltair) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *bootstrapAltair) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *bootstrapAltair) Version() int {
+	return version.Altair
+}
+
+func (h *bootstrapAltair) Header() interfaces.LightClientHeader {
+	return h.header
+}
+
+func (h *bootstrapAltair) CurrentSyncCommittee() *pb.SyncCommittee {
+	return h.p.CurrentSyncCommittee
+}
+
+func (h *bootstrapAltair) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return h.currentSyncCommitteeBranch
+}
+
+type bootstrapCapella struct {
+	p                          *pb.LightClientBootstrapCapella
+	header                     interfaces.LightClientHeader
+	currentSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+}
+
+var _ interfaces.LightClientBootstrap = &bootstrapCapella{}
+
+func NewWrappedBootstrapCapella(p *pb.LightClientBootstrapCapella) (interfaces.LightClientBootstrap, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	header, err := NewWrappedHeaderCapella(p.Header)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.CurrentSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &bootstrapCapella{
+		p:                          p,
+		header:                     header,
+		currentSyncCommitteeBranch: branch,
+	}, nil
+}
+
+func (h *bootstrapCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *bootstrapCapella) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *bootstrapCapella) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *bootstrapCapella) Version() int {
+	return version.Capella
+}
+
+func (h *bootstrapCapella) Header() interfaces.LightClientHeader {
+	return h.header
+}
+
+func (h *bootstrapCapella) CurrentSyncCommittee() *pb.SyncCommittee {
+	return h.p.CurrentSyncCommittee
+}
+
+func (h *bootstrapCapella) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return h.currentSyncCommitteeBranch
+}
+
+type bootstrapDeneb struct {
+	p                          *pb.LightClientBootstrapDeneb
+	header                     interfaces.LightClientHeader
+	currentSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+}
+
+var _ interfaces.LightClientBootstrap = &bootstrapDeneb{}
+
+func NewWrappedBootstrapDeneb(p *pb.LightClientBootstrapDeneb) (interfaces.LightClientBootstrap, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	header, err := NewWrappedHeaderDeneb(p.Header)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.CurrentSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &bootstrapDeneb{
+		p:                          p,
+		header:                     header,
+		currentSyncCommitteeBranch: branch,
+	}, nil
+}
+
+func (h *bootstrapDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *bootstrapDeneb) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *bootstrapDeneb) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *bootstrapDeneb) Version() int {
+	return version.Deneb
+}
+
+func (h *bootstrapDeneb) Header() interfaces.LightClientHeader {
+	return h.header
+}
+
+func (h *bootstrapDeneb) CurrentSyncCommittee() *pb.SyncCommittee {
+	return h.p.CurrentSyncCommittee
+}
+
+func (h *bootstrapDeneb) CurrentSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return h.currentSyncCommitteeBranch
+}

consensus-types/light-client/finality_update.go

@@ -0,0 +1,251 @@
+package light_client
+
+import (
+	"fmt"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+func NewWrappedFinalityUpdate(m proto.Message) (interfaces.LightClientFinalityUpdate, error) {
+	if m == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	switch t := m.(type) {
+	case *pb.LightClientFinalityUpdateAltair:
+		return NewWrappedFinalityUpdateAltair(t)
+	case *pb.LightClientFinalityUpdateCapella:
+		return NewWrappedFinalityUpdateCapella(t)
+	case *pb.LightClientFinalityUpdateDeneb:
+		return NewWrappedFinalityUpdateDeneb(t)
+	default:
+		return nil, fmt.Errorf("cannot construct light client finality update from type %T", t)
+	}
+}
+
+type finalityUpdateAltair struct {
+	p               *pb.LightClientFinalityUpdateAltair
+	attestedHeader  interfaces.LightClientHeader
+	finalizedHeader interfaces.LightClientHeader
+	finalityBranch  interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientFinalityUpdate = &finalityUpdateAltair{}
+
+func NewWrappedFinalityUpdateAltair(p *pb.LightClientFinalityUpdateAltair) (interfaces.LightClientFinalityUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderAltair(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderAltair(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &finalityUpdateAltair{
+		p:               p,
+		attestedHeader:  attestedHeader,
+		finalizedHeader: finalizedHeader,
+		finalityBranch:  branch,
+	}, nil
+}
+
+func (u *finalityUpdateAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *finalityUpdateAltair) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *finalityUpdateAltair) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *finalityUpdateAltair) Version() int {
+	return version.Altair
+}
+
+func (u *finalityUpdateAltair) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *finalityUpdateAltair) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *finalityUpdateAltair) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *finalityUpdateAltair) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *finalityUpdateAltair) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type finalityUpdateCapella struct {
+	p               *pb.LightClientFinalityUpdateCapella
+	attestedHeader  interfaces.LightClientHeader
+	finalizedHeader interfaces.LightClientHeader
+	finalityBranch  interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientFinalityUpdate = &finalityUpdateCapella{}
+
+func NewWrappedFinalityUpdateCapella(p *pb.LightClientFinalityUpdateCapella) (interfaces.LightClientFinalityUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderCapella(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderCapella(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &finalityUpdateCapella{
+		p:               p,
+		attestedHeader:  attestedHeader,
+		finalizedHeader: finalizedHeader,
+		finalityBranch:  branch,
+	}, nil
+}
+
+func (u *finalityUpdateCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *finalityUpdateCapella) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *finalityUpdateCapella) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *finalityUpdateCapella) Version() int {
+	return version.Capella
+}
+
+func (u *finalityUpdateCapella) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *finalityUpdateCapella) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *finalityUpdateCapella) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *finalityUpdateCapella) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *finalityUpdateCapella) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type finalityUpdateDeneb struct {
+	p               *pb.LightClientFinalityUpdateDeneb
+	attestedHeader  interfaces.LightClientHeader
+	finalizedHeader interfaces.LightClientHeader
+	finalityBranch  interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientFinalityUpdate = &finalityUpdateDeneb{}
+
+func NewWrappedFinalityUpdateDeneb(p *pb.LightClientFinalityUpdateDeneb) (interfaces.LightClientFinalityUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &finalityUpdateDeneb{
+		p:               p,
+		attestedHeader:  attestedHeader,
+		finalizedHeader: finalizedHeader,
+		finalityBranch:  branch,
+	}, nil
+}
+
+func (u *finalityUpdateDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *finalityUpdateDeneb) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *finalityUpdateDeneb) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *finalityUpdateDeneb) Version() int {
+	return version.Deneb
+}
+
+func (u *finalityUpdateDeneb) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *finalityUpdateDeneb) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *finalityUpdateDeneb) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *finalityUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *finalityUpdateDeneb) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}

consensus-types/light-client/header.go

@@ -0,0 +1,192 @@
+package light_client
+
+import (
+	"fmt"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+func NewWrappedHeader(m proto.Message) (interfaces.LightClientHeader, error) {
+	if m == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	switch t := m.(type) {
+	case *pb.LightClientHeaderAltair:
+		return NewWrappedHeaderAltair(t)
+	case *pb.LightClientHeaderCapella:
+		return NewWrappedHeaderCapella(t)
+	case *pb.LightClientHeaderDeneb:
+		return NewWrappedHeaderDeneb(t)
+	default:
+		return nil, fmt.Errorf("cannot construct light client header from type %T", t)
+	}
+}
+
+type headerAltair struct {
+	p *pb.LightClientHeaderAltair
+}
+
+var _ interfaces.LightClientHeader = &headerAltair{}
+
+func NewWrappedHeaderAltair(p *pb.LightClientHeaderAltair) (interfaces.LightClientHeader, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	return &headerAltair{p: p}, nil
+}
+
+func (h *headerAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *headerAltair) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *headerAltair) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *headerAltair) Version() int {
+	return version.Altair
+}
+
+func (h *headerAltair) Beacon() *pb.BeaconBlockHeader {
+	return h.p.Beacon
+}
+
+func (h *headerAltair) Execution() (interfaces.ExecutionData, error) {
+	return nil, consensustypes.ErrNotSupported("Execution", version.Altair)
+}
+
+func (h *headerAltair) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
+	return interfaces.LightClientExecutionBranch{}, consensustypes.ErrNotSupported("ExecutionBranch", version.Altair)
+}
+
+type headerCapella struct {
+	p               *pb.LightClientHeaderCapella
+	execution       interfaces.ExecutionData
+	executionBranch interfaces.LightClientExecutionBranch
+}
+
+var _ interfaces.LightClientHeader = &headerCapella{}
+
+func NewWrappedHeaderCapella(p *pb.LightClientHeaderCapella) (interfaces.LightClientHeader, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	execution, err := blocks.WrappedExecutionPayloadHeaderCapella(p.Execution)
+	if err != nil {
+		return nil, err
+	}
+
+	branch, err := createBranch[interfaces.LightClientExecutionBranch](
+		"execution",
+		p.ExecutionBranch,
+		fieldparams.ExecutionBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &headerCapella{
+		p:               p,
+		execution:       execution,
+		executionBranch: branch,
+	}, nil
+}
+
+func (h *headerCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *headerCapella) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *headerCapella) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *headerCapella) Version() int {
+	return version.Capella
+}
+
+func (h *headerCapella) Beacon() *pb.BeaconBlockHeader {
+	return h.p.Beacon
+}
+
+func (h *headerCapella) Execution() (interfaces.ExecutionData, error) {
+	return h.execution, nil
+}
+
+func (h *headerCapella) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
+	return h.executionBranch, nil
+}
+
+type headerDeneb struct {
+	p               *pb.LightClientHeaderDeneb
+	execution       interfaces.ExecutionData
+	executionBranch interfaces.LightClientExecutionBranch
+}
+
+var _ interfaces.LightClientHeader = &headerDeneb{}
+
+func NewWrappedHeaderDeneb(p *pb.LightClientHeaderDeneb) (interfaces.LightClientHeader, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	execution, err := blocks.WrappedExecutionPayloadHeaderDeneb(p.Execution)
+	if err != nil {
+		return nil, err
+	}
+
+	branch, err := createBranch[interfaces.LightClientExecutionBranch](
+		"execution",
+		p.ExecutionBranch,
+		fieldparams.ExecutionBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &headerDeneb{
+		p:               p,
+		execution:       execution,
+		executionBranch: branch,
+	}, nil
+}
+
+func (h *headerDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return h.p.MarshalSSZTo(dst)
+}
+
+func (h *headerDeneb) MarshalSSZ() ([]byte, error) {
+	return h.p.MarshalSSZ()
+}
+
+func (h *headerDeneb) SizeSSZ() int {
+	return h.p.SizeSSZ()
+}
+
+func (h *headerDeneb) Version() int {
+	return version.Deneb
+}
+
+func (h *headerDeneb) Beacon() *pb.BeaconBlockHeader {
+	return h.p.Beacon
+}
+
+func (h *headerDeneb) Execution() (interfaces.ExecutionData, error) {
+	return h.execution, nil
+}
+
+func (h *headerDeneb) ExecutionBranch() (interfaces.LightClientExecutionBranch, error) {
+	return h.executionBranch, nil
+}

consensus-types/light-client/helpers.go

@@ -0,0 +1,30 @@
+package light_client
+
+import (
+	"fmt"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+)
+
+type branchConstraint interface {
+	~interfaces.LightClientExecutionBranch | ~interfaces.LightClientSyncCommitteeBranch | ~interfaces.LightClientFinalityBranch
+}
+
+func createBranch[T branchConstraint](name string, input [][]byte, depth int) (T, error) {
+	var zero T
+
+	if len(input) != depth {
+		return zero, fmt.Errorf("%s branch has %d leaves instead of expected %d", name, len(input), depth)
+	}
+	var branch T
+	for i, leaf := range input {
+		if len(leaf) != fieldparams.RootLength {
+			return zero, fmt.Errorf("%s branch leaf at index %d has length %d instead of expected %d", name, i, len(leaf), fieldparams.RootLength)
+		}
+		branch[i] = bytesutil.ToBytes32(leaf)
+	}
+
+	return branch, nil
+}

consensus-types/light-client/optimistic_update.go

@@ -0,0 +1,178 @@
+package light_client
+
+import (
+	"fmt"
+
+	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+func NewWrappedOptimisticUpdate(m proto.Message) (interfaces.LightClientOptimisticUpdate, error) {
+	if m == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	switch t := m.(type) {
+	case *pb.LightClientOptimisticUpdateAltair:
+		return NewWrappedOptimisticUpdateAltair(t)
+	case *pb.LightClientOptimisticUpdateCapella:
+		return NewWrappedOptimisticUpdateCapella(t)
+	case *pb.LightClientOptimisticUpdateDeneb:
+		return NewWrappedOptimisticUpdateDeneb(t)
+	default:
+		return nil, fmt.Errorf("cannot construct light client optimistic update from type %T", t)
+	}
+}
+
+type OptimisticUpdateAltair struct {
+	p              *pb.LightClientOptimisticUpdateAltair
+	attestedHeader interfaces.LightClientHeader
+}
+
+var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateAltair{}
+
+func NewWrappedOptimisticUpdateAltair(p *pb.LightClientOptimisticUpdateAltair) (interfaces.LightClientOptimisticUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderAltair(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OptimisticUpdateAltair{
+		p:              p,
+		attestedHeader: attestedHeader,
+	}, nil
+}
+
+func (u *OptimisticUpdateAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *OptimisticUpdateAltair) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *OptimisticUpdateAltair) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *OptimisticUpdateAltair) Version() int {
+	return version.Altair
+}
+
+func (u *OptimisticUpdateAltair) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *OptimisticUpdateAltair) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *OptimisticUpdateAltair) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type OptimisticUpdateCapella struct {
+	p              *pb.LightClientOptimisticUpdateCapella
+	attestedHeader interfaces.LightClientHeader
+}
+
+var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateCapella{}
+
+func NewWrappedOptimisticUpdateCapella(p *pb.LightClientOptimisticUpdateCapella) (interfaces.LightClientOptimisticUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderCapella(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OptimisticUpdateCapella{
+		p:              p,
+		attestedHeader: attestedHeader,
+	}, nil
+}
+
+func (u *OptimisticUpdateCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *OptimisticUpdateCapella) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *OptimisticUpdateCapella) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *OptimisticUpdateCapella) Version() int {
+	return version.Capella
+}
+
+func (u *OptimisticUpdateCapella) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *OptimisticUpdateCapella) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *OptimisticUpdateCapella) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type OptimisticUpdateDeneb struct {
+	p              *pb.LightClientOptimisticUpdateDeneb
+	attestedHeader interfaces.LightClientHeader
+}
+
+var _ interfaces.LightClientOptimisticUpdate = &OptimisticUpdateDeneb{}
+
+func NewWrappedOptimisticUpdateDeneb(p *pb.LightClientOptimisticUpdateDeneb) (interfaces.LightClientOptimisticUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OptimisticUpdateDeneb{
+		p:              p,
+		attestedHeader: attestedHeader,
+	}, nil
+}
+
+func (u *OptimisticUpdateDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *OptimisticUpdateDeneb) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *OptimisticUpdateDeneb) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *OptimisticUpdateDeneb) Version() int {
+	return version.Deneb
+}
+
+func (u *OptimisticUpdateDeneb) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *OptimisticUpdateDeneb) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *OptimisticUpdateDeneb) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}

consensus-types/light-client/update.go

@@ -0,0 +1,305 @@
+package light_client
+
+import (
+	"fmt"
+
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"google.golang.org/protobuf/proto"
+)
+
+func NewWrappedUpdate(m proto.Message) (interfaces.LightClientUpdate, error) {
+	if m == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	switch t := m.(type) {
+	case *pb.LightClientUpdateAltair:
+		return NewWrappedUpdateAltair(t)
+	case *pb.LightClientUpdateCapella:
+		return NewWrappedUpdateCapella(t)
+	case *pb.LightClientUpdateDeneb:
+		return NewWrappedUpdateDeneb(t)
+	default:
+		return nil, fmt.Errorf("cannot construct light client update from type %T", t)
+	}
+}
+
+type updateAltair struct {
+	p                       *pb.LightClientUpdateAltair
+	attestedHeader          interfaces.LightClientHeader
+	nextSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+	finalizedHeader         interfaces.LightClientHeader
+	finalityBranch          interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientUpdate = &updateAltair{}
+
+func NewWrappedUpdateAltair(p *pb.LightClientUpdateAltair) (interfaces.LightClientUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderAltair(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderAltair(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.NextSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &updateAltair{
+		p:                       p,
+		attestedHeader:          attestedHeader,
+		nextSyncCommitteeBranch: scBranch,
+		finalizedHeader:         finalizedHeader,
+		finalityBranch:          finalityBranch,
+	}, nil
+}
+
+func (u *updateAltair) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *updateAltair) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *updateAltair) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *updateAltair) Version() int {
+	return version.Altair
+}
+
+func (u *updateAltair) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *updateAltair) NextSyncCommittee() *pb.SyncCommittee {
+	return u.p.NextSyncCommittee
+}
+
+func (u *updateAltair) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return u.nextSyncCommitteeBranch
+}
+
+func (u *updateAltair) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *updateAltair) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *updateAltair) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *updateAltair) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type updateCapella struct {
+	p                       *pb.LightClientUpdateCapella
+	attestedHeader          interfaces.LightClientHeader
+	nextSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+	finalizedHeader         interfaces.LightClientHeader
+	finalityBranch          interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientUpdate = &updateCapella{}
+
+func NewWrappedUpdateCapella(p *pb.LightClientUpdateCapella) (interfaces.LightClientUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderCapella(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderCapella(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.NextSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &updateCapella{
+		p:                       p,
+		attestedHeader:          attestedHeader,
+		nextSyncCommitteeBranch: scBranch,
+		finalizedHeader:         finalizedHeader,
+		finalityBranch:          finalityBranch,
+	}, nil
+}
+
+func (u *updateCapella) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *updateCapella) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *updateCapella) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *updateCapella) Version() int {
+	return version.Capella
+}
+
+func (u *updateCapella) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *updateCapella) NextSyncCommittee() *pb.SyncCommittee {
+	return u.p.NextSyncCommittee
+}
+
+func (u *updateCapella) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return u.nextSyncCommitteeBranch
+}
+
+func (u *updateCapella) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *updateCapella) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *updateCapella) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *updateCapella) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}
+
+type updateDeneb struct {
+	p                       *pb.LightClientUpdateDeneb
+	attestedHeader          interfaces.LightClientHeader
+	nextSyncCommitteeBranch interfaces.LightClientSyncCommitteeBranch
+	finalizedHeader         interfaces.LightClientHeader
+	finalityBranch          interfaces.LightClientFinalityBranch
+}
+
+var _ interfaces.LightClientUpdate = &updateDeneb{}
+
+func NewWrappedUpdateDeneb(p *pb.LightClientUpdateDeneb) (interfaces.LightClientUpdate, error) {
+	if p == nil {
+		return nil, consensustypes.ErrNilObjectWrapped
+	}
+	attestedHeader, err := NewWrappedHeaderDeneb(p.AttestedHeader)
+	if err != nil {
+		return nil, err
+	}
+	finalizedHeader, err := NewWrappedHeaderDeneb(p.FinalizedHeader)
+	if err != nil {
+		return nil, err
+	}
+	scBranch, err := createBranch[interfaces.LightClientSyncCommitteeBranch](
+		"sync committee",
+		p.NextSyncCommitteeBranch,
+		fieldparams.SyncCommitteeBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+	finalityBranch, err := createBranch[interfaces.LightClientFinalityBranch](
+		"finality",
+		p.FinalityBranch,
+		fieldparams.FinalityBranchDepth,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &updateDeneb{
+		p:                       p,
+		attestedHeader:          attestedHeader,
+		nextSyncCommitteeBranch: scBranch,
+		finalizedHeader:         finalizedHeader,
+		finalityBranch:          finalityBranch,
+	}, nil
+}
+
+func (u *updateDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return u.p.MarshalSSZTo(dst)
+}
+
+func (u *updateDeneb) MarshalSSZ() ([]byte, error) {
+	return u.p.MarshalSSZ()
+}
+
+func (u *updateDeneb) SizeSSZ() int {
+	return u.p.SizeSSZ()
+}
+
+func (u *updateDeneb) Version() int {
+	return version.Deneb
+}
+
+func (u *updateDeneb) AttestedHeader() interfaces.LightClientHeader {
+	return u.attestedHeader
+}
+
+func (u *updateDeneb) NextSyncCommittee() *pb.SyncCommittee {
+	return u.p.NextSyncCommittee
+}
+
+func (u *updateDeneb) NextSyncCommitteeBranch() interfaces.LightClientSyncCommitteeBranch {
+	return u.nextSyncCommitteeBranch
+}
+
+func (u *updateDeneb) FinalizedHeader() interfaces.LightClientHeader {
+	return u.finalizedHeader
+}
+
+func (u *updateDeneb) FinalityBranch() interfaces.LightClientFinalityBranch {
+	return u.finalityBranch
+}
+
+func (u *updateDeneb) SyncAggregate() *pb.SyncAggregate {
+	return u.p.SyncAggregate
+}
+
+func (u *updateDeneb) SignatureSlot() primitives.Slot {
+	return u.p.SignatureSlot
+}