diff --git a/beacon-chain/rpc/eth/beacon/blocks.go b/beacon-chain/rpc/eth/beacon/blocks.go index 4a9fa46514..84fb9e8a50 100644 --- a/beacon-chain/rpc/eth/beacon/blocks.go +++ b/beacon-chain/rpc/eth/beacon/blocks.go @@ -390,28 +390,29 @@ func (bs *Server) ListBlockAttestations(ctx context.Context, req *ethpbv1.BlockR ctx, span := trace.StartSpan(ctx, "beaconv1.ListBlockAttestations") defer span.End() - rBlk, err := bs.blockFromBlockID(ctx, req.BlockId) - if invalidBlockIdErr, ok := err.(*blockIdParseError); ok { - return nil, status.Errorf(codes.InvalidArgument, "Invalid block ID: %v", invalidBlockIdErr) - } + blk, phase0Blk, err := bs.blocksFromId(ctx, req.BlockId) if err != nil { - return nil, status.Errorf(codes.Internal, "Could not get block from block ID: %v", err) + return nil, status.Errorf(codes.Internal, "Could not get block: %v", err) } - if rBlk == nil || rBlk.IsNil() { - return nil, status.Errorf(codes.NotFound, "Could not find requested block") + if phase0Blk != nil { + v1Blk, err := migration.SignedBeaconBlock(blk) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err) + } + return ðpbv1.BlockAttestationsResponse{ + Data: v1Blk.Block.Body.Attestations, + }, nil } - - blk, err := rBlk.PbPhase0Block() + altairBlk, err := blk.PbAltairBlock() if err != nil { - return nil, status.Errorf(codes.Internal, "Could not get raw block: %v", err) + return nil, status.Errorf(codes.Internal, "Could not check for Altair block") } - - v1Block, err := migration.V1Alpha1ToV1SignedBlock(blk) + v2Blk, err := migration.V1Alpha1BeaconBlockAltairToV2(altairBlk.Block) if err != nil { - return nil, status.Errorf(codes.Internal, "Could not convert block to v1 block") + return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err) } return ðpbv1.BlockAttestationsResponse{ - Data: v1Block.Block.Body.Attestations, + Data: v2Blk.Body.Attestations, }, nil } diff --git a/beacon-chain/rpc/eth/beacon/blocks_test.go b/beacon-chain/rpc/eth/beacon/blocks_test.go index 62a017646e..14977f0f93 100644 --- a/beacon-chain/rpc/eth/beacon/blocks_test.go +++ b/beacon-chain/rpc/eth/beacon/blocks_test.go @@ -875,99 +875,201 @@ func TestServer_GetBlockRoot(t *testing.T) { } func TestServer_ListBlockAttestations(t *testing.T) { - beaconDB := dbTest.SetupDB(t) - ctx := context.Background() + t.Run("Phase 0", func(t *testing.T) { + beaconDB := dbTest.SetupDB(t) + ctx := context.Background() - _, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) - headBlock := blkContainers[len(blkContainers)-1] - bs := &Server{ - BeaconDB: beaconDB, - ChainInfoFetcher: &mock.ChainService{ - DB: beaconDB, - Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), - Root: headBlock.BlockRoot, - FinalizedCheckPoint: ðpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, - }, - } + _, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) + headBlock := blkContainers[len(blkContainers)-1] + bs := &Server{ + BeaconDB: beaconDB, + ChainInfoFetcher: &mock.ChainService{ + DB: beaconDB, + Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), + Root: headBlock.BlockRoot, + FinalizedCheckPoint: ðpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, + }, + } - genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) - root, err := genBlk.Block.HashTreeRoot() - require.NoError(t, err) + genBlk, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) + root, err := genBlk.Block.HashTreeRoot() + require.NoError(t, err) - tests := []struct { - name string - blockID []byte - want *ethpbalpha.SignedBeaconBlock - wantErr bool - }{ - { - name: "slot", - blockID: []byte("30"), - want: blkContainers[30].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, - }, - { - name: "bad formatting", - blockID: []byte("3bad0"), - wantErr: true, - }, - { - name: "head", - blockID: []byte("head"), - want: headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, - }, - { - name: "finalized", - blockID: []byte("finalized"), - want: blkContainers[64].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, - }, - { - name: "genesis", - blockID: []byte("genesis"), - want: genBlk, - }, - { - name: "genesis root", - blockID: root[:], - want: genBlk, - }, - { - name: "root", - blockID: blkContainers[20].BlockRoot, - want: blkContainers[20].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, - }, - { - name: "non-existent root", - blockID: bytesutil.PadTo([]byte("hi there"), 32), - wantErr: true, - }, - { - name: "slot", - blockID: []byte("40"), - want: blkContainers[40].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, - }, - { - name: "no block", - blockID: []byte("105"), - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - block, err := bs.ListBlockAttestations(ctx, ðpbv1.BlockRequest{ - BlockId: tt.blockID, + tests := []struct { + name string + blockID []byte + want *ethpbalpha.SignedBeaconBlock + wantErr bool + }{ + { + name: "slot", + blockID: []byte("30"), + want: blkContainers[30].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, + }, + { + name: "bad formatting", + blockID: []byte("3bad0"), + wantErr: true, + }, + { + name: "head", + blockID: []byte("head"), + want: headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, + }, + { + name: "finalized", + blockID: []byte("finalized"), + want: blkContainers[64].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, + }, + { + name: "genesis", + blockID: []byte("genesis"), + want: genBlk, + }, + { + name: "genesis root", + blockID: root[:], + want: genBlk, + }, + { + name: "root", + blockID: blkContainers[20].BlockRoot, + want: blkContainers[20].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, + }, + { + name: "non-existent root", + blockID: bytesutil.PadTo([]byte("hi there"), 32), + wantErr: true, + }, + { + name: "slot", + blockID: []byte("40"), + want: blkContainers[40].Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block, + }, + { + name: "no block", + blockID: []byte("105"), + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + blk, err := bs.ListBlockAttestations(ctx, ðpbv1.BlockRequest{ + BlockId: tt.blockID, + }) + if tt.wantErr { + require.NotEqual(t, err, nil) + return + } + require.NoError(t, err) + + v1Block, err := migration.V1Alpha1ToV1SignedBlock(tt.want) + require.NoError(t, err) + + if !reflect.DeepEqual(blk.Data, v1Block.Block.Body.Attestations) { + t.Error("Expected attestations to equal") + } }) - if tt.wantErr { - require.NotEqual(t, err, nil) - return - } - require.NoError(t, err) + } + }) - v1Block, err := migration.V1Alpha1ToV1SignedBlock(tt.want) - require.NoError(t, err) + t.Run("Altair", func(t *testing.T) { + beaconDB := dbTest.SetupDB(t) + ctx := context.Background() - if !reflect.DeepEqual(block.Data, v1Block.Block.Body.Attestations) { - t.Error("Expected attestations to equal") - } - }) - } + _, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB) + headBlock := blkContainers[len(blkContainers)-1] + blk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock) + require.NoError(t, err) + bs := &Server{ + BeaconDB: beaconDB, + ChainInfoFetcher: &mock.ChainService{ + DB: beaconDB, + Block: blk, + Root: headBlock.BlockRoot, + FinalizedCheckPoint: ðpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, + }, + } + + genBlk, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB) + root, err := genBlk.Block.HashTreeRoot() + require.NoError(t, err) + + tests := []struct { + name string + blockID []byte + want *ethpbalpha.SignedBeaconBlockAltair + wantErr bool + }{ + { + name: "slot", + blockID: []byte("30"), + want: blkContainers[30].Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock, + }, + { + name: "bad formatting", + blockID: []byte("3bad0"), + wantErr: true, + }, + { + name: "head", + blockID: []byte("head"), + want: headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock, + }, + { + name: "finalized", + blockID: []byte("finalized"), + want: blkContainers[64].Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock, + }, + { + name: "genesis", + blockID: []byte("genesis"), + want: genBlk, + }, + { + name: "genesis root", + blockID: root[:], + want: genBlk, + }, + { + name: "root", + blockID: blkContainers[20].BlockRoot, + want: blkContainers[20].Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock, + }, + { + name: "non-existent root", + blockID: bytesutil.PadTo([]byte("hi there"), 32), + wantErr: true, + }, + { + name: "slot", + blockID: []byte("40"), + want: blkContainers[40].Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock, + }, + { + name: "no block", + blockID: []byte("105"), + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + blk, err := bs.ListBlockAttestations(ctx, ðpbv1.BlockRequest{ + BlockId: tt.blockID, + }) + if tt.wantErr { + require.NotEqual(t, err, nil) + return + } + require.NoError(t, err) + + v1Block, err := migration.V1Alpha1BeaconBlockAltairToV2(tt.want.Block) + require.NoError(t, err) + + if !reflect.DeepEqual(blk.Data, v1Block.Body.Attestations) { + t.Error("Expected attestations to equal") + } + }) + } + }) }