Return properties of proofs

activation/malfeasance.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/spacemeshos/post/shared"
@@ -44,6 +45,19 @@ func NewMalfeasanceHandler(
 	}
 }
 
+func (mh *MalfeasanceHandler) Info(data wire.ProofData) (map[string]string, error) {
+	ap, ok := data.(*wire.AtxProof)
+	if !ok {
+		return nil, errors.New("wrong message type for multiple ATXs")
+	}
+	return map[string]string{
+		"atx1":          ap.Messages[0].InnerMsg.MsgHash.String(),
+		"atx2":          ap.Messages[1].InnerMsg.MsgHash.String(),
+		"publish_epoch": strconv.FormatUint(uint64(ap.Messages[0].InnerMsg.PublishEpoch), 10),
+		"smesher_id":    ap.Messages[0].SmesherID.String(),
+	}, nil
+}
+
 func (mh *MalfeasanceHandler) Validate(ctx context.Context, data wire.ProofData) (types.NodeID, error) {
 	ap, ok := data.(*wire.AtxProof)
 	if !ok {
@@ -109,6 +123,18 @@ func NewInvalidPostIndexHandler(
 	}
 }
 
+func (mh *InvalidPostIndexHandler) Info(data wire.ProofData) (map[string]string, error) {
+	pp, ok := data.(*wire.InvalidPostIndexProof)
+	if !ok {
+		return nil, errors.New("wrong message type for invalid post index")
+	}
+	return map[string]string{
+		"atx":        pp.Atx.ID().String(),
+		"index":      strconv.FormatUint(uint64(pp.InvalidIdx), 10),
+		"smesher_id": pp.Atx.SmesherID.String(),
+	}, nil
+}
+
 func (mh *InvalidPostIndexHandler) Validate(ctx context.Context, data wire.ProofData) (types.NodeID, error) {
 	proof, ok := data.(*wire.InvalidPostIndexProof)
 	if !ok {
@@ -174,6 +200,19 @@ func NewInvalidPrevATXHandler(
 	}
 }
 
+func (mh *InvalidPrevATXHandler) Info(data wire.ProofData) (map[string]string, error) {
+	pp, ok := data.(*wire.InvalidPrevATXProof)
+	if !ok {
+		return nil, errors.New("wrong message type for invalid previous ATX")
+	}
+	return map[string]string{
+		"atx1":       pp.Atx1.ID().String(),
+		"atx2":       pp.Atx2.ID().String(),
+		"prev_atx":   pp.Atx1.PrevATXID.String(),
+		"smesher_id": pp.Atx1.SmesherID.String(),
+	}, nil
+}
+
 func (mh *InvalidPrevATXHandler) Validate(ctx context.Context, data wire.ProofData) (types.NodeID, error) {
 	proof, ok := data.(*wire.InvalidPrevATXProof)
 	if !ok {

api/grpcserver/v2alpha1/malfeasance.go

@@ -2,10 +2,12 @@ package v2alpha1
 
 import (
 	"context"
+	"strconv"
 	"time"
 
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	spacemeshv2alpha1 "github.com/spacemeshos/api/release/go/spacemesh/v2alpha1"
+	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -16,12 +18,31 @@ import (
 	"github.com/spacemeshos/go-spacemesh/sql/identities"
 )
 
-func NewMalfeasanceService(db sql.Executor) *MalfeasanceService {
-	return &MalfeasanceService{db: db}
+const (
+	Malfeasance       = "malfeasance_v2alpha1"
+	MalfeasanceStream = "malfeasance_stream_v2alpha1"
+)
+
+type malfeasanceInfo interface {
+	Info(data []byte) (map[string]string, error)
+}
+
+func NewMalfeasanceService(
+	db sql.Executor,
+	logger *zap.Logger,
+	malfeasanceHandler malfeasanceInfo,
+) *MalfeasanceService {
+	return &MalfeasanceService{
+		db:     db,
+		logger: logger,
+		info:   malfeasanceHandler,
+	}
 }
 
 type MalfeasanceService struct {
-	db sql.Executor
+	db     sql.Executor
+	logger *zap.Logger
+	info   malfeasanceInfo
 }
 
 func (s *MalfeasanceService) RegisterService(server *grpc.Server) {
@@ -54,15 +75,11 @@ func (s *MalfeasanceService) List(
 
 	rst := make([]*spacemeshv2alpha1.MalfeasanceProof, 0, request.Limit)
 	if err := identities.IterateMaliciousOps(s.db, ops, func(id types.NodeID, proof []byte, received time.Time) bool {
-		// TODO (mafa): fetch info about proof from malfeasance service
-		proofType := uint32(0)
-		properties := make(map[string]string)
-		rst = append(rst, &spacemeshv2alpha1.MalfeasanceProof{
-			Smesher:    id.Bytes(),
-			Domain:     spacemeshv2alpha1.MalfeasanceProof_DOMAIN_UNSPECIFIED,
-			Type:       proofType,
-			Properties: properties,
-		})
+		result := s.toProof(id, proof)
+		if result == nil {
+			return true
+		}
+		rst = append(rst, result)
 		return true
 	}); err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
@@ -71,12 +88,59 @@ func (s *MalfeasanceService) List(
 	return &spacemeshv2alpha1.MalfeasanceList{Malfeasances: rst}, nil
 }
 
-func NewMalfeasanceStreamService(db sql.Executor) *MalfeasanceStreamService {
-	return &MalfeasanceStreamService{db: db}
+func (s *MalfeasanceService) toProof(id types.NodeID, proof []byte) *spacemeshv2alpha1.MalfeasanceProof {
+	properties, err := s.info.Info(proof)
+	if err != nil {
+		s.logger.Debug("failed to get malfeasance info",
+			zap.String("smesher", id.String()),
+			zap.Error(err),
+		)
+		return nil
+	}
+	domain, err := strconv.ParseUint(properties["domain"], 10, 64)
+	if err != nil {
+		s.logger.Debug("failed to parse proof domain",
+			zap.String("smesher", id.String()),
+			zap.String("domain", properties["domain"]),
+			zap.Error(err),
+		)
+		return nil
+	}
+	delete(properties, "domain")
+	proofType, err := strconv.ParseUint(properties["type"], 10, 32)
+	if err != nil {
+		s.logger.Debug("failed to parse proof type",
+			zap.String("smesher", id.String()),
+			zap.String("type", properties["type"]),
+			zap.Error(err),
+		)
+		return nil
+	}
+	delete(properties, "type")
+	return &spacemeshv2alpha1.MalfeasanceProof{
+		Smesher:    id.Bytes(),
+		Domain:     spacemeshv2alpha1.MalfeasanceProof_MalfeasanceDomain(domain),
+		Type:       uint32(proofType),
+		Properties: properties,
+	}
+}
+
+func NewMalfeasanceStreamService(
+	db sql.Executor,
+	logger *zap.Logger,
+	malfeasanceHandler malfeasanceInfo,
+) *MalfeasanceStreamService {
+	return &MalfeasanceStreamService{
+		db:     db,
+		logger: logger,
+		info:   malfeasanceHandler,
+	}
 }
 
 type MalfeasanceStreamService struct {
-	db sql.Executor
+	db     sql.Executor
+	logger *zap.Logger
+	info   malfeasanceInfo
 }
 
 func (s *MalfeasanceStreamService) RegisterService(server *grpc.Server) {

hare3/malfeasance.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"go.uber.org/zap"
@@ -52,6 +53,20 @@ func NewMalfeasanceHandler(
 	return mh
 }
 
+func (mh *MalfeasanceHandler) Info(data wire.ProofData) (map[string]string, error) {
+	hp, ok := data.(*wire.HareProof)
+	if !ok {
+		return nil, errors.New("wrong message type for hare equivocation")
+	}
+	return map[string]string{
+		"msg1":       hp.Messages[0].InnerMsg.MsgHash.String(),
+		"msg2":       hp.Messages[1].InnerMsg.MsgHash.String(),
+		"layer":      hp.Messages[0].InnerMsg.Layer.String(),
+		"round":      strconv.FormatUint(uint64(hp.Messages[0].InnerMsg.Round), 10),
+		"smesher_id": hp.Messages[0].SmesherID.String(),
+	}, nil
+}
+
 func (mh *MalfeasanceHandler) Validate(ctx context.Context, data wire.ProofData) (types.NodeID, error) {
 	hp, ok := data.(*wire.HareProof)
 	if !ok {

malfeasance/handler.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"slices"
+	"strconv"
 	"time"
 
 	"go.uber.org/zap"
@@ -92,6 +93,24 @@ func (h *Handler) countInvalidProof(p *wire.MalfeasanceProof) {
 	h.handlers[MalfeasanceType(p.Proof.Type)].ReportInvalidProof(numInvalidProofs)
 }
 
+func (h *Handler) Info(data []byte) (map[string]string, error) {
+	var p wire.MalfeasanceProof
+	if err := codec.Decode(data, &p); err != nil {
+		return nil, fmt.Errorf("decode malfeasance proof: %w", err)
+	}
+	mh, ok := h.handlers[MalfeasanceType(p.Proof.Type)]
+	if !ok {
+		return nil, fmt.Errorf("unknown malfeasance type %d", p.Proof.Type)
+	}
+	properties, err := mh.Info(p.Proof.Data)
+	if err != nil {
+		return nil, fmt.Errorf("malfeasance info: %w", err)
+	}
+	properties["domain"] = "0" // for malfeasance V1 there are no domains
+	properties["type"] = strconv.FormatUint(uint64(p.Proof.Type), 10)
+	return properties, nil
+}
+
 // HandleSyncedMalfeasanceProof is the sync validator for MalfeasanceProof.
 func (h *Handler) HandleSyncedMalfeasanceProof(
 	ctx context.Context,

malfeasance/interface.go

@@ -17,6 +17,7 @@ type tortoise interface {
 
 type MalfeasanceHandler interface {
 	Validate(ctx context.Context, data wire.ProofData) (types.NodeID, error)
+	Info(data wire.ProofData) (map[string]string, error)
 	ReportProof(vec *prometheus.CounterVec)
 	ReportInvalidProof(vec *prometheus.CounterVec)
 }