Handle V2 Malfeasance proofs in V2 ATX handler

activation/handler.go

@@ -146,7 +146,7 @@ func NewHandler(
 			fetcher:         fetcher,
 			beacon:          beacon,
 			tortoise:        tortoise,
-			malPublisher:    &MalfeasancePublisher{},
+			malPublisher:    &ATXMalfeasancePublisher{},
 		},
 	}
 
@@ -286,6 +286,7 @@ func (h *Handler) handleAtx(
 		case *wire.ActivationTxV1:
 			return h.v1.processATX(ctx, peer, atx, receivedTime)
 		case *wire.ActivationTxV2:
+			// TODO(mafa): change function signature to not return proofs any more
 			return (*mwire.MalfeasanceProof)(nil), h.v2.processATX(ctx, peer, atx, receivedTime)
 		default:
 			panic("unreachable")

activation/handler_test.go

@@ -126,7 +126,7 @@ type handlerMocks struct {
 	mValidator  *MocknipostValidator
 	mbeacon     *MockAtxReceiver
 	mtortoise   *mocks.MockTortoise
-	mMalPublish *MockmalfeasancePublisher
+	mMalPublish *MockatxMalfeasancePublisher
 }
 
 type testHandler struct {
@@ -190,7 +190,7 @@ func newTestHandlerMocks(tb testing.TB, golden types.ATXID) handlerMocks {
 		mValidator:  NewMocknipostValidator(ctrl),
 		mbeacon:     NewMockAtxReceiver(ctrl),
 		mtortoise:   mocks.NewMockTortoise(ctrl),
-		mMalPublish: NewMockmalfeasancePublisher(ctrl),
+		mMalPublish: NewMockatxMalfeasancePublisher(ctrl),
 	}
 }
 

activation/handler_v2.go

@@ -68,7 +68,7 @@
 	tortoise        system.Tortoise
 	logger          *zap.Logger
 	fetcher         system.Fetcher
-	malPublisher    malfeasancePublisher
+	malPublisher    atxMalfeasancePublisher
 }
 
 func (h *HandlerV2) processATX(
@@ -528,8 +528,9 @@
 			return nil, fmt.Errorf("fetching previous atx: %w", err)
 		}
 		if prevAtx.PublishEpoch >= atx.PublishEpoch {
-			err := fmt.Errorf("previous atx is too new (%d >= %d) (%s) ", prevAtx.PublishEpoch, atx.PublishEpoch, prev)
-			return nil, err
+			return nil, fmt.Errorf("previous atx (%s) is too new (%d >= %d)",
+				prev, prevAtx.PublishEpoch, atx.PublishEpoch,
+			)
 		}
 		previousAtxs[i] = prevAtx
 	}
@@ -545,8 +546,9 @@
 		nipostSizes[i] = new(nipostSize)
 		for _, post := range niposts.Posts {
 			if post.MarriageIndex >= uint32(len(equivocationSet)) {
-				err := fmt.Errorf("marriage index out of bounds: %d > %d", post.MarriageIndex, len(equivocationSet)-1)
-				return nil, err
+				return nil, fmt.Errorf("marriage index out of bounds: %d > %d",
+					post.MarriageIndex, len(equivocationSet)-1,
+				)
 			}
 
 			id := equivocationSet[post.MarriageIndex]

activation/handler_v2_test.go

@@ -3,6 +3,7 @@ package activation
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math"
 	"slices"
 	"testing"
@@ -17,7 +18,6 @@ import (
 
 	"github.com/spacemeshos/go-spacemesh/activation/wire"
 	"github.com/spacemeshos/go-spacemesh/atxsdata"
-	"github.com/spacemeshos/go-spacemesh/codec"
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/datastore"
 	"github.com/spacemeshos/go-spacemesh/fetch"
@@ -1509,7 +1509,7 @@ func TestHandlerV2_SyntacticallyValidateDeps(t *testing.T) {
 		atx.Sign(sig)
 
 		_, err := atxHandler.syntacticallyValidateDeps(context.Background(), atx)
-		require.ErrorContains(t, err, "previous atx is too new")
+		require.ErrorContains(t, err, fmt.Sprintf("previous atx (%s) is too new", prev.ID()))
 	})
 	t.Run("previous ATX by different smesher", func(t *testing.T) {
 		atxHandler := newV2TestHandler(t, golden)
@@ -1719,8 +1719,6 @@ func Test_Marriages(t *testing.T) {
 			nId, err := malProof.Valid(atxHandler.edVerifier)
 			require.NoError(t, err)
 			require.Equal(t, sig.NodeID(), nId)
-			b := codec.MustEncode(malProof)
-			_ = b
 			return nil
 		})
 		err = atxHandler.processATX(context.Background(), "", atx2, time.Now())

activation/interface.go

@@ -92,18 +92,22 @@ type syncer interface {
 	RegisterForATXSynced() <-chan struct{}
 }
 
-// malfeasancePublisher is an interface for publishing malfeasance proofs.
+// atxMalfeasancePublisher is an interface for publishing malfeasance proofs.
 // This interface is used to publish proofs in V2.
 //
 // The provider of that interface ensures that only valid proofs are published (invalid ones return an error).
 // Proofs against an identity that is managed by the node will also return an error and will not be gossiped.
 //
 // Additionally the publisher will only gossip proofs when the node is in sync, otherwise it will only store them.
 // and mark the associated identity as malfeasant.
-type malfeasancePublisher interface {
+type atxMalfeasancePublisher interface {
 	Publish(ctx context.Context, id types.NodeID, proof wire.Proof) error
 }
 
+type malfeasancePublisher interface {
+	Publish(ctx context.Context, id types.NodeID, proof []byte) error
+}
+
 type atxProvider interface {
 	GetAtx(id types.ATXID) (*types.ActivationTx, error)
 }

activation/malfeasance2_handler.go

@@ -0,0 +1,130 @@
+package activation
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/spacemeshos/go-spacemesh/activation/wire"
+	"github.com/spacemeshos/go-spacemesh/codec"
+	"github.com/spacemeshos/go-spacemesh/common/types"
+	"github.com/spacemeshos/go-spacemesh/datastore"
+	"github.com/spacemeshos/go-spacemesh/signing"
+	"github.com/spacemeshos/go-spacemesh/system"
+)
+
+type MalfeasanceHandlerV2 struct {
+	syncer     syncer
+	clock      layerClock
+	publisher  malfeasancePublisher
+	cdb        *datastore.CachedDB
+	tortoise   system.Tortoise
+	edVerifier *signing.EdVerifier
+}
+
+func NewMalfeasanceHandlerV2(
+	syncer syncer,
+	layerClock layerClock,
+	malPublisher malfeasancePublisher,
+	cdb *datastore.CachedDB,
+	tortoise system.Tortoise,
+	edVerifier *signing.EdVerifier,
+) *MalfeasanceHandlerV2 {
+	return &MalfeasanceHandlerV2{
+		syncer:     syncer,
+		clock:      layerClock,
+		publisher:  malPublisher, // TODO(mafa): implement malfeasancePublisher in `malfeasance` package
+		cdb:        cdb,
+		tortoise:   tortoise,
+		edVerifier: edVerifier,
+	}
+}
+
+// TODO(mafa): call this validate in the handler for publish/gossip.
+// TODO(mafa): extend this validate to return nil if `peer` == self.
+func (mh *MalfeasanceHandlerV2) Validate(ctx context.Context, data []byte) ([]types.NodeID, error) {
+	var decoded wire.ATXProof
+	if err := codec.Decode(data, &decoded); err != nil {
+		return nil, fmt.Errorf("decoding ATX malfeasance proof: %w", err)
+	}
+
+	var proof wire.Proof
+	switch decoded.ProofType {
+	case wire.DoublePublish:
+		p := &wire.ProofDoublePublish{}
+		if err := codec.Decode(decoded.Proof, p); err != nil {
+			return nil, fmt.Errorf("decoding ATX double publish proof: %w", err)
+		}
+		proof = p
+	case wire.DoubleMarry:
+		p := &wire.ProofDoubleMarry{}
+		if err := codec.Decode(decoded.Proof, p); err != nil {
+			return nil, fmt.Errorf("decoding ATX double marry proof: %w", err)
+		}
+		proof = p
+	case wire.InvalidPost:
+		p := &wire.ProofInvalidPost{}
+		if err := codec.Decode(decoded.Proof, p); err != nil {
+			return nil, fmt.Errorf("decoding ATX invalid post proof: %w", err)
+		}
+	default:
+		return nil, fmt.Errorf("unknown ATX malfeasance proof type: %d", decoded.ProofType)
+	}
+
+	id, err := proof.Valid(mh.edVerifier)
+	if err != nil {
+		return nil, fmt.Errorf("validating ATX malfeasance proof: %w", err)
+	}
+
+	// TODO(mafa): do this in the general handler
+	// validIDs := make([]types.NodeID, 0, len(decoded.Certificates)+1)
+	// validIDs = append(validIDs, id) // id has already been proven to be malfeasant
+
+	// // check certificates provided with the proof
+	// // TODO(mafa): only works if the main identity becomes malfeasant - try different approach with merkle proofs
+	// for _, cert := range decoded.Certificates {
+	// 	if id != cert.Target {
+	// 		continue
+	// 	}
+	// 	if !mh.edVerifier.Verify(signing.MARRIAGE, cert.Target, cert.ID.Bytes(), cert.Signature) {
+	// 		continue
+	// 	}
+	// 	validIDs = append(validIDs, cert.ID)
+	// }
+	// return validIDs, nil
+	return []types.NodeID{id}, nil
+}
+
+// TODO(mafa): this roughly how the general publisher looks like
+//
+// func Publish(ctx context.Context, smesherID types.NodeID, data []byte) error {
+// 	// Combine IDs from the present equivocation set for atx.SmesherID and IDs in atx.Marriages.
+// 	set, err := identities.EquivocationSet(mh.cdb, nodeID)
+// 	if err != nil {
+// 		return fmt.Errorf("getting equivocation set: %w", err)
+// 	}
+// 	for _, id := range set {
+// 		if err := identities.SetMalicious(mh.cdb, id, encoded, time.Now()); err != nil {
+// 			return fmt.Errorf("adding malfeasance proof: %w", err)
+// 		}
+
+// 		mh.cdb.CacheMalfeasanceProof(id, proof)
+// 		mh.tortoise.OnMalfeasance(id)
+// 	}
+
+// 	if !mh.syncer.ListenToATXGossip() {
+//      // we are not gossiping proofs when we are not listening to ATX gossip
+// 		return nil
+// 	}
+
+// 	gossip := mwire.MalfeasanceProofV2{
+// 		Layer:     mh.clock.CurrentLayer(),
+// 		ProofType: mwire.InvalidActivation,
+// 		Proof:     data,
+// 	}
+
+// 	if err := mh.publisher.Publish(ctx, pubsub.MalfeasanceProof, codec.MustEncode(&gossip)); err != nil {
+// 		mh.logger.Error("failed to broadcast malfeasance proof", zap.Error(err))
+// 		return fmt.Errorf("broadcast atx malfeasance proof: %w", err)
+// 	}
+// 	return nil
+// }

activation/malfeasance2_publisher.go

@@ -0,0 +1,16 @@
+package activation
+
+import (
+	"context"
+
+	"github.com/spacemeshos/go-spacemesh/activation/wire"
+	"github.com/spacemeshos/go-spacemesh/common/types"
+)
+
+// ATXMalfeasancePublisher is the publisher for ATX proofs.
+type ATXMalfeasancePublisher struct{}
+
+func (p *ATXMalfeasancePublisher) Publish(ctx context.Context, id types.NodeID, proof wire.Proof) error {
+	// TODO(mafa): implement me
+	return nil
+}

activation/post_verifier_test.go

@@ -107,9 +107,7 @@ func TestPostVerifierPrioritization(t *testing.T) {
 	verifier := NewMockPostVerifier(gomock.NewController(t))
 	v := newOffloadingPostVerifier(verifier, 2, zaptest.NewLogger(t), nodeID)
 
-	verifier.EXPECT().
-		Verify(gomock.Any(), gomock.Any(), &shared.ProofMetadata{NodeId: nodeID.Bytes()}, gomock.Any()).
-		Return(nil)
+	verifier.EXPECT().Verify(gomock.Any(), gomock.Any(), &shared.ProofMetadata{NodeId: nodeID.Bytes()}, gomock.Any())
 
 	err := v.Verify(context.Background(), &shared.Proof{}, &shared.ProofMetadata{NodeId: nodeID.Bytes()})
 	require.NoError(t, err)