diff --git a/beacon-chain/core/transition/transition_no_verify_sig.go b/beacon-chain/core/transition/transition_no_verify_sig.go index db9e3b8bd3..64787ace88 100644 --- a/beacon-chain/core/transition/transition_no_verify_sig.go +++ b/beacon-chain/core/transition/transition_no_verify_sig.go @@ -238,7 +238,7 @@ func ProcessOperationsNoVerifyAttsSigs( if err != nil { return nil, err } - case version.Altair, version.Bellatrix, version.BellatrixBlind: + case version.Altair, version.Bellatrix: state, err = altairOperations(ctx, state, signedBeaconBlock) if err != nil { return nil, err diff --git a/beacon-chain/db/kv/blocks.go b/beacon-chain/db/kv/blocks.go index 85f25441c9..57aa732313 100644 --- a/beacon-chain/db/kv/blocks.go +++ b/beacon-chain/db/kv/blocks.go @@ -828,9 +828,10 @@ func marshalBlock(_ context.Context, blk interfaces.SignedBeaconBlock) ([]byte, } } switch blockToSave.Version() { - case version.BellatrixBlind: - return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil case version.Bellatrix: + if blockToSave.IsBlinded() { + return snappy.Encode(nil, append(bellatrixBlindKey, encodedBlock...)), nil + } return snappy.Encode(nil, append(bellatrixKey, encodedBlock...)), nil case version.Altair: return snappy.Encode(nil, append(altairKey, encodedBlock...)), nil diff --git a/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go b/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go index b6bb8fb299..8576e1f049 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go +++ b/beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go @@ -134,17 +134,19 @@ func convertToBlockContainer(blk interfaces.SignedBeaconBlock, root [32]byte, is } ctr.Block = ðpb.BeaconBlockContainer_AltairBlock{AltairBlock: rBlk} case version.Bellatrix: - rBlk, err := blk.PbBellatrixBlock() - if err != nil { - return nil, err + if blk.IsBlinded() { + rBlk, err := blk.PbBlindedBellatrixBlock() + if err != nil { + return nil, err + } + ctr.Block = ðpb.BeaconBlockContainer_BlindedBellatrixBlock{BlindedBellatrixBlock: rBlk} + } else { + rBlk, err := blk.PbBellatrixBlock() + if err != nil { + return nil, err + } + ctr.Block = ðpb.BeaconBlockContainer_BellatrixBlock{BellatrixBlock: rBlk} } - ctr.Block = ðpb.BeaconBlockContainer_BellatrixBlock{BellatrixBlock: rBlk} - case version.BellatrixBlind: - rBlk, err := blk.PbBlindedBellatrixBlock() - if err != nil { - return nil, err - } - ctr.Block = ðpb.BeaconBlockContainer_BlindedBellatrixBlock{BlindedBellatrixBlock: rBlk} default: return nil, errors.Errorf("block type is not recognized: %d", blk.Version()) } diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go index a26447d15a..0aa35eb545 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go @@ -194,7 +194,7 @@ func (vs *Server) unblindBuilderBlock(ctx context.Context, b interfaces.SignedBe } // No-op if the input block is not version blind and bellatrix. - if b.Version() != version.BellatrixBlind { + if b.Version() != version.Bellatrix || !b.IsBlinded() { return b, nil } // No-op nothing if the builder has not been configured. diff --git a/beacon-chain/sync/rpc_chunked_response.go b/beacon-chain/sync/rpc_chunked_response.go index ef93b44650..fe10a51066 100644 --- a/beacon-chain/sync/rpc_chunked_response.go +++ b/beacon-chain/sync/rpc_chunked_response.go @@ -46,7 +46,7 @@ func WriteBlockChunk(stream libp2pcore.Stream, chain blockchain.ChainInfoFetcher return err } obtainedCtx = digest[:] - case version.Bellatrix, version.BellatrixBlind: + case version.Bellatrix: valRoot := chain.GenesisValidatorsRoot() digest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().BellatrixForkEpoch, valRoot[:]) if err != nil { diff --git a/consensus-types/blocks/factory.go b/consensus-types/blocks/factory.go index 631c042a1d..88e9f721c8 100644 --- a/consensus-types/blocks/factory.go +++ b/consensus-types/blocks/factory.go @@ -121,17 +121,18 @@ func BuildSignedBeaconBlock(blk interfaces.BeaconBlock, signature []byte) (inter } return NewSignedBeaconBlock(ð.SignedBeaconBlockAltair{Block: pb, Signature: signature}) case version.Bellatrix: + if blk.IsBlinded() { + pb, ok := pb.(*eth.BlindedBeaconBlockBellatrix) + if !ok { + return nil, errIncorrectBlockVersion + } + return NewSignedBeaconBlock(ð.SignedBlindedBeaconBlockBellatrix{Block: pb, Signature: signature}) + } pb, ok := pb.(*eth.BeaconBlockBellatrix) if !ok { return nil, errIncorrectBlockVersion } return NewSignedBeaconBlock(ð.SignedBeaconBlockBellatrix{Block: pb, Signature: signature}) - case version.BellatrixBlind: - pb, ok := pb.(*eth.BlindedBeaconBlockBellatrix) - if !ok { - return nil, errIncorrectBlockVersion - } - return NewSignedBeaconBlock(ð.SignedBlindedBeaconBlockBellatrix{Block: pb, Signature: signature}) default: return nil, errUnsupportedBeaconBlock } diff --git a/consensus-types/blocks/factory_test.go b/consensus-types/blocks/factory_test.go index 3ac157aa15..4c466459e9 100644 --- a/consensus-types/blocks/factory_test.go +++ b/consensus-types/blocks/factory_test.go @@ -73,7 +73,8 @@ func Test_NewSignedBeaconBlock(t *testing.T) { Body: ð.BlindedBeaconBlockBodyBellatrix{}}}} b, err := NewSignedBeaconBlock(pb) require.NoError(t, err) - assert.Equal(t, version.BellatrixBlind, b.Version()) + assert.Equal(t, version.Bellatrix, b.Version()) + assert.Equal(t, true, b.IsBlinded()) }) t.Run("SignedBlindedBeaconBlockBellatrix", func(t *testing.T) { pb := ð.SignedBlindedBeaconBlockBellatrix{ @@ -81,7 +82,8 @@ func Test_NewSignedBeaconBlock(t *testing.T) { Body: ð.BlindedBeaconBlockBodyBellatrix{}}} b, err := NewSignedBeaconBlock(pb) require.NoError(t, err) - assert.Equal(t, version.BellatrixBlind, b.Version()) + assert.Equal(t, version.Bellatrix, b.Version()) + assert.Equal(t, true, b.IsBlinded()) }) t.Run("nil", func(t *testing.T) { _, err := NewSignedBeaconBlock(nil) @@ -134,13 +136,15 @@ func Test_NewBeaconBlock(t *testing.T) { pb := ð.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: ð.BlindedBeaconBlockBellatrix{Body: ð.BlindedBeaconBlockBodyBellatrix{}}} b, err := NewBeaconBlock(pb) require.NoError(t, err) - assert.Equal(t, version.BellatrixBlind, b.Version()) + assert.Equal(t, version.Bellatrix, b.Version()) + assert.Equal(t, true, b.IsBlinded()) }) t.Run("BlindedBeaconBlockBellatrix", func(t *testing.T) { pb := ð.BlindedBeaconBlockBellatrix{Body: ð.BlindedBeaconBlockBodyBellatrix{}} b, err := NewBeaconBlock(pb) require.NoError(t, err) - assert.Equal(t, version.BellatrixBlind, b.Version()) + assert.Equal(t, version.Bellatrix, b.Version()) + assert.Equal(t, true, b.IsBlinded()) }) t.Run("nil", func(t *testing.T) { _, err := NewBeaconBlock(nil) @@ -183,7 +187,8 @@ func Test_NewBeaconBlockBody(t *testing.T) { require.NoError(t, err) b, ok := i.(*BeaconBlockBody) require.Equal(t, true, ok) - assert.Equal(t, version.BellatrixBlind, b.version) + assert.Equal(t, version.Bellatrix, b.version) + assert.Equal(t, true, b.isBlinded) }) t.Run("nil", func(t *testing.T) { _, err := NewBeaconBlockBody(nil) @@ -219,11 +224,12 @@ func Test_BuildSignedBeaconBlock(t *testing.T) { assert.Equal(t, version.Bellatrix, sb.Version()) }) t.Run("BellatrixBlind", func(t *testing.T) { - b := &BeaconBlock{version: version.BellatrixBlind, body: &BeaconBlockBody{version: version.BellatrixBlind}} + b := &BeaconBlock{version: version.Bellatrix, body: &BeaconBlockBody{version: version.Bellatrix, isBlinded: true}} sb, err := BuildSignedBeaconBlock(b, sig) require.NoError(t, err) assert.DeepEqual(t, sig, sb.Signature()) - assert.Equal(t, version.BellatrixBlind, sb.Version()) + assert.Equal(t, version.Bellatrix, sb.Version()) + assert.Equal(t, true, sb.IsBlinded()) }) } diff --git a/consensus-types/blocks/getters.go b/consensus-types/blocks/getters.go index 3bd745578b..0eba5336f1 100644 --- a/consensus-types/blocks/getters.go +++ b/consensus-types/blocks/getters.go @@ -59,11 +59,12 @@ func (b *SignedBeaconBlock) Copy() (interfaces.SignedBeaconBlock, error) { cp := eth.CopySignedBeaconBlockAltair(pb.(*eth.SignedBeaconBlockAltair)) return initSignedBlockFromProtoAltair(cp) case version.Bellatrix: + if b.IsBlinded() { + cp := eth.CopySignedBlindedBeaconBlockBellatrix(pb.(*eth.SignedBlindedBeaconBlockBellatrix)) + return initBlindedSignedBlockFromProtoBellatrix(cp) + } cp := eth.CopySignedBeaconBlockBellatrix(pb.(*eth.SignedBeaconBlockBellatrix)) return initSignedBlockFromProtoBellatrix(cp) - case version.BellatrixBlind: - cp := eth.CopySignedBlindedBeaconBlockBellatrix(pb.(*eth.SignedBlindedBeaconBlockBellatrix)) - return initBlindedSignedBlockFromProtoBellatrix(cp) default: return nil, errIncorrectBlockVersion } @@ -85,13 +86,14 @@ func (b *SignedBeaconBlock) PbGenericBlock() (*eth.GenericSignedBeaconBlock, err Block: ð.GenericSignedBeaconBlock_Altair{Altair: pb.(*eth.SignedBeaconBlockAltair)}, }, nil case version.Bellatrix: + if b.IsBlinded() { + return ð.GenericSignedBeaconBlock{ + Block: ð.GenericSignedBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*eth.SignedBlindedBeaconBlockBellatrix)}, + }, nil + } return ð.GenericSignedBeaconBlock{ Block: ð.GenericSignedBeaconBlock_Bellatrix{Bellatrix: pb.(*eth.SignedBeaconBlockBellatrix)}, }, nil - case version.BellatrixBlind: - return ð.GenericSignedBeaconBlock{ - Block: ð.GenericSignedBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*eth.SignedBlindedBeaconBlockBellatrix)}, - }, nil default: return nil, errIncorrectBlockVersion } @@ -124,7 +126,7 @@ func (b *SignedBeaconBlock) PbAltairBlock() (*eth.SignedBeaconBlockAltair, error // PbBellatrixBlock returns the underlying protobuf object. func (b *SignedBeaconBlock) PbBellatrixBlock() (*eth.SignedBeaconBlockBellatrix, error) { - if b.version != version.Bellatrix { + if b.version != version.Bellatrix || b.IsBlinded() { return nil, errNotSupported("PbBellatrixBlock", b.version) } pb, err := b.Proto() @@ -136,7 +138,7 @@ func (b *SignedBeaconBlock) PbBellatrixBlock() (*eth.SignedBeaconBlockBellatrix, // PbBlindedBellatrixBlock returns the underlying protobuf object. func (b *SignedBeaconBlock) PbBlindedBellatrixBlock() (*eth.SignedBlindedBeaconBlockBellatrix, error) { - if b.version != version.BellatrixBlind { + if b.version != version.Bellatrix || !b.IsBlinded() { return nil, errNotSupported("PbBlindedBellatrixBlock", b.version) } pb, err := b.Proto() @@ -151,6 +153,9 @@ func (b *SignedBeaconBlock) ToBlinded() (interfaces.SignedBeaconBlock, error) { if b.version != version.Bellatrix { return nil, ErrUnsupportedVersion } + if b.IsBlinded() { + return b, nil + } if b.block.IsNil() { return nil, errors.New("cannot convert nil block to blinded format") } @@ -191,6 +196,10 @@ func (b *SignedBeaconBlock) Version() int { return b.version } +func (b *SignedBeaconBlock) IsBlinded() bool { + return b.block.body.isBlinded +} + // Header converts the underlying protobuf object from blinded block to header format. func (b *SignedBeaconBlock) Header() (*eth.SignedBeaconBlockHeader, error) { if b.IsNil() { @@ -225,9 +234,10 @@ func (b *SignedBeaconBlock) MarshalSSZ() ([]byte, error) { case version.Altair: return pb.(*eth.SignedBeaconBlockAltair).MarshalSSZ() case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZ() + } return pb.(*eth.SignedBeaconBlockBellatrix).MarshalSSZ() - case version.BellatrixBlind: - return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZ() default: return []byte{}, errIncorrectBlockVersion } @@ -246,9 +256,10 @@ func (b *SignedBeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) { case version.Altair: return pb.(*eth.SignedBeaconBlockAltair).MarshalSSZTo(dst) case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZTo(dst) + } return pb.(*eth.SignedBeaconBlockBellatrix).MarshalSSZTo(dst) - case version.BellatrixBlind: - return pb.(*eth.SignedBlindedBeaconBlockBellatrix).MarshalSSZTo(dst) default: return []byte{}, errIncorrectBlockVersion } @@ -271,9 +282,10 @@ func (b *SignedBeaconBlock) SizeSSZ() int { case version.Altair: return pb.(*eth.SignedBeaconBlockAltair).SizeSSZ() case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.SignedBlindedBeaconBlockBellatrix).SizeSSZ() + } return pb.(*eth.SignedBeaconBlockBellatrix).SizeSSZ() - case version.BellatrixBlind: - return pb.(*eth.SignedBlindedBeaconBlockBellatrix).SizeSSZ() default: panic(incorrectBlockVersion) } @@ -304,24 +316,26 @@ func (b *SignedBeaconBlock) UnmarshalSSZ(buf []byte) error { return err } case version.Bellatrix: - pb := ð.SignedBeaconBlockBellatrix{} - if err := pb.UnmarshalSSZ(buf); err != nil { - return err - } - var err error - newBlock, err = initSignedBlockFromProtoBellatrix(pb) - if err != nil { - return err - } - case version.BellatrixBlind: - pb := ð.SignedBlindedBeaconBlockBellatrix{} - if err := pb.UnmarshalSSZ(buf); err != nil { - return err - } - var err error - newBlock, err = initBlindedSignedBlockFromProtoBellatrix(pb) - if err != nil { - return err + if b.IsBlinded() { + pb := ð.SignedBlindedBeaconBlockBellatrix{} + if err := pb.UnmarshalSSZ(buf); err != nil { + return err + } + var err error + newBlock, err = initBlindedSignedBlockFromProtoBellatrix(pb) + if err != nil { + return err + } + } else { + pb := ð.SignedBeaconBlockBellatrix{} + if err := pb.UnmarshalSSZ(buf); err != nil { + return err + } + var err error + newBlock, err = initSignedBlockFromProtoBellatrix(pb) + if err != nil { + return err + } } default: return errIncorrectBlockVersion @@ -362,14 +376,7 @@ func (b *BeaconBlock) IsNil() bool { // IsBlinded checks if the beacon block is a blinded block. func (b *BeaconBlock) IsBlinded() bool { - switch b.version { - case version.Phase0, version.Altair, version.Bellatrix: - return false - case version.BellatrixBlind: - return true - default: - return false - } + return b.body.isBlinded } // Version of the underlying protobuf object. @@ -389,9 +396,10 @@ func (b *BeaconBlock) HashTreeRoot() ([32]byte, error) { case version.Altair: return pb.(*eth.BeaconBlockAltair).HashTreeRoot() case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRoot() + } return pb.(*eth.BeaconBlockBellatrix).HashTreeRoot() - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRoot() default: return [32]byte{}, errIncorrectBlockVersion } @@ -409,9 +417,10 @@ func (b *BeaconBlock) HashTreeRootWith(h *ssz.Hasher) error { case version.Altair: return pb.(*eth.BeaconBlockAltair).HashTreeRootWith(h) case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRootWith(h) + } return pb.(*eth.BeaconBlockBellatrix).HashTreeRootWith(h) - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBellatrix).HashTreeRootWith(h) default: return errIncorrectBlockVersion } @@ -430,9 +439,10 @@ func (b *BeaconBlock) MarshalSSZ() ([]byte, error) { case version.Altair: return pb.(*eth.BeaconBlockAltair).MarshalSSZ() case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZ() + } return pb.(*eth.BeaconBlockBellatrix).MarshalSSZ() - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZ() default: return []byte{}, errIncorrectBlockVersion } @@ -451,9 +461,10 @@ func (b *BeaconBlock) MarshalSSZTo(dst []byte) ([]byte, error) { case version.Altair: return pb.(*eth.BeaconBlockAltair).MarshalSSZTo(dst) case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZTo(dst) + } return pb.(*eth.BeaconBlockBellatrix).MarshalSSZTo(dst) - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBellatrix).MarshalSSZTo(dst) default: return []byte{}, errIncorrectBlockVersion } @@ -476,9 +487,10 @@ func (b *BeaconBlock) SizeSSZ() int { case version.Altair: return pb.(*eth.BeaconBlockAltair).SizeSSZ() case version.Bellatrix: + if b.IsBlinded() { + return pb.(*eth.BlindedBeaconBlockBellatrix).SizeSSZ() + } return pb.(*eth.BeaconBlockBellatrix).SizeSSZ() - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBellatrix).SizeSSZ() default: panic(incorrectBodyVersion) } @@ -509,24 +521,26 @@ func (b *BeaconBlock) UnmarshalSSZ(buf []byte) error { return err } case version.Bellatrix: - pb := ð.BeaconBlockBellatrix{} - if err := pb.UnmarshalSSZ(buf); err != nil { - return err - } - var err error - newBlock, err = initBlockFromProtoBellatrix(pb) - if err != nil { - return err - } - case version.BellatrixBlind: - pb := ð.BlindedBeaconBlockBellatrix{} - if err := pb.UnmarshalSSZ(buf); err != nil { - return err - } - var err error - newBlock, err = initBlindedBlockFromProtoBellatrix(pb) - if err != nil { - return err + if b.IsBlinded() { + pb := ð.BlindedBeaconBlockBellatrix{} + if err := pb.UnmarshalSSZ(buf); err != nil { + return err + } + var err error + newBlock, err = initBlindedBlockFromProtoBellatrix(pb) + if err != nil { + return err + } + } else { + pb := ð.BeaconBlockBellatrix{} + if err := pb.UnmarshalSSZ(buf); err != nil { + return err + } + var err error + newBlock, err = initBlockFromProtoBellatrix(pb) + if err != nil { + return err + } } default: return errIncorrectBlockVersion @@ -547,9 +561,10 @@ func (b *BeaconBlock) AsSignRequestObject() (validatorpb.SignRequestObject, erro case version.Altair: return &validatorpb.SignRequest_BlockV2{BlockV2: pb.(*eth.BeaconBlockAltair)}, nil case version.Bellatrix: + if b.IsBlinded() { + return &validatorpb.SignRequest_BlindedBlockV3{BlindedBlockV3: pb.(*eth.BlindedBeaconBlockBellatrix)}, nil + } return &validatorpb.SignRequest_BlockV3{BlockV3: pb.(*eth.BeaconBlockBellatrix)}, nil - case version.BellatrixBlind: - return &validatorpb.SignRequest_BlindedBlockV3{BlindedBlockV3: pb.(*eth.BlindedBeaconBlockBellatrix)}, nil default: return nil, errIncorrectBlockVersion } @@ -614,9 +629,10 @@ func (b *BeaconBlockBody) Execution() (interfaces.ExecutionData, error) { case version.Phase0, version.Altair: return nil, errNotSupported("Execution", b.version) case version.Bellatrix: + if b.isBlinded { + return WrappedExecutionPayloadHeader(b.executionPayloadHeader) + } return WrappedExecutionPayload(b.executionPayload) - case version.BellatrixBlind: - return WrappedExecutionPayloadHeader(b.executionPayloadHeader) default: return nil, errIncorrectBlockVersion } @@ -634,9 +650,10 @@ func (b *BeaconBlockBody) HashTreeRoot() ([32]byte, error) { case version.Altair: return pb.(*eth.BeaconBlockBodyAltair).HashTreeRoot() case version.Bellatrix: + if b.isBlinded { + return pb.(*eth.BlindedBeaconBlockBodyBellatrix).HashTreeRoot() + } return pb.(*eth.BeaconBlockBodyBellatrix).HashTreeRoot() - case version.BellatrixBlind: - return pb.(*eth.BlindedBeaconBlockBodyBellatrix).HashTreeRoot() default: return [32]byte{}, errIncorrectBodyVersion } diff --git a/consensus-types/blocks/getters_test.go b/consensus-types/blocks/getters_test.go index ae4a2c9deb..21f326c810 100644 --- a/consensus-types/blocks/getters_test.go +++ b/consensus-types/blocks/getters_test.go @@ -178,11 +178,8 @@ func Test_BeaconBlock_IsNil(t *testing.T) { } func Test_BeaconBlock_IsBlinded(t *testing.T) { - assert.Equal(t, false, (&BeaconBlock{version: version.Phase0}).IsBlinded()) - assert.Equal(t, false, (&BeaconBlock{version: version.Altair}).IsBlinded()) - assert.Equal(t, false, (&BeaconBlock{version: version.Bellatrix}).IsBlinded()) - assert.Equal(t, true, (&BeaconBlock{version: version.BellatrixBlind}).IsBlinded()) - assert.Equal(t, false, (&BeaconBlock{version: 128}).IsBlinded()) + assert.Equal(t, false, (&BeaconBlock{body: &BeaconBlockBody{isBlinded: false}}).IsBlinded()) + assert.Equal(t, true, (&BeaconBlock{body: &BeaconBlockBody{isBlinded: true}}).IsBlinded()) } func Test_BeaconBlock_Version(t *testing.T) { diff --git a/consensus-types/blocks/proto.go b/consensus-types/blocks/proto.go index 03221a4966..1958f2779a 100644 --- a/consensus-types/blocks/proto.go +++ b/consensus-types/blocks/proto.go @@ -46,6 +46,20 @@ func (b *SignedBeaconBlock) Proto() (proto.Message, error) { Signature: b.signature, }, nil case version.Bellatrix: + if b.IsBlinded() { + var block *eth.BlindedBeaconBlockBellatrix + if blockMessage != nil { + var ok bool + block, ok = blockMessage.(*eth.BlindedBeaconBlockBellatrix) + if !ok { + return nil, errors.Wrap(err, incorrectBlockVersion) + } + } + return ð.SignedBlindedBeaconBlockBellatrix{ + Block: block, + Signature: b.signature, + }, nil + } var block *eth.BeaconBlockBellatrix if blockMessage != nil { var ok bool @@ -58,19 +72,6 @@ func (b *SignedBeaconBlock) Proto() (proto.Message, error) { Block: block, Signature: b.signature, }, nil - case version.BellatrixBlind: - var block *eth.BlindedBeaconBlockBellatrix - if blockMessage != nil { - var ok bool - block, ok = blockMessage.(*eth.BlindedBeaconBlockBellatrix) - if !ok { - return nil, errors.Wrap(err, incorrectBlockVersion) - } - } - return ð.SignedBlindedBeaconBlockBellatrix{ - Block: block, - Signature: b.signature, - }, nil default: return nil, errors.New("unsupported signed beacon block version") } @@ -121,6 +122,23 @@ func (b *BeaconBlock) Proto() (proto.Message, error) { Body: body, }, nil case version.Bellatrix: + if b.IsBlinded() { + var body *eth.BlindedBeaconBlockBodyBellatrix + if bodyMessage != nil { + var ok bool + body, ok = bodyMessage.(*eth.BlindedBeaconBlockBodyBellatrix) + if !ok { + return nil, errors.Wrap(err, incorrectBodyVersion) + } + } + return ð.BlindedBeaconBlockBellatrix{ + Slot: b.slot, + ProposerIndex: b.proposerIndex, + ParentRoot: b.parentRoot, + StateRoot: b.stateRoot, + Body: body, + }, nil + } var body *eth.BeaconBlockBodyBellatrix if bodyMessage != nil { var ok bool @@ -136,22 +154,6 @@ func (b *BeaconBlock) Proto() (proto.Message, error) { StateRoot: b.stateRoot, Body: body, }, nil - case version.BellatrixBlind: - var body *eth.BlindedBeaconBlockBodyBellatrix - if bodyMessage != nil { - var ok bool - body, ok = bodyMessage.(*eth.BlindedBeaconBlockBodyBellatrix) - if !ok { - return nil, errors.Wrap(err, incorrectBodyVersion) - } - } - return ð.BlindedBeaconBlockBellatrix{ - Slot: b.slot, - ProposerIndex: b.proposerIndex, - ParentRoot: b.parentRoot, - StateRoot: b.stateRoot, - Body: body, - }, nil default: return nil, errors.New("unsupported beacon block version") } @@ -188,6 +190,20 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) { SyncAggregate: b.syncAggregate, }, nil case version.Bellatrix: + if b.isBlinded { + return ð.BlindedBeaconBlockBodyBellatrix{ + 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: b.executionPayloadHeader, + }, nil + } return ð.BeaconBlockBodyBellatrix{ RandaoReveal: b.randaoReveal, Eth1Data: b.eth1Data, @@ -200,19 +216,6 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) { SyncAggregate: b.syncAggregate, ExecutionPayload: b.executionPayload, }, nil - case version.BellatrixBlind: - return ð.BlindedBeaconBlockBodyBellatrix{ - 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: b.executionPayloadHeader, - }, nil default: return nil, errors.New("unsupported beacon block body version") } @@ -279,7 +282,7 @@ func initBlindedSignedBlockFromProtoBellatrix(pb *eth.SignedBlindedBeaconBlockBe return nil, err } b := &SignedBeaconBlock{ - version: version.BellatrixBlind, + version: version.Bellatrix, block: block, signature: pb.Signature, } @@ -356,7 +359,7 @@ func initBlindedBlockFromProtoBellatrix(pb *eth.BlindedBeaconBlockBellatrix) (*B return nil, err } b := &BeaconBlock{ - version: version.BellatrixBlind, + version: version.Bellatrix, slot: pb.Slot, proposerIndex: pb.ProposerIndex, parentRoot: pb.ParentRoot, @@ -373,6 +376,7 @@ func initBlockBodyFromProtoPhase0(pb *eth.BeaconBlockBody) (*BeaconBlockBody, er b := &BeaconBlockBody{ version: version.Phase0, + isBlinded: false, randaoReveal: pb.RandaoReveal, eth1Data: pb.Eth1Data, graffiti: pb.Graffiti, @@ -392,6 +396,7 @@ func initBlockBodyFromProtoAltair(pb *eth.BeaconBlockBodyAltair) (*BeaconBlockBo b := &BeaconBlockBody{ version: version.Altair, + isBlinded: false, randaoReveal: pb.RandaoReveal, eth1Data: pb.Eth1Data, graffiti: pb.Graffiti, @@ -412,6 +417,7 @@ func initBlockBodyFromProtoBellatrix(pb *eth.BeaconBlockBodyBellatrix) (*BeaconB b := &BeaconBlockBody{ version: version.Bellatrix, + isBlinded: false, randaoReveal: pb.RandaoReveal, eth1Data: pb.Eth1Data, graffiti: pb.Graffiti, @@ -432,7 +438,8 @@ func initBlindedBlockBodyFromProtoBellatrix(pb *eth.BlindedBeaconBlockBodyBellat } b := &BeaconBlockBody{ - version: version.BellatrixBlind, + version: version.Bellatrix, + isBlinded: true, randaoReveal: pb.RandaoReveal, eth1Data: pb.Eth1Data, graffiti: pb.Graffiti, diff --git a/consensus-types/blocks/proto_test.go b/consensus-types/blocks/proto_test.go index e34fab1eef..aea51fde98 100644 --- a/consensus-types/blocks/proto_test.go +++ b/consensus-types/blocks/proto_test.go @@ -144,9 +144,9 @@ func Test_SignedBeaconBlock_Proto(t *testing.T) { Signature: f.b96, } block := &SignedBeaconBlock{ - version: version.BellatrixBlind, + version: version.Bellatrix, block: &BeaconBlock{ - version: version.BellatrixBlind, + version: version.Bellatrix, slot: 128, proposerIndex: 128, parentRoot: f.b32, @@ -261,7 +261,7 @@ func Test_BeaconBlock_Proto(t *testing.T) { Body: bodyPbBlindedBellatrix(), } block := &BeaconBlock{ - version: version.BellatrixBlind, + version: version.Bellatrix, slot: 128, proposerIndex: 128, parentRoot: f.b32, @@ -681,7 +681,8 @@ func bodyBellatrix() *BeaconBlockBody { func bodyBlindedBellatrix() *BeaconBlockBody { f := getFields() return &BeaconBlockBody{ - version: version.BellatrixBlind, + version: version.Bellatrix, + isBlinded: true, randaoReveal: f.b96, eth1Data: ð.Eth1Data{ DepositRoot: f.b32, diff --git a/consensus-types/blocks/types.go b/consensus-types/blocks/types.go index 45e849f719..06c96da366 100644 --- a/consensus-types/blocks/types.go +++ b/consensus-types/blocks/types.go @@ -38,6 +38,7 @@ var ( // BeaconBlockBody is the main beacon block body structure. It can represent any block type. type BeaconBlockBody struct { version int + isBlinded bool randaoReveal []byte eth1Data *eth.Eth1Data graffiti []byte diff --git a/consensus-types/interfaces/beacon_block.go b/consensus-types/interfaces/beacon_block.go index 1eddc15535..d0dbdc9c7d 100644 --- a/consensus-types/interfaces/beacon_block.go +++ b/consensus-types/interfaces/beacon_block.go @@ -25,6 +25,7 @@ type SignedBeaconBlock interface { ssz.Marshaler ssz.Unmarshaler Version() int + IsBlinded() bool Header() (*ethpb.SignedBeaconBlockHeader, error) } diff --git a/consensus-types/mock/block.go b/consensus-types/mock/block.go index 4cbd5a5ac0..862a373010 100644 --- a/consensus-types/mock/block.go +++ b/consensus-types/mock/block.go @@ -73,6 +73,10 @@ func (SignedBeaconBlock) Version() int { panic("implement me") } +func (SignedBeaconBlock) IsBlinded() bool { + return false +} + func (SignedBeaconBlock) ToBlinded() (interfaces.SignedBeaconBlock, error) { panic("implement me") } diff --git a/runtime/version/fork.go b/runtime/version/fork.go index 1d9f81e267..2ce11ff5fa 100644 --- a/runtime/version/fork.go +++ b/runtime/version/fork.go @@ -4,7 +4,6 @@ const ( Phase0 = iota Altair Bellatrix - BellatrixBlind ) func String(version int) string { @@ -15,8 +14,6 @@ func String(version int) string { return "altair" case Bellatrix: return "bellatrix" - case BellatrixBlind: - return "bellatrix-blind" default: return "unknown version" }