Add deneb block to consensus types (#12368)

consensus-types/blocks/execution.go

@@ -160,6 +160,11 @@ func (executionPayload) WithdrawalsRoot() ([]byte, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
 
+// ExcessDataGas --
+func (e executionPayload) ExcessDataGas() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
 // PbBellatrix --
 func (e executionPayload) PbBellatrix() (*enginev1.ExecutionPayload, error) {
 	return e.p, nil
@@ -321,7 +326,12 @@ func (executionPayloadHeader) WithdrawalsRoot() ([]byte, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
 
-// PbCapella --
+// ExcessDataGas --
+func (e executionPayloadHeader) ExcessDataGas() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// PbV2 --
 func (executionPayloadHeader) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
@@ -511,7 +521,12 @@ func (executionPayloadCapella) WithdrawalsRoot() ([]byte, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
 
-// PbCapella --
+// ExcessDataGas returns error for executionPayloadCapella.
+func (e executionPayloadCapella) ExcessDataGas() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// PbV2 --
 func (e executionPayloadCapella) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return e.p, nil
 }
@@ -673,7 +688,12 @@ func (e executionPayloadHeaderCapella) WithdrawalsRoot() ([]byte, error) {
 	return e.p.WithdrawalsRoot, nil
 }
 
-// PbCapella --
+// ExcessDataGas returns error for executionPayloadHeaderCapella.
+func (e executionPayloadHeaderCapella) ExcessDataGas() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// PbV2 --
 func (executionPayloadHeaderCapella) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
 	return nil, consensus_types.ErrUnsupportedField
 }
@@ -726,6 +746,49 @@ func PayloadToHeaderCapella(payload interfaces.ExecutionData) (*enginev1.Executi
 	}, nil
 }
 
+// PayloadToHeaderDeneb converts `payload` into execution payload header format.
+func PayloadToHeaderDeneb(payload interfaces.ExecutionData) (*enginev1.ExecutionPayloadHeaderDeneb, error) {
+	txs, err := payload.Transactions()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := ssz.TransactionsRoot(txs)
+	if err != nil {
+		return nil, err
+	}
+	withdrawals, err := payload.Withdrawals()
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+	if err != nil {
+		return nil, err
+	}
+	excessDataGas, err := payload.ExcessDataGas()
+	if err != nil {
+		return nil, err
+	}
+
+	return &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       bytesutil.SafeCopyBytes(payload.ParentHash()),
+		FeeRecipient:     bytesutil.SafeCopyBytes(payload.FeeRecipient()),
+		StateRoot:        bytesutil.SafeCopyBytes(payload.StateRoot()),
+		ReceiptsRoot:     bytesutil.SafeCopyBytes(payload.ReceiptsRoot()),
+		LogsBloom:        bytesutil.SafeCopyBytes(payload.LogsBloom()),
+		PrevRandao:       bytesutil.SafeCopyBytes(payload.PrevRandao()),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        bytesutil.SafeCopyBytes(payload.ExtraData()),
+		BaseFeePerGas:    bytesutil.SafeCopyBytes(payload.BaseFeePerGas()),
+		BlockHash:        bytesutil.SafeCopyBytes(payload.BlockHash()),
+		TransactionsRoot: txRoot[:],
+		WithdrawalsRoot:  withdrawalsRoot[:],
+		ExcessDataGas:    bytesutil.SafeCopyBytes(excessDataGas),
+	}, nil
+}
+
 // IsEmptyExecutionData checks if an execution data is empty underneath. If a single field has
 // a non-zero value, this function will return false.
 func IsEmptyExecutionData(data interfaces.ExecutionData) (bool, error) {
@@ -782,3 +845,333 @@ func IsEmptyExecutionData(data interfaces.ExecutionData) (bool, error) {
 	}
 	return true, nil
 }
+
+// executionPayloadHeaderDeneb is a convenience wrapper around a blinded beacon block body's execution header data structure.
+// This wrapper allows us to conform to a common interface so that beacon
+// blocks for future forks can also be applied across Prysm without issues.
+type executionPayloadHeaderDeneb struct {
+	p     *enginev1.ExecutionPayloadHeaderDeneb
+	value uint64
+}
+
+// WrappedExecutionPayloadHeaderDeneb is a constructor which wraps a protobuf execution header into an interface.
+func WrappedExecutionPayloadHeaderDeneb(p *enginev1.ExecutionPayloadHeaderDeneb, value uint64) (interfaces.ExecutionData, error) {
+	w := executionPayloadHeaderDeneb{p: p, value: value}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// IsNil checks if the underlying data is nil.
+func (e executionPayloadHeaderDeneb) IsNil() bool {
+	return e.p == nil
+}
+
+// MarshalSSZ --
+func (e executionPayloadHeaderDeneb) MarshalSSZ() ([]byte, error) {
+	return e.p.MarshalSSZ()
+}
+
+// MarshalSSZTo --
+func (e executionPayloadHeaderDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return e.p.MarshalSSZTo(dst)
+}
+
+// SizeSSZ --
+func (e executionPayloadHeaderDeneb) SizeSSZ() int {
+	return e.p.SizeSSZ()
+}
+
+// UnmarshalSSZ --
+func (e executionPayloadHeaderDeneb) UnmarshalSSZ(buf []byte) error {
+	return e.p.UnmarshalSSZ(buf)
+}
+
+// HashTreeRoot --
+func (e executionPayloadHeaderDeneb) HashTreeRoot() ([32]byte, error) {
+	return e.p.HashTreeRoot()
+}
+
+// HashTreeRootWith --
+func (e executionPayloadHeaderDeneb) HashTreeRootWith(hh *fastssz.Hasher) error {
+	return e.p.HashTreeRootWith(hh)
+}
+
+// Proto --
+func (e executionPayloadHeaderDeneb) Proto() proto.Message {
+	return e.p
+}
+
+// ParentHash --
+func (e executionPayloadHeaderDeneb) ParentHash() []byte {
+	return e.p.ParentHash
+}
+
+// FeeRecipient --
+func (e executionPayloadHeaderDeneb) FeeRecipient() []byte {
+	return e.p.FeeRecipient
+}
+
+// StateRoot --
+func (e executionPayloadHeaderDeneb) StateRoot() []byte {
+	return e.p.StateRoot
+}
+
+// ReceiptsRoot --
+func (e executionPayloadHeaderDeneb) ReceiptsRoot() []byte {
+	return e.p.ReceiptsRoot
+}
+
+// LogsBloom --
+func (e executionPayloadHeaderDeneb) LogsBloom() []byte {
+	return e.p.LogsBloom
+}
+
+// PrevRandao --
+func (e executionPayloadHeaderDeneb) PrevRandao() []byte {
+	return e.p.PrevRandao
+}
+
+// BlockNumber --
+func (e executionPayloadHeaderDeneb) BlockNumber() uint64 {
+	return e.p.BlockNumber
+}
+
+// GasLimit --
+func (e executionPayloadHeaderDeneb) GasLimit() uint64 {
+	return e.p.GasLimit
+}
+
+// GasUsed --
+func (e executionPayloadHeaderDeneb) GasUsed() uint64 {
+	return e.p.GasUsed
+}
+
+// Timestamp --
+func (e executionPayloadHeaderDeneb) Timestamp() uint64 {
+	return e.p.Timestamp
+}
+
+// ExtraData --
+func (e executionPayloadHeaderDeneb) ExtraData() []byte {
+	return e.p.ExtraData
+}
+
+// BaseFeePerGas --
+func (e executionPayloadHeaderDeneb) BaseFeePerGas() []byte {
+	return e.p.BaseFeePerGas
+}
+
+// BlockHash --
+func (e executionPayloadHeaderDeneb) BlockHash() []byte {
+	return e.p.BlockHash
+}
+
+// Transactions --
+func (executionPayloadHeaderDeneb) Transactions() ([][]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// TransactionsRoot --
+func (e executionPayloadHeaderDeneb) TransactionsRoot() ([]byte, error) {
+	return e.p.TransactionsRoot, nil
+}
+
+// Withdrawals --
+func (e executionPayloadHeaderDeneb) Withdrawals() ([]*enginev1.Withdrawal, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// WitdrawalsRoot --
+func (e executionPayloadHeaderDeneb) WithdrawalsRoot() ([]byte, error) {
+	return e.p.WithdrawalsRoot, nil
+}
+
+func (e executionPayloadHeaderDeneb) ExcessDataGas() ([]byte, error) {
+	return e.p.ExcessDataGas, nil
+}
+
+// PbBellatrix --
+func (e executionPayloadHeaderDeneb) PbBellatrix() (*enginev1.ExecutionPayload, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// PbCapella --
+func (e executionPayloadHeaderDeneb) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+func (e executionPayloadHeaderDeneb) ValueInGwei() (uint64, error) {
+	return e.value, nil
+}
+
+// IsBlinded returns true if the underlying data is blinded.
+func (e executionPayloadHeaderDeneb) IsBlinded() bool {
+	return true
+}
+
+// executionPayloadDeneb is a convenience wrapper around a beacon block body's execution payload data structure
+// This wrapper allows us to conform to a common interface so that beacon
+// blocks for future forks can also be applied across Prysm without issues.
+type executionPayloadDeneb struct {
+	p     *enginev1.ExecutionPayloadDeneb
+	value uint64
+}
+
+// WrappedExecutionPayloadDeneb is a constructor which wraps a protobuf execution payload into an interface.
+func WrappedExecutionPayloadDeneb(p *enginev1.ExecutionPayloadDeneb, value uint64) (interfaces.ExecutionData, error) {
+	w := executionPayloadDeneb{p: p, value: value}
+	if w.IsNil() {
+		return nil, consensus_types.ErrNilObjectWrapped
+	}
+	return w, nil
+}
+
+// IsNil checks if the underlying data is nil.
+func (e executionPayloadDeneb) IsNil() bool {
+	return e.p == nil
+}
+
+// MarshalSSZ --
+func (e executionPayloadDeneb) MarshalSSZ() ([]byte, error) {
+	return e.p.MarshalSSZ()
+}
+
+// MarshalSSZTo --
+func (e executionPayloadDeneb) MarshalSSZTo(dst []byte) ([]byte, error) {
+	return e.p.MarshalSSZTo(dst)
+}
+
+// SizeSSZ --
+func (e executionPayloadDeneb) SizeSSZ() int {
+	return e.p.SizeSSZ()
+}
+
+// UnmarshalSSZ --
+func (e executionPayloadDeneb) UnmarshalSSZ(buf []byte) error {
+	return e.p.UnmarshalSSZ(buf)
+}
+
+// HashTreeRoot --
+func (e executionPayloadDeneb) HashTreeRoot() ([32]byte, error) {
+	return e.p.HashTreeRoot()
+}
+
+// HashTreeRootWith --
+func (e executionPayloadDeneb) HashTreeRootWith(hh *fastssz.Hasher) error {
+	return e.p.HashTreeRootWith(hh)
+}
+
+// Proto --
+func (e executionPayloadDeneb) Proto() proto.Message {
+	return e.p
+}
+
+// ParentHash --
+func (e executionPayloadDeneb) ParentHash() []byte {
+	return e.p.ParentHash
+}
+
+// FeeRecipient --
+func (e executionPayloadDeneb) FeeRecipient() []byte {
+	return e.p.FeeRecipient
+}
+
+// StateRoot --
+func (e executionPayloadDeneb) StateRoot() []byte {
+	return e.p.StateRoot
+}
+
+// ReceiptsRoot --
+func (e executionPayloadDeneb) ReceiptsRoot() []byte {
+	return e.p.ReceiptsRoot
+}
+
+// LogsBloom --
+func (e executionPayloadDeneb) LogsBloom() []byte {
+	return e.p.LogsBloom
+}
+
+// PrevRandao --
+func (e executionPayloadDeneb) PrevRandao() []byte {
+	return e.p.PrevRandao
+}
+
+// BlockNumber --
+func (e executionPayloadDeneb) BlockNumber() uint64 {
+	return e.p.BlockNumber
+}
+
+// GasLimit --
+func (e executionPayloadDeneb) GasLimit() uint64 {
+	return e.p.GasLimit
+}
+
+// GasUsed --
+func (e executionPayloadDeneb) GasUsed() uint64 {
+	return e.p.GasUsed
+}
+
+// Timestamp --
+func (e executionPayloadDeneb) Timestamp() uint64 {
+	return e.p.Timestamp
+}
+
+// ExtraData --
+func (e executionPayloadDeneb) ExtraData() []byte {
+	return e.p.ExtraData
+}
+
+// BaseFeePerGas --
+func (e executionPayloadDeneb) BaseFeePerGas() []byte {
+	return e.p.BaseFeePerGas
+}
+
+// BlockHash --
+func (e executionPayloadDeneb) BlockHash() []byte {
+	return e.p.BlockHash
+}
+
+// Transactions --
+func (e executionPayloadDeneb) Transactions() ([][]byte, error) {
+	return e.p.Transactions, nil
+}
+
+// TransactionsRoot --
+func (e executionPayloadDeneb) TransactionsRoot() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// Withdrawals --
+func (e executionPayloadDeneb) Withdrawals() ([]*enginev1.Withdrawal, error) {
+	return e.p.Withdrawals, nil
+}
+
+// WithdrawalsRoot --
+func (e executionPayloadDeneb) WithdrawalsRoot() ([]byte, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+func (e executionPayloadDeneb) ExcessDataGas() ([]byte, error) {
+	return e.p.ExcessDataGas, nil
+}
+
+// PbBellatrix --
+func (e executionPayloadDeneb) PbBellatrix() (*enginev1.ExecutionPayload, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+// PbCapella --
+func (e executionPayloadDeneb) PbCapella() (*enginev1.ExecutionPayloadCapella, error) {
+	return nil, consensus_types.ErrUnsupportedField
+}
+
+func (e executionPayloadDeneb) ValueInGwei() (uint64, error) {
+	return e.value, nil
+}
+
+// IsBlinded returns true if the underlying data is blinded.
+func (e executionPayloadDeneb) IsBlinded() bool {
+	return false
+}

consensus-types/blocks/execution_test.go

@@ -242,6 +242,104 @@ func Test_executionPayloadHeaderCapella_Pb(t *testing.T) {
 	require.ErrorIs(t, err, consensus_types.ErrUnsupportedField)
 }
 
+func TestWrapExecutionPayloadDeneb(t *testing.T) {
+	data := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    []byte("parenthash"),
+		FeeRecipient:  []byte("feerecipient"),
+		StateRoot:     []byte("stateroot"),
+		ReceiptsRoot:  []byte("receiptsroot"),
+		LogsBloom:     []byte("logsbloom"),
+		PrevRandao:    []byte("prevrandao"),
+		BlockNumber:   11,
+		GasLimit:      22,
+		GasUsed:       33,
+		Timestamp:     44,
+		ExtraData:     []byte("extradata"),
+		BaseFeePerGas: []byte("basefeepergas"),
+		BlockHash:     []byte("blockhash"),
+		Transactions:  [][]byte{[]byte("transaction")},
+		Withdrawals: []*enginev1.Withdrawal{{
+			Index:          55,
+			ValidatorIndex: 66,
+			Address:        []byte("executionaddress"),
+			Amount:         77,
+		}},
+		ExcessDataGas: []byte("excessdatagas"),
+	}
+	payload, err := blocks.WrappedExecutionPayloadDeneb(data, 420)
+	require.NoError(t, err)
+	v, err := payload.ValueInGwei()
+	require.NoError(t, err)
+	assert.Equal(t, uint64(420), v)
+
+	g, err := payload.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, []byte("excessdatagas"), g)
+}
+
+func TestWrapExecutionPayloadHeaderDeneb(t *testing.T) {
+	data := &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       []byte("parenthash"),
+		FeeRecipient:     []byte("feerecipient"),
+		StateRoot:        []byte("stateroot"),
+		ReceiptsRoot:     []byte("receiptsroot"),
+		LogsBloom:        []byte("logsbloom"),
+		PrevRandao:       []byte("prevrandao"),
+		BlockNumber:      11,
+		GasLimit:         22,
+		GasUsed:          33,
+		Timestamp:        44,
+		ExtraData:        []byte("extradata"),
+		BaseFeePerGas:    []byte("basefeepergas"),
+		BlockHash:        []byte("blockhash"),
+		TransactionsRoot: []byte("transactionsroot"),
+		WithdrawalsRoot:  []byte("withdrawalsroot"),
+		ExcessDataGas:    []byte("excessdatagas"),
+	}
+	payload, err := blocks.WrappedExecutionPayloadHeaderDeneb(data, 10)
+	require.NoError(t, err)
+
+	v, err := payload.ValueInGwei()
+	require.NoError(t, err)
+	assert.Equal(t, uint64(10), v)
+
+	g, err := payload.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, []byte("excessdatagas"), g)
+}
+
+func TestWrapExecutionPayloadDeneb_SSZ(t *testing.T) {
+	payload := createWrappedPayloadDeneb(t)
+	rt, err := payload.HashTreeRoot()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, rt)
+
+	var b []byte
+	b, err = payload.MarshalSSZTo(b)
+	assert.NoError(t, err)
+	assert.NotEqual(t, 0, len(b))
+	encoded, err := payload.MarshalSSZ()
+	require.NoError(t, err)
+	assert.NotEqual(t, 0, payload.SizeSSZ())
+	assert.NoError(t, payload.UnmarshalSSZ(encoded))
+}
+
+func TestWrapExecutionPayloadHeaderDeneb_SSZ(t *testing.T) {
+	payload := createWrappedPayloadHeaderDeneb(t)
+	rt, err := payload.HashTreeRoot()
+	assert.NoError(t, err)
+	assert.NotEmpty(t, rt)
+
+	var b []byte
+	b, err = payload.MarshalSSZTo(b)
+	assert.NoError(t, err)
+	assert.NotEqual(t, 0, len(b))
+	encoded, err := payload.MarshalSSZ()
+	require.NoError(t, err)
+	assert.NotEqual(t, 0, payload.SizeSSZ())
+	assert.NoError(t, payload.UnmarshalSSZ(encoded))
+}
+
 func createWrappedPayload(t testing.TB) interfaces.ExecutionData {
 	wsb, err := blocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{
 		ParentHash:    make([]byte, fieldparams.RootLength),
@@ -327,3 +425,49 @@ func createWrappedPayloadHeaderCapella(t testing.TB) interfaces.ExecutionData {
 	require.NoError(t, err)
 	return payload
 }
+
+func createWrappedPayloadDeneb(t testing.TB) interfaces.ExecutionData {
+	payload, err := blocks.WrappedExecutionPayloadDeneb(&enginev1.ExecutionPayloadDeneb{
+		ParentHash:    make([]byte, fieldparams.RootLength),
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+		PrevRandao:    make([]byte, fieldparams.RootLength),
+		BlockNumber:   0,
+		GasLimit:      0,
+		GasUsed:       0,
+		Timestamp:     0,
+		ExtraData:     make([]byte, 0),
+		BaseFeePerGas: make([]byte, fieldparams.RootLength),
+		BlockHash:     make([]byte, fieldparams.RootLength),
+		Transactions:  make([][]byte, 0),
+		Withdrawals:   make([]*enginev1.Withdrawal, 0),
+		ExcessDataGas: make([]byte, fieldparams.RootLength),
+	}, 0)
+	require.NoError(t, err)
+	return payload
+}
+
+func createWrappedPayloadHeaderDeneb(t testing.TB) interfaces.ExecutionData {
+	payload, err := blocks.WrappedExecutionPayloadHeaderDeneb(&enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       make([]byte, fieldparams.RootLength),
+		FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:        make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+		LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+		PrevRandao:       make([]byte, fieldparams.RootLength),
+		BlockNumber:      0,
+		GasLimit:         0,
+		GasUsed:          0,
+		Timestamp:        0,
+		ExtraData:        make([]byte, 0),
+		BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+		BlockHash:        make([]byte, fieldparams.RootLength),
+		TransactionsRoot: make([]byte, fieldparams.RootLength),
+		WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+		ExcessDataGas:    make([]byte, fieldparams.RootLength),
+	}, 0)
+	require.NoError(t, err)
+	return payload
+}

consensus-types/blocks/factory.go

@@ -56,6 +56,14 @@ func NewSignedBeaconBlock(i interface{}) (interfaces.SignedBeaconBlock, error) {
 		return initBlindedSignedBlockFromProtoCapella(b.BlindedCapella)
 	case *eth.SignedBlindedBeaconBlockCapella:
 		return initBlindedSignedBlockFromProtoCapella(b)
+	case *eth.GenericSignedBeaconBlock_Deneb:
+		return initSignedBlockFromProtoDeneb(b.Deneb.Block)
+	case *eth.SignedBeaconBlockDeneb:
+		return initSignedBlockFromProtoDeneb(b)
+	case *eth.SignedBlindedBeaconBlockDeneb:
+		return initBlindedSignedBlockFromProtoDeneb(b)
+	case *eth.GenericSignedBeaconBlock_Blinded_Deneb:
+		return initBlindedSignedBlockFromProtoDeneb(b.Blinded_Deneb.Block)
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedSignedBeaconBlock, "unable to create block from type %T", i)
 	}
@@ -90,6 +98,14 @@ func NewBeaconBlock(i interface{}) (interfaces.ReadOnlyBeaconBlock, error) {
 		return initBlindedBlockFromProtoCapella(b.BlindedCapella)
 	case *eth.BlindedBeaconBlockCapella:
 		return initBlindedBlockFromProtoCapella(b)
+	case *eth.GenericBeaconBlock_Deneb:
+		return initBlockFromProtoDeneb(b.Deneb.Block)
+	case *eth.BeaconBlockDeneb:
+		return initBlockFromProtoDeneb(b)
+	case *eth.BlindedBeaconBlockDeneb:
+		return initBlindedBlockFromProtoDeneb(b)
+	case *eth.GenericBeaconBlock_Blinded_Deneb:
+		return initBlindedBlockFromProtoDeneb(b.Blinded_Deneb.Block)
 	default:
 		return nil, errors.Wrapf(errUnsupportedBeaconBlock, "unable to create block from type %T", i)
 	}
@@ -112,6 +128,10 @@ func NewBeaconBlockBody(i interface{}) (interfaces.ReadOnlyBeaconBlockBody, erro
 		return initBlockBodyFromProtoCapella(b)
 	case *eth.BlindedBeaconBlockBodyCapella:
 		return initBlindedBlockBodyFromProtoCapella(b)
+	case *eth.BeaconBlockBodyDeneb:
+		return initBlockBodyFromProtoDeneb(b)
+	case *eth.BlindedBeaconBlockBodyDeneb:
+		return initBlindedBlockBodyFromProtoDeneb(b)
 	default:
 		return nil, errors.Wrapf(errUnsupportedBeaconBlockBody, "unable to create block body from type %T", i)
 	}
@@ -165,6 +185,19 @@ func BuildSignedBeaconBlock(blk interfaces.ReadOnlyBeaconBlock, signature []byte
 			return nil, errIncorrectBlockVersion
 		}
 		return NewSignedBeaconBlock(&eth.SignedBeaconBlockCapella{Block: pb, Signature: signature})
+	case version.Deneb:
+		if blk.IsBlinded() {
+			pb, ok := pb.(*eth.BlindedBeaconBlockDeneb)
+			if !ok {
+				return nil, errIncorrectBlockVersion
+			}
+			return NewSignedBeaconBlock(&eth.SignedBlindedBeaconBlockDeneb{Block: pb, Signature: signature})
+		}
+		pb, ok := pb.(*eth.BeaconBlockDeneb)
+		if !ok {
+			return nil, errIncorrectBlockVersion
+		}
+		return NewSignedBeaconBlock(&eth.SignedBeaconBlockDeneb{Block: pb, Signature: signature})
 	default:
 		return nil, errUnsupportedBeaconBlock
 	}
@@ -194,6 +227,8 @@ func BuildSignedBeaconBlockFromExecutionPayload(
 		wrappedPayload, wrapErr = WrappedExecutionPayload(p)
 	case *enginev1.ExecutionPayloadCapella:
 		wrappedPayload, wrapErr = WrappedExecutionPayloadCapella(p, 0)
+	case *enginev1.ExecutionPayloadDeneb:
+		wrappedPayload, wrapErr = WrappedExecutionPayloadDeneb(p, 0)
 	default:
 		return nil, fmt.Errorf("%T is not a type of execution payload", p)
 	}
@@ -282,6 +317,38 @@ func BuildSignedBeaconBlockFromExecutionPayload(
 			},
 			Signature: sig[:],
 		}
+	case *enginev1.ExecutionPayloadDeneb:
+		blsToExecutionChanges, err := b.Body().BLSToExecutionChanges()
+		if err != nil {
+			return nil, err
+		}
+		commitments, err := b.Body().BlobKzgCommitments()
+		if err != nil {
+			return nil, err
+		}
+		fullBlock = &eth.SignedBeaconBlockDeneb{
+			Block: &eth.BeaconBlockDeneb{
+				Slot:          b.Slot(),
+				ProposerIndex: b.ProposerIndex(),
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				Body: &eth.BeaconBlockBodyDeneb{
+					RandaoReveal:          randaoReveal[:],
+					Eth1Data:              b.Body().Eth1Data(),
+					Graffiti:              graffiti[:],
+					ProposerSlashings:     b.Body().ProposerSlashings(),
+					AttesterSlashings:     b.Body().AttesterSlashings(),
+					Attestations:          b.Body().Attestations(),
+					Deposits:              b.Body().Deposits(),
+					VoluntaryExits:        b.Body().VoluntaryExits(),
+					SyncAggregate:         syncAgg,
+					ExecutionPayload:      p,
+					BlsToExecutionChanges: blsToExecutionChanges,
+					BlobKzgCommitments:    commitments,
+				},
+			},
+			Signature: sig[:],
+		}
 	default:
 		return nil, fmt.Errorf("%T is not a type of execution payload", p)
 	}

consensus-types/blocks/factory_test.go

@@ -121,6 +121,46 @@ func Test_NewSignedBeaconBlock(t *testing.T) {
 		assert.Equal(t, version.Capella, b.Version())
 		assert.Equal(t, true, b.IsBlinded())
 	})
+	t.Run("GenericSignedBeaconBlock_Deneb", func(t *testing.T) {
+		pb := &eth.GenericSignedBeaconBlock_Deneb{
+			Deneb: &eth.SignedBeaconBlockAndBlobsDeneb{
+				Block: &eth.SignedBeaconBlockDeneb{
+					Block: &eth.BeaconBlockDeneb{
+						Body: &eth.BeaconBlockBodyDeneb{},
+					}}}}
+		b, err := NewSignedBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+	})
+	t.Run("SignedBeaconBlockDeneb", func(t *testing.T) {
+		pb := &eth.SignedBeaconBlockDeneb{
+			Block: &eth.BeaconBlockDeneb{
+				Body: &eth.BeaconBlockBodyDeneb{}}}
+		b, err := NewSignedBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+	})
+	t.Run("SignedBlindedBeaconBlockDeneb", func(t *testing.T) {
+		pb := &eth.SignedBlindedBeaconBlockDeneb{
+			Block: &eth.BlindedBeaconBlockDeneb{
+				Body: &eth.BlindedBeaconBlockBodyDeneb{}}}
+		b, err := NewSignedBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+		assert.Equal(t, true, b.IsBlinded())
+	})
+	t.Run("GenericSignedBeaconBlock_BlindedDeneb", func(t *testing.T) {
+		pb := &eth.GenericSignedBeaconBlock_Blinded_Deneb{
+			Blinded_Deneb: &eth.SignedBlindedBeaconBlockDenebAndBlobs{
+				Block: &eth.SignedBlindedBeaconBlockDeneb{
+					Block: &eth.BlindedBeaconBlockDeneb{
+						Body: &eth.BlindedBeaconBlockBodyDeneb{},
+					}}}}
+		b, err := NewSignedBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+		assert.Equal(t, true, b.IsBlinded())
+	})
 	t.Run("nil", func(t *testing.T) {
 		_, err := NewSignedBeaconBlock(nil)
 		assert.ErrorContains(t, "received nil object", err)
@@ -208,6 +248,34 @@ func Test_NewBeaconBlock(t *testing.T) {
 		assert.Equal(t, version.Capella, b.Version())
 		assert.Equal(t, true, b.IsBlinded())
 	})
+	t.Run("GenericBeaconBlock_Deneb", func(t *testing.T) {
+		pb := &eth.GenericBeaconBlock_Deneb{Deneb: &eth.BeaconBlockDenebAndBlobs{Block: &eth.BeaconBlockDeneb{
+			Body: &eth.BeaconBlockBodyDeneb{},
+		}}}
+		b, err := NewBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+	})
+	t.Run("BeaconBlockDeneb", func(t *testing.T) {
+		pb := &eth.BeaconBlockDeneb{Body: &eth.BeaconBlockBodyDeneb{}}
+		b, err := NewBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+	})
+	t.Run("BlindedBeaconBlockDeneb", func(t *testing.T) {
+		pb := &eth.BlindedBeaconBlockDeneb{Body: &eth.BlindedBeaconBlockBodyDeneb{}}
+		b, err := NewBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+		assert.Equal(t, true, b.IsBlinded())
+	})
+	t.Run("GenericBeaconBlock_BlindedDeneb", func(t *testing.T) {
+		pb := &eth.GenericBeaconBlock_Blinded_Deneb{Blinded_Deneb: &eth.BlindedBeaconBlockDenebAndBlobs{Block: &eth.BlindedBeaconBlockDeneb{Body: &eth.BlindedBeaconBlockBodyDeneb{}}}}
+		b, err := NewBeaconBlock(pb)
+		require.NoError(t, err)
+		assert.Equal(t, version.Deneb, b.Version())
+		assert.Equal(t, true, b.IsBlinded())
+	})
 	t.Run("nil", func(t *testing.T) {
 		_, err := NewBeaconBlock(nil)
 		assert.ErrorContains(t, "received nil object", err)
@@ -269,6 +337,23 @@ func Test_NewBeaconBlockBody(t *testing.T) {
 		assert.Equal(t, version.Capella, b.version)
 		assert.Equal(t, true, b.isBlinded)
 	})
+	t.Run("BeaconBlockBodyDeneb", func(t *testing.T) {
+		pb := &eth.BeaconBlockBodyDeneb{}
+		i, err := NewBeaconBlockBody(pb)
+		require.NoError(t, err)
+		b, ok := i.(*BeaconBlockBody)
+		require.Equal(t, true, ok)
+		assert.Equal(t, version.Deneb, b.version)
+	})
+	t.Run("BlindedBeaconBlockBodyDeneb", func(t *testing.T) {
+		pb := &eth.BlindedBeaconBlockBodyDeneb{}
+		i, err := NewBeaconBlockBody(pb)
+		require.NoError(t, err)
+		b, ok := i.(*BeaconBlockBody)
+		require.Equal(t, true, ok)
+		assert.Equal(t, version.Deneb, b.version)
+		assert.Equal(t, true, b.isBlinded)
+	})
 	t.Run("nil", func(t *testing.T) {
 		_, err := NewBeaconBlockBody(nil)
 		assert.ErrorContains(t, "received nil object", err)
@@ -325,6 +410,21 @@ func Test_BuildSignedBeaconBlock(t *testing.T) {
 		assert.Equal(t, version.Capella, sb.Version())
 		assert.Equal(t, true, sb.IsBlinded())
 	})
+	t.Run("Deneb", func(t *testing.T) {
+		b := &BeaconBlock{version: version.Deneb, body: &BeaconBlockBody{version: version.Deneb}}
+		sb, err := BuildSignedBeaconBlock(b, sig[:])
+		require.NoError(t, err)
+		assert.DeepEqual(t, sig, sb.Signature())
+		assert.Equal(t, version.Deneb, sb.Version())
+	})
+	t.Run("DenebBlind", func(t *testing.T) {
+		b := &BeaconBlock{version: version.Deneb, body: &BeaconBlockBody{version: version.Deneb, isBlinded: true}}
+		sb, err := BuildSignedBeaconBlock(b, sig[:])
+		require.NoError(t, err)
+		assert.DeepEqual(t, sig, sb.Signature())
+		assert.Equal(t, version.Deneb, sb.Version())
+		assert.Equal(t, true, sb.IsBlinded())
+	})
 }
 
 func TestBuildSignedBeaconBlockFromExecutionPayload(t *testing.T) {
@@ -401,4 +501,36 @@ func TestBuildSignedBeaconBlockFromExecutionPayload(t *testing.T) {
 		require.NoError(t, err)
 		require.DeepEqual(t, payload, got.Proto())
 	})
+	t.Run("deneb", func(t *testing.T) {
+		payload := &enginev1.ExecutionPayloadDeneb{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+			ExcessDataGas: bytesutil.PadTo([]byte{123}, 32),
+		}
+		wrapped, err := WrappedExecutionPayloadDeneb(payload, 123)
+		require.NoError(t, err)
+		header, err := PayloadToHeaderDeneb(wrapped)
+		require.NoError(t, err)
+		blindedBlock := &eth.SignedBlindedBeaconBlockDeneb{
+			Block: &eth.BlindedBeaconBlockDeneb{
+				Body: &eth.BlindedBeaconBlockBodyDeneb{}}}
+		blindedBlock.Block.Body.ExecutionPayloadHeader = header
+
+		blk, err := NewSignedBeaconBlock(blindedBlock)
+		require.NoError(t, err)
+		builtBlock, err := BuildSignedBeaconBlockFromExecutionPayload(blk, payload)
+		require.NoError(t, err)
+
+		got, err := builtBlock.Block().Body().Execution()
+		require.NoError(t, err)
+		require.DeepEqual(t, payload, got.Proto())
+		require.DeepEqual(t, bytesutil.PadTo([]byte{123}, 32), payload.ExcessDataGas)
+	})
 }

consensus-types/blocks/getters.go

@@ -71,6 +71,13 @@ func (b *SignedBeaconBlock) Copy() (interfaces.ReadOnlySignedBeaconBlock, error)
 		}
 		cp := eth.CopySignedBeaconBlockCapella(pb.(*eth.SignedBeaconBlockCapella))
 		return initSignedBlockFromProtoCapella(cp)
+	case version.Deneb:
+		if b.IsBlinded() {
+			cp := eth.CopySignedBlindedBeaconBlockDeneb(pb.(*eth.SignedBlindedBeaconBlockDeneb))
+			return initBlindedSignedBlockFromProtoDeneb(cp)
+		}
+		cp := eth.CopySignedBeaconBlockDeneb(pb.(*eth.SignedBeaconBlockDeneb))
+		return initSignedBlockFromProtoDeneb(cp)
 	default:
 		return nil, errIncorrectBlockVersion
 	}
@@ -186,6 +193,30 @@ func (b *SignedBeaconBlock) PbBlindedCapellaBlock() (*eth.SignedBlindedBeaconBlo
 	return pb.(*eth.SignedBlindedBeaconBlockCapella), nil
 }
 
+// PbDenebBlock returns the underlying protobuf object.
+func (b *SignedBeaconBlock) PbDenebBlock() (*eth.SignedBeaconBlockDeneb, error) {
+	if b.version != version.Deneb || b.IsBlinded() {
+		return nil, consensus_types.ErrNotSupported("PbDenebBlock", b.version)
+	}
+	pb, err := b.Proto()
+	if err != nil {
+		return nil, err
+	}
+	return pb.(*eth.SignedBeaconBlockDeneb), nil
+}
+
+// PbBlindedDenebBlock returns the underlying protobuf object.
+func (b *SignedBeaconBlock) PbBlindedDenebBlock() (*eth.SignedBlindedBeaconBlockDeneb, error) {
+	if b.version != version.Deneb || !b.IsBlinded() {
+		return nil, consensus_types.ErrNotSupported("PbBlindedDenebBlock", b.version)
+	}
+	pb, err := b.Proto()
+	if err != nil {
+		return nil, err
+	}
+	return pb.(*eth.SignedBlindedBeaconBlockDeneb), nil
+}
+
 // ToBlinded converts a non-blinded block to its blinded equivalent.
 func (b *SignedBeaconBlock) ToBlinded() (interfaces.ReadOnlySignedBeaconBlock, error) {
 	if b.version < version.Bellatrix {
@@ -258,6 +289,35 @@ func (b *SignedBeaconBlock) ToBlinded() (interfaces.ReadOnlySignedBeaconBlock, e
 				},
 				Signature: b.signature[:],
 			})
+	case *enginev1.ExecutionPayloadDeneb:
+		header, err := PayloadToHeaderDeneb(payload)
+		if err != nil {
+			return nil, err
+		}
+		return initBlindedSignedBlockFromProtoDeneb(
+			&eth.SignedBlindedBeaconBlockDeneb{
+				Block: &eth.BlindedBeaconBlockDeneb{
+					Slot:          b.block.slot,
+					ProposerIndex: b.block.proposerIndex,
+					ParentRoot:    b.block.parentRoot[:],
+					StateRoot:     b.block.stateRoot[:],
+					Body: &eth.BlindedBeaconBlockBodyDeneb{
+						RandaoReveal:           b.block.body.randaoReveal[:],
+						Eth1Data:               b.block.body.eth1Data,
+						Graffiti:               b.block.body.graffiti[:],
+						ProposerSlashings:      b.block.body.proposerSlashings,
+						AttesterSlashings:      b.block.body.attesterSlashings,
+						Attestations:           b.block.body.attestations,
+						Deposits:               b.block.body.deposits,
+						VoluntaryExits:         b.block.body.voluntaryExits,
+						SyncAggregate:          b.block.body.syncAggregate,
+						ExecutionPayloadHeader: header,
+						BlsToExecutionChanges:  b.block.body.blsToExecutionChanges,
+						BlobKzgCommitments:     b.block.body.blobKzgCommitments,
+					},
+				},
+				Signature: b.signature[:],
+			})
 	default:
 		return nil, fmt.Errorf("%T is not an execution payload header", p)
 	}
@@ -315,6 +375,11 @@ func (b *SignedBeaconBlock) MarshalSSZ() ([]byte, error) {
 			return pb.(*eth.SignedBlindedBeaconBlockCapella).MarshalSSZ()
 		}
 		return pb.(*eth.SignedBeaconBlockCapella).MarshalSSZ()
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockDeneb).MarshalSSZ()
+		}
+		return pb.(*eth.SignedBeaconBlockDeneb).MarshalSSZ()
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -342,6 +407,11 @@ func (b *SignedBeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
 			return pb.(*eth.SignedBlindedBeaconBlockCapella).MarshalSSZTo(dst)
 		}
 		return pb.(*eth.SignedBeaconBlockCapella).MarshalSSZTo(dst)
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockDeneb).MarshalSSZTo(dst)
+		}
+		return pb.(*eth.SignedBeaconBlockDeneb).MarshalSSZTo(dst)
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -373,6 +443,11 @@ func (b *SignedBeaconBlock) SizeSSZ() int {
 			return pb.(*eth.SignedBlindedBeaconBlockCapella).SizeSSZ()
 		}
 		return pb.(*eth.SignedBeaconBlockCapella).SizeSSZ()
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.SignedBlindedBeaconBlockDeneb).SizeSSZ()
+		}
+		return pb.(*eth.SignedBeaconBlockDeneb).SizeSSZ()
 	default:
 		panic(incorrectBlockVersion)
 	}
@@ -446,6 +521,28 @@ func (b *SignedBeaconBlock) UnmarshalSSZ(buf []byte) error {
 				return err
 			}
 		}
+	case version.Deneb:
+		if b.IsBlinded() {
+			pb := &eth.SignedBlindedBeaconBlockDeneb{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlindedSignedBlockFromProtoDeneb(pb)
+			if err != nil {
+				return err
+			}
+		} else {
+			pb := &eth.SignedBeaconBlockDeneb{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initSignedBlockFromProtoDeneb(pb)
+			if err != nil {
+				return err
+			}
+		}
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -514,6 +611,11 @@ func (b *BeaconBlock) HashTreeRoot() ([field_params.RootLength]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockCapella).HashTreeRoot()
 		}
 		return pb.(*eth.BeaconBlockCapella).HashTreeRoot()
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockDeneb).HashTreeRoot()
+		}
+		return pb.(*eth.BeaconBlockDeneb).HashTreeRoot()
 	default:
 		return [field_params.RootLength]byte{}, errIncorrectBlockVersion
 	}
@@ -540,6 +642,11 @@ func (b *BeaconBlock) HashTreeRootWith(h *ssz.Hasher) error {
 			return pb.(*eth.BlindedBeaconBlockCapella).HashTreeRootWith(h)
 		}
 		return pb.(*eth.BeaconBlockCapella).HashTreeRootWith(h)
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockDeneb).HashTreeRootWith(h)
+		}
+		return pb.(*eth.BeaconBlockDeneb).HashTreeRootWith(h)
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -567,6 +674,11 @@ func (b *BeaconBlock) MarshalSSZ() ([]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockCapella).MarshalSSZ()
 		}
 		return pb.(*eth.BeaconBlockCapella).MarshalSSZ()
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockDeneb).MarshalSSZ()
+		}
+		return pb.(*eth.BeaconBlockDeneb).MarshalSSZ()
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -594,6 +706,11 @@ func (b *BeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) {
 			return pb.(*eth.BlindedBeaconBlockCapella).MarshalSSZTo(dst)
 		}
 		return pb.(*eth.BeaconBlockCapella).MarshalSSZTo(dst)
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockDeneb).MarshalSSZTo(dst)
+		}
+		return pb.(*eth.BeaconBlockDeneb).MarshalSSZTo(dst)
 	default:
 		return []byte{}, errIncorrectBlockVersion
 	}
@@ -625,6 +742,11 @@ func (b *BeaconBlock) SizeSSZ() int {
 			return pb.(*eth.BlindedBeaconBlockCapella).SizeSSZ()
 		}
 		return pb.(*eth.BeaconBlockCapella).SizeSSZ()
+	case version.Deneb:
+		if b.IsBlinded() {
+			return pb.(*eth.BlindedBeaconBlockDeneb).SizeSSZ()
+		}
+		return pb.(*eth.BeaconBlockDeneb).SizeSSZ()
 	default:
 		panic(incorrectBodyVersion)
 	}
@@ -698,6 +820,28 @@ func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error {
 				return err
 			}
 		}
+	case version.Deneb:
+		if b.IsBlinded() {
+			pb := &eth.BlindedBeaconBlockDeneb{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlindedBlockFromProtoDeneb(pb)
+			if err != nil {
+				return err
+			}
+		} else {
+			pb := &eth.BeaconBlockDeneb{}
+			if err := pb.UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			var err error
+			newBlock, err = initBlockFromProtoDeneb(pb)
+			if err != nil {
+				return err
+			}
+		}
 	default:
 		return errIncorrectBlockVersion
 	}
@@ -761,6 +905,13 @@ func (b *BeaconBlock) Copy() (interfaces.ReadOnlyBeaconBlock, error) {
 		}
 		cp := eth.CopyBeaconBlockCapella(pb.(*eth.BeaconBlockCapella))
 		return initBlockFromProtoCapella(cp)
+	case version.Deneb:
+		if b.IsBlinded() {
+			cp := eth.CopyBlindedBeaconBlockDeneb(pb.(*eth.BlindedBeaconBlockDeneb))
+			return initBlindedBlockFromProtoDeneb(cp)
+		}
+		cp := eth.CopyBeaconBlockDeneb(pb.(*eth.BeaconBlockDeneb))
+		return initBlockFromProtoDeneb(cp)
 	default:
 		return nil, errIncorrectBlockVersion
 	}
@@ -866,6 +1017,27 @@ func (b *BeaconBlockBody) Execution() (interfaces.ExecutionData, error) {
 			}
 		}
 		return WrappedExecutionPayloadCapella(p, 0)
+	case version.Deneb:
+		if b.isBlinded {
+			var ph *enginev1.ExecutionPayloadHeaderDeneb
+			var ok bool
+			if b.executionPayloadHeader != nil {
+				ph, ok = b.executionPayloadHeader.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+				if !ok {
+					return nil, errPayloadHeaderWrongType
+				}
+				return WrappedExecutionPayloadHeaderDeneb(ph, 0)
+			}
+		}
+		var p *enginev1.ExecutionPayloadDeneb
+		var ok bool
+		if b.executionPayload != nil {
+			p, ok = b.executionPayload.Proto().(*enginev1.ExecutionPayloadDeneb)
+			if !ok {
+				return nil, errPayloadWrongType
+			}
+		}
+		return WrappedExecutionPayloadDeneb(p, 0)
 	default:
 		return nil, errIncorrectBlockVersion
 	}
@@ -878,6 +1050,18 @@ func (b *BeaconBlockBody) BLSToExecutionChanges() ([]*eth.SignedBLSToExecutionCh
 	return b.blsToExecutionChanges, nil
 }
 
+// BlobKzgCommitments returns the blob kzg commitments in the block.
+func (b *BeaconBlockBody) BlobKzgCommitments() ([][]byte, error) {
+	switch b.version {
+	case version.Phase0, version.Altair, version.Bellatrix, version.Capella:
+		return nil, consensus_types.ErrNotSupported("BlobKzgCommitments", b.version)
+	case version.Deneb:
+		return b.blobKzgCommitments, nil
+	default:
+		return nil, errIncorrectBlockVersion
+	}
+}
+
 // HashTreeRoot returns the ssz root of the block body.
 func (b *BeaconBlockBody) HashTreeRoot() ([field_params.RootLength]byte, error) {
 	pb, err := b.Proto()
@@ -899,6 +1083,11 @@ func (b *BeaconBlockBody) HashTreeRoot() ([field_params.RootLength]byte, error)
 			return pb.(*eth.BlindedBeaconBlockBodyCapella).HashTreeRoot()
 		}
 		return pb.(*eth.BeaconBlockBodyCapella).HashTreeRoot()
+	case version.Deneb:
+		if b.isBlinded {
+			return pb.(*eth.BlindedBeaconBlockBodyDeneb).HashTreeRoot()
+		}
+		return pb.(*eth.BeaconBlockBodyDeneb).HashTreeRoot()
 	default:
 		return [field_params.RootLength]byte{}, errIncorrectBodyVersion
 	}

consensus-types/blocks/getters_test.go

@@ -212,6 +212,37 @@ func Test_BeaconBlock_Copy(t *testing.T) {
 	require.NoError(t, err)
 	assert.NotEqual(t, cp, b)
 	assert.NotEqual(t, cp.Body(), bb)
+
+	payload := &pb.ExecutionPayloadDeneb{ExcessDataGas: bytesutil.PadTo([]byte{123}, 32)}
+	header := &pb.ExecutionPayloadHeaderDeneb{ExcessDataGas: bytesutil.PadTo([]byte{223}, 32)}
+	payloadInterface, err := WrappedExecutionPayloadDeneb(payload, 123)
+	require.NoError(t, err)
+	headerInterface, err := WrappedExecutionPayloadHeaderDeneb(header, 123)
+	require.NoError(t, err)
+	bb = &BeaconBlockBody{executionPayload: payloadInterface, executionPayloadHeader: headerInterface, randaoReveal: bytesutil.ToBytes96([]byte{246}), graffiti: bytesutil.ToBytes32([]byte("graffiti"))}
+	b = &BeaconBlock{body: bb, slot: 123, proposerIndex: 456, parentRoot: bytesutil.ToBytes32([]byte("parentroot")), stateRoot: bytesutil.ToBytes32([]byte("stateroot"))}
+	b.version = version.Deneb
+	b.body.version = b.version
+	cp, err = b.Copy()
+	require.NoError(t, err)
+	assert.NotEqual(t, cp, b)
+	assert.NotEqual(t, cp.Body(), bb)
+	e, err := cp.Body().Execution()
+	require.NoError(t, err)
+	gas, err := e.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, gas, bytesutil.PadTo([]byte{123}, 32))
+
+	b.body.isBlinded = true
+	cp, err = b.Copy()
+	require.NoError(t, err)
+	assert.NotEqual(t, cp, b)
+	assert.NotEqual(t, cp.Body(), bb)
+	e, err = cp.Body().Execution()
+	require.NoError(t, err)
+	gas, err = e.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, gas, bytesutil.PadTo([]byte{223}, 32))
 }
 
 func Test_BeaconBlock_IsNil(t *testing.T) {
@@ -407,6 +438,30 @@ func Test_BeaconBlockBody_Execution(t *testing.T) {
 	result, err = bb.Block().Body().Execution()
 	require.NoError(t, err)
 	assert.DeepEqual(t, result, eCapellaHeader)
+
+	executionDeneb := &pb.ExecutionPayloadDeneb{BlockNumber: 1, ExcessDataGas: bytesutil.PadTo([]byte{123}, 32)}
+	eDeneb, err := WrappedExecutionPayloadDeneb(executionDeneb, 0)
+	require.NoError(t, err)
+	bb = &SignedBeaconBlock{version: version.Deneb, block: &BeaconBlock{body: &BeaconBlockBody{version: version.Deneb}}}
+	require.NoError(t, bb.SetExecution(eDeneb))
+	result, err = bb.Block().Body().Execution()
+	require.NoError(t, err)
+	assert.DeepEqual(t, result, eDeneb)
+	gas, err := eDeneb.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, gas, bytesutil.PadTo([]byte{123}, 32))
+
+	executionDenebHeader := &pb.ExecutionPayloadHeaderDeneb{BlockNumber: 1, ExcessDataGas: bytesutil.PadTo([]byte{223}, 32)}
+	eDenebHeader, err := WrappedExecutionPayloadHeaderDeneb(executionDenebHeader, 0)
+	require.NoError(t, err)
+	bb = &SignedBeaconBlock{version: version.Deneb, block: &BeaconBlock{version: version.Deneb, body: &BeaconBlockBody{version: version.Deneb, isBlinded: true}}}
+	require.NoError(t, bb.SetExecution(eDenebHeader))
+	result, err = bb.Block().Body().Execution()
+	require.NoError(t, err)
+	assert.DeepEqual(t, result, eDenebHeader)
+	gas, err = eDenebHeader.ExcessDataGas()
+	require.NoError(t, err)
+	require.DeepEqual(t, gas, bytesutil.PadTo([]byte{223}, 32))
 }
 
 func Test_BeaconBlockBody_HashTreeRoot(t *testing.T) {

consensus-types/blocks/proto.go

@@ -102,6 +102,33 @@ func (b *SignedBeaconBlock) Proto() (proto.Message, error) {
 			Block:     block,
 			Signature: b.signature[:],
 		}, nil
+	case version.Deneb:
+		if b.IsBlinded() {
+			var block *eth.BlindedBeaconBlockDeneb
+			if blockMessage != nil {
+				var ok bool
+				block, ok = blockMessage.(*eth.BlindedBeaconBlockDeneb)
+				if !ok {
+					return nil, errIncorrectBlockVersion
+				}
+			}
+			return &eth.SignedBlindedBeaconBlockDeneb{
+				Block:     block,
+				Signature: b.signature[:],
+			}, nil
+		}
+		var block *eth.BeaconBlockDeneb
+		if blockMessage != nil {
+			var ok bool
+			block, ok = blockMessage.(*eth.BeaconBlockDeneb)
+			if !ok {
+				return nil, errIncorrectBlockVersion
+			}
+		}
+		return &eth.SignedBeaconBlockDeneb{
+			Block:     block,
+			Signature: b.signature[:],
+		}, nil
 	default:
 		return nil, errors.New("unsupported signed beacon block version")
 	}
@@ -217,6 +244,39 @@ func (b *BeaconBlock) Proto() (proto.Message, error) {
 			StateRoot:     b.stateRoot[:],
 			Body:          body,
 		}, nil
+	case version.Deneb:
+		if b.IsBlinded() {
+			var body *eth.BlindedBeaconBlockBodyDeneb
+			if bodyMessage != nil {
+				var ok bool
+				body, ok = bodyMessage.(*eth.BlindedBeaconBlockBodyDeneb)
+				if !ok {
+					return nil, errIncorrectBodyVersion
+				}
+			}
+			return &eth.BlindedBeaconBlockDeneb{
+				Slot:          b.slot,
+				ProposerIndex: b.proposerIndex,
+				ParentRoot:    b.parentRoot[:],
+				StateRoot:     b.stateRoot[:],
+				Body:          body,
+			}, nil
+		}
+		var body *eth.BeaconBlockBodyDeneb
+		if bodyMessage != nil {
+			var ok bool
+			body, ok = bodyMessage.(*eth.BeaconBlockBodyDeneb)
+			if !ok {
+				return nil, errIncorrectBodyVersion
+			}
+		}
+		return &eth.BeaconBlockDeneb{
+			Slot:          b.slot,
+			ProposerIndex: b.proposerIndex,
+			ParentRoot:    b.parentRoot[:],
+			StateRoot:     b.stateRoot[:],
+			Body:          body,
+		}, nil
 	default:
 		return nil, errors.New("unsupported beacon block version")
 	}
@@ -340,6 +400,53 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) {
 			ExecutionPayload:      p,
 			BlsToExecutionChanges: b.blsToExecutionChanges,
 		}, nil
+	case version.Deneb:
+		if b.isBlinded {
+			var ph *enginev1.ExecutionPayloadHeaderDeneb
+			var ok bool
+			if b.executionPayloadHeader != nil {
+				ph, ok = b.executionPayloadHeader.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+				if !ok {
+					return nil, errPayloadHeaderWrongType
+				}
+			}
+			return &eth.BlindedBeaconBlockBodyDeneb{
+				RandaoReveal:           b.randaoReveal[:],
+				Eth1Data:               b.eth1Data,
+				Graffiti:               b.graffiti[:],
+				ProposerSlashings:      b.proposerSlashings,
+				AttesterSlashings:      b.attesterSlashings,
+				Attestations:           b.attestations,
+				Deposits:               b.deposits,
+				VoluntaryExits:         b.voluntaryExits,
+				SyncAggregate:          b.syncAggregate,
+				ExecutionPayloadHeader: ph,
+				BlsToExecutionChanges:  b.blsToExecutionChanges,
+				BlobKzgCommitments:     b.blobKzgCommitments,
+			}, nil
+		}
+		var p *enginev1.ExecutionPayloadDeneb
+		var ok bool
+		if b.executionPayload != nil {
+			p, ok = b.executionPayload.Proto().(*enginev1.ExecutionPayloadDeneb)
+			if !ok {
+				return nil, errPayloadWrongType
+			}
+		}
+		return &eth.BeaconBlockBodyDeneb{
+			RandaoReveal:          b.randaoReveal[:],
+			Eth1Data:              b.eth1Data,
+			Graffiti:              b.graffiti[:],
+			ProposerSlashings:     b.proposerSlashings,
+			AttesterSlashings:     b.attesterSlashings,
+			Attestations:          b.attestations,
+			Deposits:              b.deposits,
+			VoluntaryExits:        b.voluntaryExits,
+			SyncAggregate:         b.syncAggregate,
+			ExecutionPayload:      p,
+			BlsToExecutionChanges: b.blsToExecutionChanges,
+			BlobKzgCommitments:    b.blobKzgCommitments,
+		}, nil
 	default:
 		return nil, errors.New("unsupported beacon block body version")
 	}
@@ -413,6 +520,23 @@ func initSignedBlockFromProtoCapella(pb *eth.SignedBeaconBlockCapella) (*SignedB
 	return b, nil
 }
 
+func initSignedBlockFromProtoDeneb(pb *eth.SignedBeaconBlockDeneb) (*SignedBeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	block, err := initBlockFromProtoDeneb(pb.Block)
+	if err != nil {
+		return nil, err
+	}
+	b := &SignedBeaconBlock{
+		version:   version.Deneb,
+		block:     block,
+		signature: bytesutil.ToBytes96(pb.Signature),
+	}
+	return b, nil
+}
+
 func initBlindedSignedBlockFromProtoBellatrix(pb *eth.SignedBlindedBeaconBlockBellatrix) (*SignedBeaconBlock, error) {
 	if pb == nil {
 		return nil, errNilBlock
@@ -447,6 +571,23 @@ func initBlindedSignedBlockFromProtoCapella(pb *eth.SignedBlindedBeaconBlockCape
 	return b, nil
 }
 
+func initBlindedSignedBlockFromProtoDeneb(pb *eth.SignedBlindedBeaconBlockDeneb) (*SignedBeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	block, err := initBlindedBlockFromProtoDeneb(pb.Block)
+	if err != nil {
+		return nil, err
+	}
+	b := &SignedBeaconBlock{
+		version:   version.Deneb,
+		block:     block,
+		signature: bytesutil.ToBytes96(pb.Signature),
+	}
+	return b, nil
+}
+
 func initBlockFromProtoPhase0(pb *eth.BeaconBlock) (*BeaconBlock, error) {
 	if pb == nil {
 		return nil, errNilBlock
@@ -547,6 +688,26 @@ func initBlockFromProtoCapella(pb *eth.BeaconBlockCapella) (*BeaconBlock, error)
 	return b, nil
 }
 
+func initBlockFromProtoDeneb(pb *eth.BeaconBlockDeneb) (*BeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	body, err := initBlockBodyFromProtoDeneb(pb.Body)
+	if err != nil {
+		return nil, err
+	}
+	b := &BeaconBlock{
+		version:       version.Deneb,
+		slot:          pb.Slot,
+		proposerIndex: pb.ProposerIndex,
+		parentRoot:    bytesutil.ToBytes32(pb.ParentRoot),
+		stateRoot:     bytesutil.ToBytes32(pb.StateRoot),
+		body:          body,
+	}
+	return b, nil
+}
+
 func initBlindedBlockFromProtoCapella(pb *eth.BlindedBeaconBlockCapella) (*BeaconBlock, error) {
 	if pb == nil {
 		return nil, errNilBlock
@@ -567,6 +728,26 @@ func initBlindedBlockFromProtoCapella(pb *eth.BlindedBeaconBlockCapella) (*Beaco
 	return b, nil
 }
 
+func initBlindedBlockFromProtoDeneb(pb *eth.BlindedBeaconBlockDeneb) (*BeaconBlock, error) {
+	if pb == nil {
+		return nil, errNilBlock
+	}
+
+	body, err := initBlindedBlockBodyFromProtoDeneb(pb.Body)
+	if err != nil {
+		return nil, err
+	}
+	b := &BeaconBlock{
+		version:       version.Deneb,
+		slot:          pb.Slot,
+		proposerIndex: pb.ProposerIndex,
+		parentRoot:    bytesutil.ToBytes32(pb.ParentRoot),
+		stateRoot:     bytesutil.ToBytes32(pb.StateRoot),
+		body:          body,
+	}
+	return b, nil
+}
+
 func initBlockBodyFromProtoPhase0(pb *eth.BeaconBlockBody) (*BeaconBlockBody, error) {
 	if pb == nil {
 		return nil, errNilBlockBody
@@ -717,3 +898,61 @@ func initBlindedBlockBodyFromProtoCapella(pb *eth.BlindedBeaconBlockBodyCapella)
 	}
 	return b, nil
 }
+
+func initBlockBodyFromProtoDeneb(pb *eth.BeaconBlockBodyDeneb) (*BeaconBlockBody, error) {
+	if pb == nil {
+		return nil, errNilBlockBody
+	}
+
+	p, err := WrappedExecutionPayloadDeneb(pb.ExecutionPayload, 0)
+	// We allow the payload to be nil
+	if err != nil && err != consensus_types.ErrNilObjectWrapped {
+		return nil, err
+	}
+	b := &BeaconBlockBody{
+		version:               version.Deneb,
+		isBlinded:             false,
+		randaoReveal:          bytesutil.ToBytes96(pb.RandaoReveal),
+		eth1Data:              pb.Eth1Data,
+		graffiti:              bytesutil.ToBytes32(pb.Graffiti),
+		proposerSlashings:     pb.ProposerSlashings,
+		attesterSlashings:     pb.AttesterSlashings,
+		attestations:          pb.Attestations,
+		deposits:              pb.Deposits,
+		voluntaryExits:        pb.VoluntaryExits,
+		syncAggregate:         pb.SyncAggregate,
+		executionPayload:      p,
+		blsToExecutionChanges: pb.BlsToExecutionChanges,
+		blobKzgCommitments:    pb.BlobKzgCommitments,
+	}
+	return b, nil
+}
+
+func initBlindedBlockBodyFromProtoDeneb(pb *eth.BlindedBeaconBlockBodyDeneb) (*BeaconBlockBody, error) {
+	if pb == nil {
+		return nil, errNilBlockBody
+	}
+
+	ph, err := WrappedExecutionPayloadHeaderDeneb(pb.ExecutionPayloadHeader, 0)
+	// We allow the payload to be nil
+	if err != nil && err != consensus_types.ErrNilObjectWrapped {
+		return nil, err
+	}
+	b := &BeaconBlockBody{
+		version:                version.Deneb,
+		isBlinded:              true,
+		randaoReveal:           bytesutil.ToBytes96(pb.RandaoReveal),
+		eth1Data:               pb.Eth1Data,
+		graffiti:               bytesutil.ToBytes32(pb.Graffiti),
+		proposerSlashings:      pb.ProposerSlashings,
+		attesterSlashings:      pb.AttesterSlashings,
+		attestations:           pb.Attestations,
+		deposits:               pb.Deposits,
+		voluntaryExits:         pb.VoluntaryExits,
+		syncAggregate:          pb.SyncAggregate,
+		executionPayloadHeader: ph,
+		blsToExecutionChanges:  pb.BlsToExecutionChanges,
+		blobKzgCommitments:     pb.BlobKzgCommitments,
+	}
+	return b, nil
+}

consensus-types/blocks/proto_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
@@ -24,7 +25,10 @@ type fields struct {
 	execPayloadHeader        *enginev1.ExecutionPayloadHeader
 	execPayloadCapella       *enginev1.ExecutionPayloadCapella
 	execPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
+	execPayloadDeneb         *enginev1.ExecutionPayloadDeneb
+	execPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb
 	blsToExecutionChanges    []*eth.SignedBLSToExecutionChange
+	kzgCommitments           [][]byte
 }
 
 func Test_SignedBeaconBlock_Proto(t *testing.T) {
@@ -234,6 +238,74 @@ func Test_SignedBeaconBlock_Proto(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedHTR, resultHTR)
 	})
+	t.Run("Deneb", func(t *testing.T) {
+		expectedBlock := &eth.SignedBeaconBlockDeneb{
+			Block: &eth.BeaconBlockDeneb{
+				Slot:          128,
+				ProposerIndex: 128,
+				ParentRoot:    f.root[:],
+				StateRoot:     f.root[:],
+				Body:          bodyPbDeneb(),
+			},
+			Signature: f.sig[:],
+		}
+		block := &SignedBeaconBlock{
+			version: version.Deneb,
+			block: &BeaconBlock{
+				version:       version.Deneb,
+				slot:          128,
+				proposerIndex: 128,
+				parentRoot:    f.root,
+				stateRoot:     f.root,
+				body:          bodyDeneb(t),
+			},
+			signature: f.sig,
+		}
+
+		result, err := block.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.SignedBeaconBlockDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBlock.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
+	t.Run("DenebBlind", func(t *testing.T) {
+		expectedBlock := &eth.SignedBlindedBeaconBlockDeneb{
+			Block: &eth.BlindedBeaconBlockDeneb{
+				Slot:          128,
+				ProposerIndex: 128,
+				ParentRoot:    f.root[:],
+				StateRoot:     f.root[:],
+				Body:          bodyPbBlindedDeneb(),
+			},
+			Signature: f.sig[:],
+		}
+		block := &SignedBeaconBlock{
+			version: version.Deneb,
+			block: &BeaconBlock{
+				version:       version.Deneb,
+				slot:          128,
+				proposerIndex: 128,
+				parentRoot:    f.root,
+				stateRoot:     f.root,
+				body:          bodyBlindedDeneb(t),
+			},
+			signature: f.sig,
+		}
+
+		result, err := block.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.SignedBlindedBeaconBlockDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBlock.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
 }
 
 func Test_BeaconBlock_Proto(t *testing.T) {
@@ -401,6 +473,60 @@ func Test_BeaconBlock_Proto(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedHTR, resultHTR)
 	})
+	t.Run("Deneb", func(t *testing.T) {
+		expectedBlock := &eth.BeaconBlockDeneb{
+			Slot:          128,
+			ProposerIndex: 128,
+			ParentRoot:    f.root[:],
+			StateRoot:     f.root[:],
+			Body:          bodyPbDeneb(),
+		}
+		block := &BeaconBlock{
+			version:       version.Deneb,
+			slot:          128,
+			proposerIndex: 128,
+			parentRoot:    f.root,
+			stateRoot:     f.root,
+			body:          bodyDeneb(t),
+		}
+
+		result, err := block.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.BeaconBlockDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBlock.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
+	t.Run("DenebBlind", func(t *testing.T) {
+		expectedBlock := &eth.BlindedBeaconBlockDeneb{
+			Slot:          128,
+			ProposerIndex: 128,
+			ParentRoot:    f.root[:],
+			StateRoot:     f.root[:],
+			Body:          bodyPbBlindedDeneb(),
+		}
+		block := &BeaconBlock{
+			version:       version.Deneb,
+			slot:          128,
+			proposerIndex: 128,
+			parentRoot:    f.root,
+			stateRoot:     f.root,
+			body:          bodyBlindedDeneb(t),
+		}
+
+		result, err := block.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.BlindedBeaconBlockDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBlock.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
 }
 
 func Test_BeaconBlockBody_Proto(t *testing.T) {
@@ -483,6 +609,32 @@ func Test_BeaconBlockBody_Proto(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedHTR, resultHTR)
 	})
+	t.Run("Deneb", func(t *testing.T) {
+		expectedBody := bodyPbDeneb()
+		body := bodyDeneb(t)
+		result, err := body.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.BeaconBlockBodyDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBody.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
+	t.Run("DenebBlind", func(t *testing.T) {
+		expectedBody := bodyPbBlindedDeneb()
+		body := bodyBlindedDeneb(t)
+		result, err := body.Proto()
+		require.NoError(t, err)
+		resultBlock, ok := result.(*eth.BlindedBeaconBlockBodyDeneb)
+		require.Equal(t, true, ok)
+		resultHTR, err := resultBlock.HashTreeRoot()
+		require.NoError(t, err)
+		expectedHTR, err := expectedBody.HashTreeRoot()
+		require.NoError(t, err)
+		assert.DeepEqual(t, expectedHTR, resultHTR)
+	})
 	t.Run("Bellatrix - wrong payload type", func(t *testing.T) {
 		body := bodyBellatrix(t)
 		body.executionPayload = &executionPayloadHeader{}
@@ -507,6 +659,18 @@ func Test_BeaconBlockBody_Proto(t *testing.T) {
 		_, err := body.Proto()
 		require.ErrorIs(t, err, errPayloadHeaderWrongType)
 	})
+	t.Run("Deneb - wrong payload type", func(t *testing.T) {
+		body := bodyDeneb(t)
+		body.executionPayload = &executionPayloadHeaderDeneb{}
+		_, err := body.Proto()
+		require.ErrorIs(t, err, errPayloadWrongType)
+	})
+	t.Run("DenebBlind - wrong payload type", func(t *testing.T) {
+		body := bodyBlindedDeneb(t)
+		body.executionPayloadHeader = &executionPayloadDeneb{}
+		_, err := body.Proto()
+		require.ErrorIs(t, err, errPayloadHeaderWrongType)
+	})
 }
 
 func Test_initSignedBlockFromProtoPhase0(t *testing.T) {
@@ -641,6 +805,50 @@ func Test_initBlindedSignedBlockFromProtoCapella(t *testing.T) {
 	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature[:])
 }
 
+func Test_initSignedBlockFromProtoDeneb(t *testing.T) {
+	f := getFields()
+	expectedBlock := &eth.SignedBeaconBlockDeneb{
+		Block: &eth.BeaconBlockDeneb{
+			Slot:          128,
+			ProposerIndex: 128,
+			ParentRoot:    f.root[:],
+			StateRoot:     f.root[:],
+			Body:          bodyPbDeneb(),
+		},
+		Signature: f.sig[:],
+	}
+	resultBlock, err := initSignedBlockFromProtoDeneb(expectedBlock)
+	require.NoError(t, err)
+	resultHTR, err := resultBlock.block.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature[:])
+}
+
+func Test_initBlindedSignedBlockFromProtoDeneb(t *testing.T) {
+	f := getFields()
+	expectedBlock := &eth.SignedBlindedBeaconBlockDeneb{
+		Block: &eth.BlindedBeaconBlockDeneb{
+			Slot:          128,
+			ProposerIndex: 128,
+			ParentRoot:    f.root[:],
+			StateRoot:     f.root[:],
+			Body:          bodyPbBlindedDeneb(),
+		},
+		Signature: f.sig[:],
+	}
+	resultBlock, err := initBlindedSignedBlockFromProtoDeneb(expectedBlock)
+	require.NoError(t, err)
+	resultHTR, err := resultBlock.block.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+	assert.DeepEqual(t, expectedBlock.Signature, resultBlock.signature[:])
+}
+
 func Test_initBlockFromProtoPhase0(t *testing.T) {
 	f := getFields()
 	expectedBlock := &eth.BeaconBlock{
@@ -749,6 +957,42 @@ func Test_initBlockFromProtoBlindedCapella(t *testing.T) {
 	assert.DeepEqual(t, expectedHTR, resultHTR)
 }
 
+func Test_initBlockFromProtoDeneb(t *testing.T) {
+	f := getFields()
+	expectedBlock := &eth.BeaconBlockDeneb{
+		Slot:          128,
+		ProposerIndex: 128,
+		ParentRoot:    f.root[:],
+		StateRoot:     f.root[:],
+		Body:          bodyPbDeneb(),
+	}
+	resultBlock, err := initBlockFromProtoDeneb(expectedBlock)
+	require.NoError(t, err)
+	resultHTR, err := resultBlock.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBlock.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+}
+
+func Test_initBlockFromProtoBlindedDeneb(t *testing.T) {
+	f := getFields()
+	expectedBlock := &eth.BlindedBeaconBlockDeneb{
+		Slot:          128,
+		ProposerIndex: 128,
+		ParentRoot:    f.root[:],
+		StateRoot:     f.root[:],
+		Body:          bodyPbBlindedDeneb(),
+	}
+	resultBlock, err := initBlindedBlockFromProtoDeneb(expectedBlock)
+	require.NoError(t, err)
+	resultHTR, err := resultBlock.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBlock.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+}
+
 func Test_initBlockBodyFromProtoPhase0(t *testing.T) {
 	expectedBody := bodyPbPhase0()
 	resultBody, err := initBlockBodyFromProtoPhase0(expectedBody)
@@ -815,6 +1059,28 @@ func Test_initBlockBodyFromProtoBlindedCapella(t *testing.T) {
 	assert.DeepEqual(t, expectedHTR, resultHTR)
 }
 
+func Test_initBlockBodyFromProtoDeneb(t *testing.T) {
+	expectedBody := bodyPbDeneb()
+	resultBody, err := initBlockBodyFromProtoDeneb(expectedBody)
+	require.NoError(t, err)
+	resultHTR, err := resultBody.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBody.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+}
+
+func Test_initBlockBodyFromProtoBlindedDeneb(t *testing.T) {
+	expectedBody := bodyPbBlindedDeneb()
+	resultBody, err := initBlindedBlockBodyFromProtoDeneb(expectedBody)
+	require.NoError(t, err)
+	resultHTR, err := resultBody.HashTreeRoot()
+	require.NoError(t, err)
+	expectedHTR, err := expectedBody.HashTreeRoot()
+	require.NoError(t, err)
+	assert.DeepEqual(t, expectedHTR, resultHTR)
+}
+
 func bodyPbPhase0() *eth.BeaconBlockBody {
 	f := getFields()
 	return &eth.BeaconBlockBody{
@@ -934,6 +1200,50 @@ func bodyPbBlindedCapella() *eth.BlindedBeaconBlockBodyCapella {
 	}
 }
 
+func bodyPbDeneb() *eth.BeaconBlockBodyDeneb {
+	f := getFields()
+	return &eth.BeaconBlockBodyDeneb{
+		RandaoReveal: f.sig[:],
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot:  f.root[:],
+			DepositCount: 128,
+			BlockHash:    f.root[:],
+		},
+		Graffiti:              f.root[:],
+		ProposerSlashings:     f.proposerSlashings,
+		AttesterSlashings:     f.attesterSlashings,
+		Attestations:          f.atts,
+		Deposits:              f.deposits,
+		VoluntaryExits:        f.voluntaryExits,
+		SyncAggregate:         f.syncAggregate,
+		ExecutionPayload:      f.execPayloadDeneb,
+		BlsToExecutionChanges: f.blsToExecutionChanges,
+		BlobKzgCommitments:    f.kzgCommitments,
+	}
+}
+
+func bodyPbBlindedDeneb() *eth.BlindedBeaconBlockBodyDeneb {
+	f := getFields()
+	return &eth.BlindedBeaconBlockBodyDeneb{
+		RandaoReveal: f.sig[:],
+		Eth1Data: &eth.Eth1Data{
+			DepositRoot:  f.root[:],
+			DepositCount: 128,
+			BlockHash:    f.root[:],
+		},
+		Graffiti:               f.root[:],
+		ProposerSlashings:      f.proposerSlashings,
+		AttesterSlashings:      f.attesterSlashings,
+		Attestations:           f.atts,
+		Deposits:               f.deposits,
+		VoluntaryExits:         f.voluntaryExits,
+		SyncAggregate:          f.syncAggregate,
+		ExecutionPayloadHeader: f.execPayloadHeaderDeneb,
+		BlsToExecutionChanges:  f.blsToExecutionChanges,
+		BlobKzgCommitments:     f.kzgCommitments,
+	}
+}
+
 func bodyPhase0() *BeaconBlockBody {
 	f := getFields()
 	return &BeaconBlockBody{
@@ -1069,6 +1379,57 @@ func bodyBlindedCapella(t *testing.T) *BeaconBlockBody {
 	}
 }
 
+func bodyDeneb(t *testing.T) *BeaconBlockBody {
+	f := getFields()
+	p, err := WrappedExecutionPayloadDeneb(f.execPayloadDeneb, 0)
+	require.NoError(t, err)
+	return &BeaconBlockBody{
+		version:      version.Deneb,
+		randaoReveal: f.sig,
+		eth1Data: &eth.Eth1Data{
+			DepositRoot:  f.root[:],
+			DepositCount: 128,
+			BlockHash:    f.root[:],
+		},
+		graffiti:              f.root,
+		proposerSlashings:     f.proposerSlashings,
+		attesterSlashings:     f.attesterSlashings,
+		attestations:          f.atts,
+		deposits:              f.deposits,
+		voluntaryExits:        f.voluntaryExits,
+		syncAggregate:         f.syncAggregate,
+		executionPayload:      p,
+		blsToExecutionChanges: f.blsToExecutionChanges,
+		blobKzgCommitments:    f.kzgCommitments,
+	}
+}
+
+func bodyBlindedDeneb(t *testing.T) *BeaconBlockBody {
+	f := getFields()
+	ph, err := WrappedExecutionPayloadHeaderDeneb(f.execPayloadHeaderDeneb, 0)
+	require.NoError(t, err)
+	return &BeaconBlockBody{
+		version:      version.Deneb,
+		isBlinded:    true,
+		randaoReveal: f.sig,
+		eth1Data: &eth.Eth1Data{
+			DepositRoot:  f.root[:],
+			DepositCount: 128,
+			BlockHash:    f.root[:],
+		},
+		graffiti:               f.root,
+		proposerSlashings:      f.proposerSlashings,
+		attesterSlashings:      f.attesterSlashings,
+		attestations:           f.atts,
+		deposits:               f.deposits,
+		voluntaryExits:         f.voluntaryExits,
+		syncAggregate:          f.syncAggregate,
+		executionPayloadHeader: ph,
+		blsToExecutionChanges:  f.blsToExecutionChanges,
+		blobKzgCommitments:     f.kzgCommitments,
+	}
+}
+
 func getFields() fields {
 	b20 := make([]byte, 20)
 	b48 := make([]byte, 48)
@@ -1275,6 +1636,60 @@ func getFields() fields {
 		Signature: sig[:],
 	}}
 
+	execPayloadDeneb := &enginev1.ExecutionPayloadDeneb{
+		ParentHash:    root[:],
+		FeeRecipient:  b20,
+		StateRoot:     root[:],
+		ReceiptsRoot:  root[:],
+		LogsBloom:     b256,
+		PrevRandao:    root[:],
+		BlockNumber:   128,
+		GasLimit:      128,
+		GasUsed:       128,
+		Timestamp:     128,
+		ExtraData:     root[:],
+		BaseFeePerGas: root[:],
+		BlockHash:     root[:],
+		Transactions: [][]byte{
+			[]byte("transaction1"),
+			[]byte("transaction2"),
+			[]byte("transaction8"),
+		},
+		Withdrawals: []*enginev1.Withdrawal{
+			{
+				Index:   128,
+				Address: b20,
+				Amount:  128,
+			},
+		},
+		ExcessDataGas: root[:],
+	}
+	execPayloadHeaderDeneb := &enginev1.ExecutionPayloadHeaderDeneb{
+		ParentHash:       root[:],
+		FeeRecipient:     b20,
+		StateRoot:        root[:],
+		ReceiptsRoot:     root[:],
+		LogsBloom:        b256,
+		PrevRandao:       root[:],
+		BlockNumber:      128,
+		GasLimit:         128,
+		GasUsed:          128,
+		Timestamp:        128,
+		ExtraData:        root[:],
+		BaseFeePerGas:    root[:],
+		BlockHash:        root[:],
+		TransactionsRoot: root[:],
+		WithdrawalsRoot:  root[:],
+		ExcessDataGas:    root[:],
+	}
+
+	kzgCommitments := [][]byte{
+		bytesutil.PadTo([]byte{123}, 48),
+		bytesutil.PadTo([]byte{223}, 48),
+		bytesutil.PadTo([]byte{183}, 48),
+		bytesutil.PadTo([]byte{143}, 48),
+	}
+
 	return fields{
 		root:                     root,
 		sig:                      sig,
@@ -1288,6 +1703,9 @@ func getFields() fields {
 		execPayloadHeader:        execPayloadHeader,
 		execPayloadCapella:       execPayloadCapella,
 		execPayloadHeaderCapella: execPayloadHeaderCapella,
+		execPayloadDeneb:         execPayloadDeneb,
+		execPayloadHeaderDeneb:   execPayloadHeaderDeneb,
 		blsToExecutionChanges:    blsToExecutionChanges,
+		kzgCommitments:           kzgCommitments,
 	}
 }

consensus-types/blocks/setters.go

@@ -125,3 +125,16 @@ func (b *SignedBeaconBlock) SetBLSToExecutionChanges(blsToExecutionChanges []*et
 	b.block.body.blsToExecutionChanges = blsToExecutionChanges
 	return nil
 }
+
+// SetBlobKzgCommitments sets the blob kzg commitments in the block.
+func (b *SignedBeaconBlock) SetBlobKzgCommitments(c [][]byte) error {
+	switch b.version {
+	case version.Phase0, version.Altair, version.Bellatrix, version.Capella:
+		return consensus_types.ErrNotSupported("SetBlobKzgCommitments", b.version)
+	case version.Deneb:
+		b.block.body.blobKzgCommitments = c
+		return nil
+	default:
+		return errIncorrectBlockVersion
+	}
+}

consensus-types/blocks/types.go

@@ -49,6 +49,7 @@ type BeaconBlockBody struct {
 	executionPayload       interfaces.ExecutionData
 	executionPayloadHeader interfaces.ExecutionData
 	blsToExecutionChanges  []*eth.SignedBLSToExecutionChange
+	blobKzgCommitments     [][]byte
 }
 
 // BeaconBlock is the main beacon block structure. It can represent any block type.

consensus-types/interfaces/beacon_block.go

@@ -25,7 +25,9 @@ type ReadOnlySignedBeaconBlock interface {
 	PbBellatrixBlock() (*ethpb.SignedBeaconBlockBellatrix, error)
 	PbBlindedBellatrixBlock() (*ethpb.SignedBlindedBeaconBlockBellatrix, error)
 	PbCapellaBlock() (*ethpb.SignedBeaconBlockCapella, error)
+	PbDenebBlock() (*ethpb.SignedBeaconBlockDeneb, error)
 	PbBlindedCapellaBlock() (*ethpb.SignedBlindedBeaconBlockCapella, error)
+	PbBlindedDenebBlock() (*ethpb.SignedBlindedBeaconBlockDeneb, error)
 	ssz.Marshaler
 	ssz.Unmarshaler
 	Version() int
@@ -70,12 +72,14 @@ type ReadOnlyBeaconBlockBody interface {
 	Proto() (proto.Message, error)
 	Execution() (ExecutionData, error)
 	BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error)
+	BlobKzgCommitments() ([][]byte, error)
 }
 
 type SignedBeaconBlock interface {
 	ReadOnlySignedBeaconBlock
 	SetExecution(ExecutionData) error
 	SetBLSToExecutionChanges([]*ethpb.SignedBLSToExecutionChange) error
+	SetBlobKzgCommitments(c [][]byte) error
 	SetSyncAggregate(*ethpb.SyncAggregate) error
 	SetVoluntaryExits([]*ethpb.SignedVoluntaryExit)
 	SetDeposits([]*ethpb.Deposit)
@@ -114,6 +118,7 @@ type ExecutionData interface {
 	Timestamp() uint64
 	ExtraData() []byte
 	BaseFeePerGas() []byte
+	ExcessDataGas() ([]byte, error)
 	BlockHash() []byte
 	Transactions() ([][]byte, error)
 	TransactionsRoot() ([]byte, error)

consensus-types/mock/block.go

@@ -66,6 +66,14 @@ func (SignedBeaconBlock) PbBlindedCapellaBlock() (*eth.SignedBlindedBeaconBlockC
 	panic("implement me")
 }
 
+func (SignedBeaconBlock) PbDenebBlock() (*eth.SignedBeaconBlockDeneb, error) {
+	panic("implement me")
+}
+
+func (SignedBeaconBlock) PbBlindedDenebBlock() (*eth.SignedBlindedBeaconBlockDeneb, error) {
+	panic("implement me")
+}
+
 func (SignedBeaconBlock) MarshalSSZTo(_ []byte) ([]byte, error) {
 	panic("implement me")
 }
@@ -215,10 +223,6 @@ func (BeaconBlockBody) AttesterSlashings() []*eth.AttesterSlashing {
 	panic("implement me")
 }
 
-func (BeaconBlockBody) Attestations() []*eth.Attestation {
-	panic("implement me")
-}
-
 func (BeaconBlockBody) Deposits() []*eth.Deposit {
 	panic("implement me")
 }
@@ -299,6 +303,15 @@ func (b *BeaconBlockBody) SetBLSToExecutionChanges([]*eth.SignedBLSToExecutionCh
 	panic("implement me")
 }
 
+// BlobKzgCommitments returns the blob kzg commitments in the block.
+func (b *BeaconBlockBody) BlobKzgCommitments() ([][]byte, error) {
+	panic("implement me")
+}
+
+func (b *BeaconBlockBody) Attestations() []*eth.Attestation {
+	panic("implement me")
+}
+
 var _ interfaces.ReadOnlySignedBeaconBlock = &SignedBeaconBlock{}
 var _ interfaces.ReadOnlyBeaconBlock = &BeaconBlock{}
 var _ interfaces.ReadOnlyBeaconBlockBody = &BeaconBlockBody{}