mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 12:57:18 +00:00
fb8be4d555
* refactor BLS to expose an interface rather than a single implementation * Split up tests, gofmt, goimports, docs * godoc for signature.Copy() * more godocs * revert gomod / deps changes * rm newline * revert proto changes * rename bls12 to herumi for clarity
180 lines
6.2 KiB
Go
180 lines
6.2 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/pkg/errors"
|
|
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
|
|
slashpb "github.com/prysmaticlabs/prysm/proto/slashing"
|
|
"github.com/prysmaticlabs/prysm/shared/attestationutil"
|
|
"github.com/prysmaticlabs/prysm/shared/bls"
|
|
"github.com/prysmaticlabs/prysm/shared/p2putils"
|
|
"github.com/prysmaticlabs/prysm/shared/params"
|
|
"github.com/prysmaticlabs/prysm/slasher/beaconclient"
|
|
"github.com/prysmaticlabs/prysm/slasher/db"
|
|
"github.com/prysmaticlabs/prysm/slasher/detection"
|
|
"go.opencensus.io/trace"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
// Server defines a server implementation of the gRPC Slasher service,
|
|
// providing RPC endpoints for retrieving slashing proofs for malicious validators.
|
|
type Server struct {
|
|
ctx context.Context
|
|
detector *detection.Service
|
|
slasherDB db.Database
|
|
beaconClient *beaconclient.Service
|
|
}
|
|
|
|
// IsSlashableAttestation returns an attester slashing if the attestation submitted
|
|
// is a slashable vote.
|
|
func (ss *Server) IsSlashableAttestation(ctx context.Context, req *ethpb.IndexedAttestation) (*slashpb.AttesterSlashingResponse, error) {
|
|
ctx, span := trace.StartSpan(ctx, "detection.IsSlashableAttestation")
|
|
defer span.End()
|
|
|
|
if req == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil request provided")
|
|
}
|
|
if req.Data == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil request data provided")
|
|
}
|
|
if req.Data.Target == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil request data target provided")
|
|
}
|
|
if req.Data.Source == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil request data source provided")
|
|
}
|
|
if req.Signature == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil signature provided")
|
|
}
|
|
|
|
err := attestationutil.IsValidAttestationIndices(ctx, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gvr, err := ss.beaconClient.GenesisValidatorsRoot(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fork, err := p2putils.Fork(req.Data.Target.Epoch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
domain, err := helpers.Domain(fork, req.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, gvr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
indices := req.AttestingIndices
|
|
pkMap, err := ss.beaconClient.FindOrGetPublicKeys(ctx, indices)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pubkeys := []bls.PublicKey{}
|
|
for _, pkBytes := range pkMap {
|
|
pk, err := bls.PublicKeyFromBytes(pkBytes[:])
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not deserialize validator public key")
|
|
}
|
|
pubkeys = append(pubkeys, pk)
|
|
}
|
|
|
|
err = attestationutil.VerifyIndexedAttestationSig(ctx, req, pubkeys, domain)
|
|
if err != nil {
|
|
log.WithError(err).Error("failed to verify indexed attestation signature")
|
|
return nil, status.Errorf(codes.Internal, "could not verify indexed attestation signature: %v: %v", req, err)
|
|
}
|
|
slashings, err := ss.detector.DetectAttesterSlashings(ctx, req)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "could not detect attester slashings for attestation: %v: %v", req, err)
|
|
}
|
|
if len(slashings) < 1 {
|
|
if err := ss.slasherDB.SaveIndexedAttestation(ctx, req); err != nil {
|
|
log.WithError(err).Error("Could not save indexed attestation")
|
|
return nil, status.Errorf(codes.Internal, "could not save indexed attestation: %v: %v", req, err)
|
|
}
|
|
if err := ss.detector.UpdateSpans(ctx, req); err != nil {
|
|
log.WithError(err).Error("could not update spans")
|
|
}
|
|
}
|
|
return &slashpb.AttesterSlashingResponse{
|
|
AttesterSlashing: slashings,
|
|
}, nil
|
|
}
|
|
|
|
// IsSlashableBlock returns an proposer slashing if the block submitted
|
|
// is a double proposal.
|
|
func (ss *Server) IsSlashableBlock(ctx context.Context, req *ethpb.SignedBeaconBlockHeader) (*slashpb.ProposerSlashingResponse, error) {
|
|
ctx, span := trace.StartSpan(ctx, "detection.IsSlashableBlock")
|
|
defer span.End()
|
|
|
|
if req == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil request provided")
|
|
}
|
|
if req.Header == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil header provided")
|
|
|
|
}
|
|
if req.Signature == nil {
|
|
return nil, status.Error(codes.InvalidArgument, "nil signature provided")
|
|
}
|
|
gvr, err := ss.beaconClient.GenesisValidatorsRoot(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
blockEpoch := helpers.SlotToEpoch(req.Header.Slot)
|
|
fork, err := p2putils.Fork(blockEpoch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
domain, err := helpers.Domain(fork, blockEpoch, params.BeaconConfig().DomainBeaconProposer, gvr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkMap, err := ss.beaconClient.FindOrGetPublicKeys(ctx, []uint64{req.Header.ProposerIndex})
|
|
if err := helpers.VerifyBlockHeaderSigningRoot(
|
|
req.Header, pkMap[req.Header.ProposerIndex], req.Signature, domain); err != nil {
|
|
return nil, err
|
|
}
|
|
slashing, err := ss.detector.DetectDoubleProposals(ctx, req)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "could not detect proposer slashing for block: %v: %v", req, err)
|
|
}
|
|
psr := &slashpb.ProposerSlashingResponse{}
|
|
if slashing != nil {
|
|
psr = &slashpb.ProposerSlashingResponse{
|
|
ProposerSlashing: []*ethpb.ProposerSlashing{slashing},
|
|
}
|
|
}
|
|
return psr, nil
|
|
|
|
}
|
|
|
|
// IsSlashableAttestationNoUpdate returns true if the attestation submitted
|
|
// is a slashable vote (no db update is being done).
|
|
func (ss *Server) IsSlashableAttestationNoUpdate(ctx context.Context, req *ethpb.IndexedAttestation) (*slashpb.Slashable, error) {
|
|
sl := &slashpb.Slashable{}
|
|
slashings, err := ss.detector.DetectAttesterSlashings(ctx, req)
|
|
if err != nil {
|
|
return sl, status.Errorf(codes.Internal, "could not detect attester slashings for attestation: %v: %v", req, err)
|
|
}
|
|
if len(slashings) < 1 {
|
|
return sl, nil
|
|
}
|
|
sl.Slashable = true
|
|
return sl, nil
|
|
}
|
|
|
|
// IsSlashableBlockNoUpdate returns true if the block submitted
|
|
// is slashable (no db update is being done).
|
|
func (ss *Server) IsSlashableBlockNoUpdate(ctx context.Context, req *ethpb.BeaconBlockHeader) (*slashpb.Slashable, error) {
|
|
sl := &slashpb.Slashable{}
|
|
slash, err := ss.detector.DetectDoubleProposeNoUpdate(ctx, req)
|
|
if err != nil {
|
|
return sl, status.Errorf(codes.Internal, "could not detect proposer slashing for block: %v: %v", req, err)
|
|
}
|
|
sl.Slashable = slash
|
|
return sl, nil
|
|
}
|