Use Single Beacon Block Wrapper Function Across Prysm (#10608)

* remove altair wrappers in favor of generic ones for blocks

* rem deprecated

* body wrapper

* builds

* nil check

beacon-chain/blockchain/log_test.go

@@ -25,57 +25,85 @@ func Test_logStateTransitionData(t *testing.T) {
 	require.NoError(t, err)
 	tests := []struct {
 		name string
-		b    interfaces.BeaconBlock
+		b    func() interfaces.BeaconBlock
 		want string
 	}{
 		{name: "empty block body",
-			b:    wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" prefix=blockchain slot=0",
 		},
 		{name: "has attestation",
-			b:    wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{Attestations: []*ethpb.Attestation{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
 		},
 		{name: "has deposit",
-			b: wrapper.WrappedPhase0BeaconBlock(
-				&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-					Attestations: []*ethpb.Attestation{{}},
-					Deposits:     []*ethpb.Deposit{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(
+					&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+						Attestations: []*ethpb.Attestation{{}},
+						Deposits:     []*ethpb.Deposit{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" attestations=1 deposits=1 prefix=blockchain slot=0",
 		},
 		{name: "has attester slashing",
-			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-				AttesterSlashings: []*ethpb.AttesterSlashing{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+					AttesterSlashings: []*ethpb.AttesterSlashing{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" attesterSlashings=1 prefix=blockchain slot=0",
 		},
 		{name: "has proposer slashing",
-			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-				ProposerSlashings: []*ethpb.ProposerSlashing{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+					ProposerSlashings: []*ethpb.ProposerSlashing{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" prefix=blockchain proposerSlashings=1 slot=0",
 		},
 		{name: "has exit",
-			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-				VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+					VoluntaryExits: []*ethpb.SignedVoluntaryExit{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" prefix=blockchain slot=0 voluntaryExits=1",
 		},
 		{name: "has everything",
-			b: wrapper.WrappedPhase0BeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
-				Attestations:      []*ethpb.Attestation{{}},
-				Deposits:          []*ethpb.Deposit{{}},
-				AttesterSlashings: []*ethpb.AttesterSlashing{{}},
-				ProposerSlashings: []*ethpb.ProposerSlashing{{}},
-				VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}}),
+			b: func() interfaces.BeaconBlock {
+				wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{
+					Attestations:      []*ethpb.Attestation{{}},
+					Deposits:          []*ethpb.Deposit{{}},
+					AttesterSlashings: []*ethpb.AttesterSlashing{{}},
+					ProposerSlashings: []*ethpb.ProposerSlashing{{}},
+					VoluntaryExits:    []*ethpb.SignedVoluntaryExit{{}}}})
+				require.NoError(t, err)
+				return wb
+			},
 			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 deposits=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
 		},
 		{name: "has payload",
-			b:    wrappedPayloadBlk,
+			b:    func() interfaces.BeaconBlock { return wrappedPayloadBlk },
 			want: "\"Finished applying state transition\" payloadHash=0x010203 prefix=blockchain slot=0 syncBitsCount=0 txCount=2",
 		},
 	}
 	for _, tt := range tests {
 		hook := logTest.NewGlobal()
 		t.Run(tt.name, func(t *testing.T) {
-			require.NoError(t, logStateTransitionData(tt.b))
+			require.NoError(t, logStateTransitionData(tt.b()))
 			require.LogsContain(t, hook, tt.want)
 		})
 	}

beacon-chain/blockchain/process_block_test.go

@@ -588,7 +588,9 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
 	b.Block.ParentRoot = gRoot[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
-	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block)))
+	wb, err := wrapper.WrappedBeaconBlock(b.Block)
+	require.NoError(t, err)
+	require.NoError(t, service.verifyBlkPreState(ctx, wb))
 }
 
 func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
@@ -623,7 +625,9 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
 	b.Block.ParentRoot = gRoot[:]
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
-	require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block)))
+	wb, err := wrapper.WrappedBeaconBlock(b.Block)
+	require.NoError(t, err)
+	require.NoError(t, service.verifyBlkPreState(ctx, wb))
 }
 
 func TestCachedPreState_CanGetFromDB(t *testing.T) {
@@ -653,7 +657,9 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1
 	service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
-	err = service.verifyBlkPreState(ctx, wrapper.WrappedPhase0BeaconBlock(b.Block))
+	wb, err := wrapper.WrappedBeaconBlock(b.Block)
+	require.NoError(t, err)
+	err = service.verifyBlkPreState(ctx, wb)
 	wanted := "could not reconstruct parent state"
 	assert.ErrorContains(t, wanted, err)
 

beacon-chain/core/blocks/payload_test.go

@@ -338,7 +338,7 @@ func Test_IsMergeTransitionBlockUsingPayloadHeader(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			got, err := blocks.IsMergeTransitionBlockUsingPreStatePayloadHeader(tt.header, body)
 			require.NoError(t, err)
@@ -374,7 +374,7 @@ func Test_IsExecutionBlock(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			wrappedBlock, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+			wrappedBlock, err := wrapper.WrappedBeaconBlock(blk.Block)
 			require.NoError(t, err)
 			got, err := blocks.IsExecutionBlock(wrappedBlock.Body())
 			require.NoError(t, err)
@@ -445,7 +445,7 @@ func Test_IsExecutionEnabled(t *testing.T) {
 			require.NoError(t, st.SetLatestExecutionPayloadHeader(tt.header))
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			if tt.useAltairSt {
 				st, _ = util.DeterministicGenesisStateAltair(t, 1)
@@ -511,7 +511,7 @@ func Test_IsExecutionEnabledUsingHeader(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			blk := util.NewBeaconBlockBellatrix()
 			blk.Block.Body.ExecutionPayload = tt.payload
-			body, err := wrapper.WrappedBellatrixBeaconBlockBody(blk.Block.Body)
+			body, err := wrapper.WrappedBeaconBlockBody(blk.Block.Body)
 			require.NoError(t, err)
 			got, err := blocks.IsExecutionEnabledUsingHeader(tt.header, body)
 			require.NoError(t, err)

beacon-chain/monitor/process_attestation_test.go

@@ -237,7 +237,7 @@ func TestProcessAttestations(t *testing.T) {
 		},
 	}
 
-	wrappedBlock, err := wrapper.WrappedAltairBeaconBlock(block)
+	wrappedBlock, err := wrapper.WrappedBeaconBlock(block)
 	require.NoError(t, err)
 	s.processAttestations(ctx, state, wrappedBlock)
 	wanted1 := "\"Attestation included\" BalanceChange=0 CorrectHead=true CorrectSource=true CorrectTarget=true Head=0x68656c6c6f2d InclusionSlot=2 NewBalance=32000000000 Slot=1 Source=0x68656c6c6f2d Target=0x68656c6c6f2d ValidatorIndex=2 prefix=monitor"

beacon-chain/monitor/process_block_test.go

@@ -124,7 +124,9 @@ func TestProcessSlashings(t *testing.T) {
 					2: true,
 				},
 			}
-			s.processSlashings(wrapper.WrappedPhase0BeaconBlock(tt.block))
+			wb, err := wrapper.WrappedBeaconBlock(tt.block)
+			require.NoError(t, err)
+			s.processSlashings(wb)
 			if tt.wantedErr != "" {
 				require.LogsContain(t, hook, tt.wantedErr)
 			} else {
@@ -168,7 +170,9 @@ func TestProcessProposedBlock(t *testing.T) {
 			beaconState, _ := util.DeterministicGenesisState(t, 256)
 			root := [32]byte{}
 			copy(root[:], "hello-world")
-			s.processProposedBlock(beaconState, root, wrapper.WrappedPhase0BeaconBlock(tt.block))
+			wb, err := wrapper.WrappedBeaconBlock(tt.block)
+			require.NoError(t, err)
+			s.processProposedBlock(beaconState, root, wb)
 			if tt.wantedErr != "" {
 				require.LogsContain(t, hook, tt.wantedErr)
 			} else {

beacon-chain/monitor/process_exit_test.go

@@ -40,7 +40,9 @@ func TestProcessExitsFromBlockTrackedIndices(t *testing.T) {
 		},
 	}
 
-	s.processExitsFromBlock(wrapper.WrappedPhase0BeaconBlock(block))
+	wb, err := wrapper.WrappedBeaconBlock(block)
+	require.NoError(t, err)
+	s.processExitsFromBlock(wb)
 	require.LogsContain(t, hook, "\"Voluntary exit was included\" Slot=0 ValidatorIndex=2")
 }
 
@@ -74,7 +76,9 @@ func TestProcessExitsFromBlockUntrackedIndices(t *testing.T) {
 		},
 	}
 
-	s.processExitsFromBlock(wrapper.WrappedPhase0BeaconBlock(block))
+	wb, err := wrapper.WrappedBeaconBlock(block)
+	require.NoError(t, err)
+	s.processExitsFromBlock(wb)
 	require.LogsDoNotContain(t, hook, "\"Voluntary exit was included\"")
 }
 

beacon-chain/monitor/process_sync_committee_test.go

@@ -49,7 +49,7 @@ func TestProcessSyncAggregate(t *testing.T) {
 		},
 	}
 
-	wrappedBlock, err := wrapper.WrappedAltairBeaconBlock(block)
+	wrappedBlock, err := wrapper.WrappedBeaconBlock(block)
 	require.NoError(t, err)
 
 	s.processSyncAggregate(beaconState, wrappedBlock)

consensus-types/interfaces/utils_test.go

@@ -81,7 +81,9 @@ func TestBeaconBlockHeaderFromBlockInterface(t *testing.T) {
 		BodyRoot:      bodyRoot[:],
 	}
 
-	bh, err := interfaces.BeaconBlockHeaderFromBlockInterface(wrapper.WrappedPhase0BeaconBlock(blk))
+	wb, err := wrapper.WrappedBeaconBlock(blk)
+	require.NoError(t, err)
+	bh, err := interfaces.BeaconBlockHeaderFromBlockInterface(wb)
 	require.NoError(t, err)
 	assert.DeepEqual(t, want, bh)
 }

consensus-types/wrapper/beacon_block.go

@@ -17,6 +17,9 @@ var (
 	// ErrUnsupportedBeaconBlock is returned when the struct type is not a supported beacon block
 	// type.
 	ErrUnsupportedBeaconBlock = errors.New("unsupported beacon block")
+	// ErrUnsupportedBeaconBlockBody is returned when the struct type is not a supported beacon block body
+	// type.
+	ErrUnsupportedBeaconBlockBody = errors.New("unsupported beacon block body")
 	// ErrUnsupportedPhase0Block is returned when accessing a phase0 block from a non-phase0 wrapped
 	// block.
 	ErrUnsupportedPhase0Block = errors.New("unsupported phase0 block")
@@ -59,31 +62,52 @@ func WrappedSignedBeaconBlock(i interface{}) (interfaces.SignedBeaconBlock, erro
 	}
 }
 
-// WrappedBeaconBlock will wrap a signed beacon block to conform to the
-// signed beacon block interface.
+// WrappedBeaconBlock will wrap a beacon block to conform to the
+// beacon block interface.
 func WrappedBeaconBlock(i interface{}) (interfaces.BeaconBlock, error) {
 	switch b := i.(type) {
 	case *eth.GenericBeaconBlock_Phase0:
-		return WrappedPhase0BeaconBlock(b.Phase0), nil
+		return wrappedPhase0BeaconBlock(b.Phase0), nil
 	case *eth.BeaconBlock:
-		return WrappedPhase0BeaconBlock(b), nil
+		return wrappedPhase0BeaconBlock(b), nil
 	case *eth.GenericBeaconBlock_Altair:
-		return WrappedAltairBeaconBlock(b.Altair)
+		return wrappedAltairBeaconBlock(b.Altair)
 	case *eth.BeaconBlockAltair:
-		return WrappedAltairBeaconBlock(b)
+		return wrappedAltairBeaconBlock(b)
 	case *eth.GenericBeaconBlock_Bellatrix:
-		return WrappedBellatrixBeaconBlock(b.Bellatrix)
+		return wrappedBellatrixBeaconBlock(b.Bellatrix)
 	case *eth.BeaconBlockBellatrix:
-		return WrappedBellatrixBeaconBlock(b)
+		return wrappedBellatrixBeaconBlock(b)
 	case *eth.GenericBeaconBlock_BlindedBellatrix:
-		return WrappedBellatrixBlindedBeaconBlock(b.BlindedBellatrix)
+		return wrappedBellatrixBlindedBeaconBlock(b.BlindedBellatrix)
 	case *eth.BlindedBeaconBlockBellatrix:
-		return WrappedBellatrixBlindedBeaconBlock(b)
+		return wrappedBellatrixBlindedBeaconBlock(b)
+	case nil:
+		return nil, ErrNilObjectWrapped
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedBeaconBlock, "unable to wrap block of type %T", i)
 	}
 }
 
+// WrappedBeaconBlockBody will wrap a beacon block body to conform to the
+// beacon block interface.
+func WrappedBeaconBlockBody(i interface{}) (interfaces.BeaconBlockBody, error) {
+	switch b := i.(type) {
+	case *eth.BeaconBlockBody:
+		return wrappedPhase0BeaconBlockBody(b), nil
+	case *eth.BeaconBlockBodyAltair:
+		return wrappedAltairBeaconBlockBody(b)
+	case *eth.BeaconBlockBodyBellatrix:
+		return wrappedBellatrixBeaconBlockBody(b)
+	case *eth.BlindedBeaconBlockBodyBellatrix:
+		return wrappedBellatrixBlindedBeaconBlockBody(b)
+	case nil:
+		return nil, ErrNilObjectWrapped
+	default:
+		return nil, errors.Wrapf(ErrUnsupportedBeaconBlockBody, "unable to wrap block body of type %T", i)
+	}
+}
+
 // BuildSignedBeaconBlock assembles a block.SignedBeaconBlock interface compatible struct from a
 // given beacon block an the appropriate signature. This method may be used to easily create a
 // signed beacon block.

consensus-types/wrapper/beacon_block_altair.go

@@ -141,11 +141,9 @@ type altairBeaconBlock struct {
 	b *eth.BeaconBlockAltair
 }
 
-// WrappedAltairBeaconBlock is constructor which wraps a protobuf altair object
+// wrappedAltairBeaconBlock is constructor which wraps a protobuf altair object
 // with the block wrapper.
-//
-// Deprecated: Use WrappedBeaconBlock.
-func WrappedAltairBeaconBlock(b *eth.BeaconBlockAltair) (interfaces.BeaconBlock, error) {
+func wrappedAltairBeaconBlock(b *eth.BeaconBlockAltair) (interfaces.BeaconBlock, error) {
 	w := altairBeaconBlock{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped
@@ -244,9 +242,9 @@ type altairBeaconBlockBody struct {
 	b *eth.BeaconBlockBodyAltair
 }
 
-// WrappedAltairBeaconBlockBody is constructor which wraps a protobuf altair object
+// wrappedAltairBeaconBlockBody is constructor which wraps a protobuf altair object
 // with the block wrapper.
-func WrappedAltairBeaconBlockBody(b *eth.BeaconBlockBodyAltair) (interfaces.BeaconBlockBody, error) {
+func wrappedAltairBeaconBlockBody(b *eth.BeaconBlockBodyAltair) (interfaces.BeaconBlockBody, error) {
 	w := altairBeaconBlockBody{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped

consensus-types/wrapper/beacon_block_altair_test.go

@@ -111,7 +111,7 @@ func TestAltairSignedBeaconBlock_Version(t *testing.T) {
 
 func TestAltairBeaconBlock_Slot(t *testing.T) {
 	slot := types.Slot(546)
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{Slot: slot})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{Slot: slot})
 	require.NoError(t, err)
 
 	assert.Equal(t, slot, wb.Slot())
@@ -119,7 +119,7 @@ func TestAltairBeaconBlock_Slot(t *testing.T) {
 
 func TestAltairBeaconBlock_ProposerIndex(t *testing.T) {
 	pi := types.ValidatorIndex(555)
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{ProposerIndex: pi})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{ProposerIndex: pi})
 	require.NoError(t, err)
 
 	assert.Equal(t, pi, wb.ProposerIndex())
@@ -127,7 +127,7 @@ func TestAltairBeaconBlock_ProposerIndex(t *testing.T) {
 
 func TestAltairBeaconBlock_ParentRoot(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{ParentRoot: root})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{ParentRoot: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wb.ParentRoot())
@@ -135,7 +135,7 @@ func TestAltairBeaconBlock_ParentRoot(t *testing.T) {
 
 func TestAltairBeaconBlock_StateRoot(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{StateRoot: root})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{StateRoot: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wb.StateRoot())
@@ -143,17 +143,17 @@ func TestAltairBeaconBlock_StateRoot(t *testing.T) {
 
 func TestAltairBeaconBlock_Body(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyAltair{Graffiti: []byte{0x44}}
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{Body: body})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{Body: body})
 	require.NoError(t, err)
 
 	assert.Equal(t, body, wb.Body().Proto())
 }
 
 func TestAltairBeaconBlock_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedAltairBeaconBlock(nil)
+	_, err := wrapper.WrappedBeaconBlock(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{})
 	require.NoError(t, err)
 
 	assert.Equal(t, false, wb.IsNil())
@@ -166,7 +166,7 @@ func TestAltairBeaconBlock_IsBlinded(t *testing.T) {
 }
 
 func TestAltairBeaconBlock_HashTreeRoot(t *testing.T) {
-	wb, err := wrapper.WrappedAltairBeaconBlock(util.HydrateBeaconBlockAltair(&ethpb.BeaconBlockAltair{}))
+	wb, err := wrapper.WrappedBeaconBlock(util.HydrateBeaconBlockAltair(&ethpb.BeaconBlockAltair{}))
 	require.NoError(t, err)
 
 	rt, err := wb.HashTreeRoot()
@@ -176,14 +176,14 @@ func TestAltairBeaconBlock_HashTreeRoot(t *testing.T) {
 
 func TestAltairBeaconBlock_Proto(t *testing.T) {
 	blk := &ethpb.BeaconBlockAltair{ProposerIndex: 234}
-	wb, err := wrapper.WrappedAltairBeaconBlock(blk)
+	wb, err := wrapper.WrappedBeaconBlock(blk)
 	require.NoError(t, err)
 
 	assert.Equal(t, blk, wb.Proto())
 }
 
 func TestAltairBeaconBlock_SSZ(t *testing.T) {
-	wb, err := wrapper.WrappedAltairBeaconBlock(util.HydrateBeaconBlockAltair(&ethpb.BeaconBlockAltair{}))
+	wb, err := wrapper.WrappedBeaconBlock(util.HydrateBeaconBlockAltair(&ethpb.BeaconBlockAltair{}))
 	assert.NoError(t, err)
 
 	b, err := wb.MarshalSSZ()
@@ -196,7 +196,7 @@ func TestAltairBeaconBlock_SSZ(t *testing.T) {
 }
 
 func TestAltairBeaconBlock_Version(t *testing.T) {
-	wb, err := wrapper.WrappedAltairBeaconBlock(&ethpb.BeaconBlockAltair{})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockAltair{})
 	require.NoError(t, err)
 
 	assert.Equal(t, version.Altair, wb.Version())
@@ -204,7 +204,7 @@ func TestAltairBeaconBlock_Version(t *testing.T) {
 
 func TestAltairBeaconBlockBody_RandaoReveal(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(&ethpb.BeaconBlockBodyAltair{RandaoReveal: root})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BeaconBlockBodyAltair{RandaoReveal: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wbb.RandaoReveal())
@@ -215,7 +215,7 @@ func TestAltairBeaconBlockBody_Eth1Data(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyAltair{
 		Eth1Data: data,
 	}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 	assert.Equal(t, data, wbb.Eth1Data())
 }
@@ -223,7 +223,7 @@ func TestAltairBeaconBlockBody_Eth1Data(t *testing.T) {
 func TestAltairBeaconBlockBody_Graffiti(t *testing.T) {
 	graffiti := []byte{0x66, 0xAA}
 	body := &ethpb.BeaconBlockBodyAltair{Graffiti: graffiti}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, graffiti, wbb.Graffiti())
@@ -236,7 +236,7 @@ func TestAltairBeaconBlockBody_ProposerSlashings(t *testing.T) {
 		}},
 	}
 	body := &ethpb.BeaconBlockBodyAltair{ProposerSlashings: ps}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, ps, wbb.ProposerSlashings())
@@ -247,7 +247,7 @@ func TestAltairBeaconBlockBody_AttesterSlashings(t *testing.T) {
 		{Attestation_1: &ethpb.IndexedAttestation{Signature: []byte{0x11}}},
 	}
 	body := &ethpb.BeaconBlockBodyAltair{AttesterSlashings: as}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, as, wbb.AttesterSlashings())
@@ -257,7 +257,7 @@ func TestAltairBeaconBlockBody_Attestations(t *testing.T) {
 	atts := []*ethpb.Attestation{{Signature: []byte{0x88}}}
 
 	body := &ethpb.BeaconBlockBodyAltair{Attestations: atts}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, atts, wbb.Attestations())
@@ -268,7 +268,7 @@ func TestAltairBeaconBlockBody_Deposits(t *testing.T) {
 		{Proof: [][]byte{{0x54, 0x10}}},
 	}
 	body := &ethpb.BeaconBlockBodyAltair{Deposits: deposits}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, deposits, wbb.Deposits())
@@ -279,24 +279,24 @@ func TestAltairBeaconBlockBody_VoluntaryExits(t *testing.T) {
 		{Exit: &ethpb.VoluntaryExit{Epoch: 54}},
 	}
 	body := &ethpb.BeaconBlockBodyAltair{VoluntaryExits: exits}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, exits, wbb.VoluntaryExits())
 }
 
 func TestAltairBeaconBlockBody_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedAltairBeaconBlockBody(nil)
+	_, err := wrapper.WrappedBeaconBlockBody(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(&ethpb.BeaconBlockBodyAltair{})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BeaconBlockBodyAltair{})
 	require.NoError(t, err)
 	assert.Equal(t, false, wbb.IsNil())
 
 }
 
 func TestAltairBeaconBlockBody_HashTreeRoot(t *testing.T) {
-	wb, err := wrapper.WrappedAltairBeaconBlockBody(util.HydrateBeaconBlockBodyAltair(&ethpb.BeaconBlockBodyAltair{}))
+	wb, err := wrapper.WrappedBeaconBlockBody(util.HydrateBeaconBlockBodyAltair(&ethpb.BeaconBlockBodyAltair{}))
 	assert.NoError(t, err)
 
 	rt, err := wb.HashTreeRoot()
@@ -306,7 +306,7 @@ func TestAltairBeaconBlockBody_HashTreeRoot(t *testing.T) {
 
 func TestAltairBeaconBlockBody_Proto(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyAltair{Graffiti: []byte{0x66, 0xAA}}
-	wbb, err := wrapper.WrappedAltairBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.Equal(t, body, wbb.Proto())

consensus-types/wrapper/beacon_block_bellatrix.go

@@ -136,11 +136,9 @@ type bellatrixBeaconBlock struct {
 	b *eth.BeaconBlockBellatrix
 }
 
-// WrappedBellatrixBeaconBlock is a constructor which wraps a protobuf Bellatrix object
+// wrappedBellatrixBeaconBlock is a constructor which wraps a protobuf Bellatrix object
 // with the block wrapper.
-//
-// Deprecated: Use WrappedBeaconBlock.
-func WrappedBellatrixBeaconBlock(b *eth.BeaconBlockBellatrix) (interfaces.BeaconBlock, error) {
+func wrappedBellatrixBeaconBlock(b *eth.BeaconBlockBellatrix) (interfaces.BeaconBlock, error) {
 	w := bellatrixBeaconBlock{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped
@@ -239,9 +237,9 @@ type bellatrixBeaconBlockBody struct {
 	b *eth.BeaconBlockBodyBellatrix
 }
 
-// WrappedBellatrixBeaconBlockBody is a constructor which wraps a protobuf bellatrix object
+// wrappedBellatrixBeaconBlockBody is a constructor which wraps a protobuf bellatrix object
 // with the block wrapper.
-func WrappedBellatrixBeaconBlockBody(b *eth.BeaconBlockBodyBellatrix) (interfaces.BeaconBlockBody, error) {
+func wrappedBellatrixBeaconBlockBody(b *eth.BeaconBlockBodyBellatrix) (interfaces.BeaconBlockBody, error) {
 	w := bellatrixBeaconBlockBody{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped

consensus-types/wrapper/beacon_block_bellatrix_test.go

@@ -143,7 +143,7 @@ func TestBellatrixSignedBeaconBlock_Version(t *testing.T) {
 
 func TestBellatrixBeaconBlock_Slot(t *testing.T) {
 	slot := types.Slot(546)
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{Slot: slot})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{Slot: slot})
 	require.NoError(t, err)
 
 	assert.Equal(t, slot, wb.Slot())
@@ -151,7 +151,7 @@ func TestBellatrixBeaconBlock_Slot(t *testing.T) {
 
 func TestBellatrixBeaconBlock_ProposerIndex(t *testing.T) {
 	pi := types.ValidatorIndex(555)
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{ProposerIndex: pi})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{ProposerIndex: pi})
 	require.NoError(t, err)
 
 	assert.Equal(t, pi, wb.ProposerIndex())
@@ -159,7 +159,7 @@ func TestBellatrixBeaconBlock_ProposerIndex(t *testing.T) {
 
 func TestBellatrixBeaconBlock_ParentRoot(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{ParentRoot: root})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{ParentRoot: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wb.ParentRoot())
@@ -167,7 +167,7 @@ func TestBellatrixBeaconBlock_ParentRoot(t *testing.T) {
 
 func TestBellatrixBeaconBlock_StateRoot(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{StateRoot: root})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{StateRoot: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wb.StateRoot())
@@ -175,17 +175,17 @@ func TestBellatrixBeaconBlock_StateRoot(t *testing.T) {
 
 func TestBellatrixBeaconBlock_Body(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyBellatrix{Graffiti: []byte{0x44}}
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{Body: body})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{Body: body})
 	require.NoError(t, err)
 
 	assert.Equal(t, body, wb.Body().Proto())
 }
 
 func TestBellatrixBeaconBlock_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedBellatrixBeaconBlock(nil)
+	_, err := wrapper.WrappedBeaconBlock(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{})
 	require.NoError(t, err)
 
 	assert.Equal(t, false, wb.IsNil())
@@ -198,7 +198,7 @@ func TesTBellatrixBeaconBlock_IsBlinded(t *testing.T) {
 }
 
 func TestBellatrixBeaconBlock_HashTreeRoot(t *testing.T) {
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(util.HydrateBeaconBlockBellatrix(&ethpb.BeaconBlockBellatrix{}))
+	wb, err := wrapper.WrappedBeaconBlock(util.HydrateBeaconBlockBellatrix(&ethpb.BeaconBlockBellatrix{}))
 	require.NoError(t, err)
 
 	rt, err := wb.HashTreeRoot()
@@ -208,14 +208,14 @@ func TestBellatrixBeaconBlock_HashTreeRoot(t *testing.T) {
 
 func TestBellatrixBeaconBlock_Proto(t *testing.T) {
 	blk := &ethpb.BeaconBlockBellatrix{ProposerIndex: 234}
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(blk)
+	wb, err := wrapper.WrappedBeaconBlock(blk)
 	require.NoError(t, err)
 
 	assert.Equal(t, blk, wb.Proto())
 }
 
 func TestBellatrixBeaconBlock_SSZ(t *testing.T) {
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(util.HydrateBeaconBlockBellatrix(&ethpb.BeaconBlockBellatrix{}))
+	wb, err := wrapper.WrappedBeaconBlock(util.HydrateBeaconBlockBellatrix(&ethpb.BeaconBlockBellatrix{}))
 	assert.NoError(t, err)
 
 	b, err := wb.MarshalSSZ()
@@ -228,7 +228,7 @@ func TestBellatrixBeaconBlock_SSZ(t *testing.T) {
 }
 
 func TestBellatrixBeaconBlock_Version(t *testing.T) {
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(&ethpb.BeaconBlockBellatrix{})
+	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BeaconBlockBellatrix{})
 	require.NoError(t, err)
 
 	assert.Equal(t, version.Bellatrix, wb.Version())
@@ -236,7 +236,7 @@ func TestBellatrixBeaconBlock_Version(t *testing.T) {
 
 func TestBellatrixBeaconBlockBody_RandaoReveal(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{RandaoReveal: root})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{RandaoReveal: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wbb.RandaoReveal())
@@ -247,7 +247,7 @@ func TestBellatrixBeaconBlockBody_Eth1Data(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyBellatrix{
 		Eth1Data: data,
 	}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 	assert.Equal(t, data, wbb.Eth1Data())
 }
@@ -255,7 +255,7 @@ func TestBellatrixBeaconBlockBody_Eth1Data(t *testing.T) {
 func TestBellatrixBeaconBlockBody_Graffiti(t *testing.T) {
 	graffiti := []byte{0x66, 0xAA}
 	body := &ethpb.BeaconBlockBodyBellatrix{Graffiti: graffiti}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, graffiti, wbb.Graffiti())
@@ -268,7 +268,7 @@ func TestBellatrixBeaconBlockBody_ProposerSlashings(t *testing.T) {
 		}},
 	}
 	body := &ethpb.BeaconBlockBodyBellatrix{ProposerSlashings: ps}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, ps, wbb.ProposerSlashings())
@@ -279,7 +279,7 @@ func TestBellatrixBeaconBlockBody_AttesterSlashings(t *testing.T) {
 		{Attestation_1: &ethpb.IndexedAttestation{Signature: []byte{0x11}}},
 	}
 	body := &ethpb.BeaconBlockBodyBellatrix{AttesterSlashings: as}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, as, wbb.AttesterSlashings())
@@ -289,7 +289,7 @@ func TestBellatrixBeaconBlockBody_Attestations(t *testing.T) {
 	atts := []*ethpb.Attestation{{Signature: []byte{0x88}}}
 
 	body := &ethpb.BeaconBlockBodyBellatrix{Attestations: atts}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, atts, wbb.Attestations())
@@ -300,7 +300,7 @@ func TestBellatrixBeaconBlockBody_Deposits(t *testing.T) {
 		{Proof: [][]byte{{0x54, 0x10}}},
 	}
 	body := &ethpb.BeaconBlockBodyBellatrix{Deposits: deposits}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, deposits, wbb.Deposits())
@@ -311,24 +311,24 @@ func TestBellatrixBeaconBlockBody_VoluntaryExits(t *testing.T) {
 		{Exit: &ethpb.VoluntaryExit{Epoch: 54}},
 	}
 	body := &ethpb.BeaconBlockBodyBellatrix{VoluntaryExits: exits}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, exits, wbb.VoluntaryExits())
 }
 
 func TestBellatrixBeaconBlockBody_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedBellatrixBeaconBlockBody(nil)
+	_, err := wrapper.WrappedBeaconBlockBody(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{})
 	require.NoError(t, err)
 	assert.Equal(t, false, wbb.IsNil())
 
 }
 
 func TestBellatrixBeaconBlockBody_HashTreeRoot(t *testing.T) {
-	wb, err := wrapper.WrappedBellatrixBeaconBlockBody(util.HydrateBeaconBlockBodyBellatrix(&ethpb.BeaconBlockBodyBellatrix{}))
+	wb, err := wrapper.WrappedBeaconBlockBody(util.HydrateBeaconBlockBodyBellatrix(&ethpb.BeaconBlockBodyBellatrix{}))
 	assert.NoError(t, err)
 
 	rt, err := wb.HashTreeRoot()
@@ -338,7 +338,7 @@ func TestBellatrixBeaconBlockBody_HashTreeRoot(t *testing.T) {
 
 func TestBellatrixBeaconBlockBody_Proto(t *testing.T) {
 	body := &ethpb.BeaconBlockBodyBellatrix{Graffiti: []byte{0x66, 0xAA}}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.Equal(t, body, wbb.Proto())
@@ -349,7 +349,7 @@ func TestBellatrixBeaconBlockBody_ExecutionPayload(t *testing.T) {
 		BlockNumber: 100,
 	}
 	body := &ethpb.BeaconBlockBodyBellatrix{ExecutionPayload: payloads}
-	wbb, err := wrapper.WrappedBellatrixBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	got, err := wbb.ExecutionPayload()

consensus-types/wrapper/beacon_block_phase0.go

@@ -38,7 +38,7 @@ func (w Phase0SignedBeaconBlock) Signature() []byte {
 
 // Block returns the underlying beacon block object.
 func (w Phase0SignedBeaconBlock) Block() interfaces.BeaconBlock {
-	return WrappedPhase0BeaconBlock(w.b.Block)
+	return wrappedPhase0BeaconBlock(w.b.Block)
 }
 
 // IsNil checks if the underlying beacon block is
@@ -137,11 +137,9 @@ type Phase0BeaconBlock struct {
 	b *eth.BeaconBlock
 }
 
-// WrappedPhase0BeaconBlock is constructor which wraps a protobuf phase 0 object
+// wrappedPhase0BeaconBlock is constructor which wraps a protobuf phase 0 object
 // with the block wrapper.
-//
-// Deprecated: Use WrappedBeaconBlock.
-func WrappedPhase0BeaconBlock(b *eth.BeaconBlock) interfaces.BeaconBlock {
+func wrappedPhase0BeaconBlock(b *eth.BeaconBlock) interfaces.BeaconBlock {
 	return Phase0BeaconBlock{b: b}
 }
 
@@ -167,7 +165,7 @@ func (w Phase0BeaconBlock) StateRoot() []byte {
 
 // Body returns the underlying block body.
 func (w Phase0BeaconBlock) Body() interfaces.BeaconBlockBody {
-	return WrappedPhase0BeaconBlockBody(w.b.Body)
+	return wrappedPhase0BeaconBlockBody(w.b.Body)
 }
 
 // IsNil checks if the beacon block is nil.
@@ -236,9 +234,9 @@ type Phase0BeaconBlockBody struct {
 	b *eth.BeaconBlockBody
 }
 
-// WrappedPhase0BeaconBlockBody is constructor which wraps a protobuf phase 0 object
+// wrappedPhase0BeaconBlockBody is constructor which wraps a protobuf phase 0 object
 // with the block wrapper.
-func WrappedPhase0BeaconBlockBody(b *eth.BeaconBlockBody) interfaces.BeaconBlockBody {
+func wrappedPhase0BeaconBlockBody(b *eth.BeaconBlockBody) interfaces.BeaconBlockBody {
 	return Phase0BeaconBlockBody{b: b}
 }
 

consensus-types/wrapper/blinded_beacon_block_bellatrix.go

@@ -137,11 +137,9 @@ type blindedBeaconBlockBellatrix struct {
 	b *eth.BlindedBeaconBlockBellatrix
 }
 
-// WrappedBellatrixBlindedBeaconBlock is a constructor which wraps a protobuf Bellatrix object
+// wrappedBellatrixBlindedBeaconBlock is a constructor which wraps a protobuf Bellatrix object
 // with the block wrapper.
-//
-// Deprecated: Use WrappedBeaconBlock.
-func WrappedBellatrixBlindedBeaconBlock(b *eth.BlindedBeaconBlockBellatrix) (interfaces.BeaconBlock, error) {
+func wrappedBellatrixBlindedBeaconBlock(b *eth.BlindedBeaconBlockBellatrix) (interfaces.BeaconBlock, error) {
 	w := blindedBeaconBlockBellatrix{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped
@@ -240,9 +238,9 @@ type blindedBeaconBlockBodyBellatrix struct {
 	b *eth.BlindedBeaconBlockBodyBellatrix
 }
 
-// WrappedBellatrixBlindedBeaconBlockBody is a constructor which wraps a protobuf bellatrix object
+// wrappedBellatrixBlindedBeaconBlockBody is a constructor which wraps a protobuf bellatrix object
 // with the block wrapper.
-func WrappedBellatrixBlindedBeaconBlockBody(b *eth.BlindedBeaconBlockBodyBellatrix) (interfaces.BeaconBlockBody, error) {
+func wrappedBellatrixBlindedBeaconBlockBody(b *eth.BlindedBeaconBlockBodyBellatrix) (interfaces.BeaconBlockBody, error) {
 	w := blindedBeaconBlockBodyBellatrix{b: b}
 	if w.IsNil() {
 		return nil, ErrNilObjectWrapped

consensus-types/wrapper/blinded_beacon_block_bellatrix_test.go

@@ -193,7 +193,7 @@ func TestBellatrixBlindedBeaconBlock_Body(t *testing.T) {
 }
 
 func TestBellatrixBlindedBeaconBlock_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(nil)
+	_, err := wrapper.WrappedBeaconBlockBody(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
 	wb, err := wrapper.WrappedBeaconBlock(&ethpb.BlindedBeaconBlockBellatrix{})
@@ -248,7 +248,7 @@ func TestBellatrixBlindedBeaconBlock_Version(t *testing.T) {
 
 func TestBellatrixBlindedBeaconBlockBody_RandaoReveal(t *testing.T) {
 	root := []byte{0xAA, 0xBF, 0x33, 0x01}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{RandaoReveal: root})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{RandaoReveal: root})
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, root, wbb.RandaoReveal())
@@ -259,7 +259,7 @@ func TestBellatrixBlindedBeaconBlockBody_Eth1Data(t *testing.T) {
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{
 		Eth1Data: data,
 	}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 	assert.Equal(t, data, wbb.Eth1Data())
 }
@@ -267,7 +267,7 @@ func TestBellatrixBlindedBeaconBlockBody_Eth1Data(t *testing.T) {
 func TestBellatrixBlindedBeaconBlockBody_Graffiti(t *testing.T) {
 	graffiti := []byte{0x66, 0xAA}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{Graffiti: graffiti}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, graffiti, wbb.Graffiti())
@@ -280,7 +280,7 @@ func TestBellatrixBlindedBeaconBlockBody_ProposerSlashings(t *testing.T) {
 		}},
 	}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{ProposerSlashings: ps}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, ps, wbb.ProposerSlashings())
@@ -291,7 +291,7 @@ func TestBellatrixBlindedBeaconBlockBody_AttesterSlashings(t *testing.T) {
 		{Attestation_1: &ethpb.IndexedAttestation{Signature: []byte{0x11}}},
 	}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{AttesterSlashings: as}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, as, wbb.AttesterSlashings())
@@ -301,7 +301,7 @@ func TestBellatrixBlindedBeaconBlockBody_Attestations(t *testing.T) {
 	atts := []*ethpb.Attestation{{Signature: []byte{0x88}}}
 
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{Attestations: atts}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, atts, wbb.Attestations())
@@ -312,7 +312,7 @@ func TestBellatrixBlindedBeaconBlockBody_Deposits(t *testing.T) {
 		{Proof: [][]byte{{0x54, 0x10}}},
 	}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{Deposits: deposits}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, deposits, wbb.Deposits())
@@ -323,24 +323,24 @@ func TestBellatrixBlindedBeaconBlockBody_VoluntaryExits(t *testing.T) {
 		{Exit: &ethpb.VoluntaryExit{Epoch: 54}},
 	}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{VoluntaryExits: exits}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, exits, wbb.VoluntaryExits())
 }
 
 func TestBellatrixBlindedBeaconBlockBody_IsNil(t *testing.T) {
-	_, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(nil)
+	_, err := wrapper.WrappedBeaconBlockBody(nil)
 	require.Equal(t, wrapper.ErrNilObjectWrapped, err)
 
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{})
+	wbb, err := wrapper.WrappedBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{})
 	require.NoError(t, err)
 	assert.Equal(t, false, wbb.IsNil())
 
 }
 
 func TestBellatrixBlindedBeaconBlockBody_HashTreeRoot(t *testing.T) {
-	wb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(util.HydrateBlindedBeaconBlockBodyBellatrix(&ethpb.BlindedBeaconBlockBodyBellatrix{}))
+	wb, err := wrapper.WrappedBeaconBlockBody(util.HydrateBlindedBeaconBlockBodyBellatrix(&ethpb.BlindedBeaconBlockBodyBellatrix{}))
 	assert.NoError(t, err)
 
 	rt, err := wb.HashTreeRoot()
@@ -350,7 +350,7 @@ func TestBellatrixBlindedBeaconBlockBody_HashTreeRoot(t *testing.T) {
 
 func TestBellatrixBlindedBeaconBlockBody_Proto(t *testing.T) {
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{Graffiti: []byte{0x66, 0xAA}}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	assert.Equal(t, body, wbb.Proto())
@@ -361,7 +361,7 @@ func TestBellatrixBlindedBeaconBlockBody_ExecutionPayloadHeader(t *testing.T) {
 		BlockNumber: 100,
 	}
 	body := &ethpb.BlindedBeaconBlockBodyBellatrix{ExecutionPayloadHeader: payloads}
-	wbb, err := wrapper.WrappedBellatrixBlindedBeaconBlockBody(body)
+	wbb, err := wrapper.WrappedBeaconBlockBody(body)
 	require.NoError(t, err)
 
 	_, err = wbb.ExecutionPayload()

tools/eth1voting/main.go

@@ -73,14 +73,18 @@ func main() {
 }
 
 func wrapBlock(b *v1alpha1.BeaconBlockContainer) interfaces.BeaconBlock {
-	if bb := b.GetAltairBlock(); bb != nil {
-		wb, err := wrapper.WrappedAltairBeaconBlock(bb.Block)
-		if err != nil {
-			panic(err)
-		}
-		return wb
-	} else if bb := b.GetPhase0Block(); bb != nil {
-		return wrapper.WrappedPhase0BeaconBlock(bb.Block)
+	var err error
+	var wb interfaces.SignedBeaconBlock
+	switch bb := b.Block.(type) {
+	case *v1alpha1.BeaconBlockContainer_Phase0Block:
+		wb, err = wrapper.WrappedSignedBeaconBlock(bb.Phase0Block)
+	case *v1alpha1.BeaconBlockContainer_AltairBlock:
+		wb, err = wrapper.WrappedSignedBeaconBlock(bb.AltairBlock)
+	case *v1alpha1.BeaconBlockContainer_BellatrixBlock:
+		wb, err = wrapper.WrappedSignedBeaconBlock(bb.BellatrixBlock)
 	}
-	panic("No block")
+	if err != nil {
+		panic("no block")
+	}
+	return wb.Block()
 }

validator/client/propose_test.go

@@ -802,7 +802,8 @@ func TestSignBlock(t *testing.T) {
 		},
 	}
 	validator.keyManager = km
-	b := wrapper.WrappedPhase0BeaconBlock(blk.Block)
+	b, err := wrapper.WrappedBeaconBlock(blk.Block)
+	require.NoError(t, err)
 	sig, blockRoot, err := validator.signBlock(ctx, pubKey, 0, 0, b)
 	require.NoError(t, err, "%x,%v", sig, err)
 	require.Equal(t, "a049e1dc723e5a8b5bd14f292973572dffd53785ddb337"+
@@ -842,7 +843,7 @@ func TestSignAltairBlock(t *testing.T) {
 		},
 	}
 	validator.keyManager = km
-	wb, err := wrapper.WrappedAltairBeaconBlock(blk.Block)
+	wb, err := wrapper.WrappedBeaconBlock(blk.Block)
 	require.NoError(t, err)
 	sig, blockRoot, err := validator.signBlock(ctx, pubKey, 0, 0, wb)
 	require.NoError(t, err, "%x,%v", sig, err)
@@ -878,7 +879,7 @@ func TestSignBellatrixBlock(t *testing.T) {
 		},
 	}
 	validator.keyManager = km
-	wb, err := wrapper.WrappedBellatrixBeaconBlock(blk.Block)
+	wb, err := wrapper.WrappedBeaconBlock(blk.Block)
 	require.NoError(t, err)
 	sig, blockRoot, err := validator.signBlock(ctx, pubKey, 0, 0, wb)
 	require.NoError(t, err, "%x,%v", sig, err)