feat: add the slashing msg handler for op consumer fp (#327)

proto/babylon/finality/v1/tx.proto

@@ -8,6 +8,7 @@ import "tendermint/crypto/proof.proto";
 import "cosmos_proto/cosmos.proto";
 import "cosmos/msg/v1/msg.proto";
 import "babylon/finality/v1/params.proto";
+import "babylon/finality/v1/finality.proto";
 
 // Msg defines the Msg service.
 service Msg {
@@ -23,6 +24,9 @@ service Msg {
     // UnjailFinalityProvider defines a method for unjailing a jailed
     // finality provider, thus it can receive voting power
     rpc UnjailFinalityProvider(MsgUnjailFinalityProvider) returns (MsgUnjailFinalityProviderResponse);
+    // EquivocationEvidence handles the evidence of equivocation message sent from
+    // the finality gadget cw contract
+    rpc EquivocationEvidence(MsgEquivocationEvidence) returns (MsgEquivocationEvidenceResponse);
 }
 
 // MsgCommitPubRandList defines a message for committing a list of public randomness for EOTS
@@ -103,3 +107,31 @@ message MsgUnjailFinalityProvider {
 
 // MsgUnjailFinalityProviderResponse defines the Msg/UnjailFinalityProvider response type
 message MsgUnjailFinalityProviderResponse {}
+
+// MsgEquivocationEvidence is the message for handling evidence of equivocation
+message MsgEquivocationEvidence {
+    option (cosmos.msg.v1.signer) = "signer";
+
+    string signer = 1;
+    // fp_btc_pk is the BTC PK of the finality provider that casts this vote
+    bytes fp_btc_pk = 2 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.BIP340PubKey" ];
+    // block_height is the height of the conflicting blocks
+    uint64 block_height = 3;
+    // pub_rand is the public randomness the finality provider has committed to
+    bytes pub_rand = 4 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.SchnorrPubRand" ];
+    // canonical_app_hash is the AppHash of the canonical block
+    bytes canonical_app_hash = 5;
+    // fork_app_hash is the AppHash of the fork block
+    bytes fork_app_hash = 6;
+    // canonical_finality_sig is the finality signature to the canonical block
+    // where finality signature is an EOTS signature, i.e.,
+    // the `s` in a Schnorr signature `(r, s)`
+    // `r` is the public randomness that is already committed by the finality provider
+    bytes canonical_finality_sig = 7 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.SchnorrEOTSSig" ];
+    // fork_finality_sig is the finality signature to the fork block
+    // where finality signature is an EOTS signature
+    bytes fork_finality_sig = 8 [ (gogoproto.customtype) = "github.com/babylonlabs-io/babylon/types.SchnorrEOTSSig" ];
+}
+
+// MsgEquivocationEvidenceResponse is the response for MsgEquivocationEvidence
+message MsgEquivocationEvidenceResponse {}

x/finality/keeper/msg_server.go

@@ -333,3 +333,56 @@ func (ms msgServer) validateActivationHeight(ctx sdk.Context, height uint64) (ui
 	}
 	return activationHeight, nil
 }
+
+// EquivocationEvidence handles the evidence of equivocation message sent from the finality gadget cw contract
+func (ms msgServer) EquivocationEvidence(goCtx context.Context, req *types.MsgEquivocationEvidence) (*types.MsgEquivocationEvidenceResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// validate the evidence
+	if err := validateEvidence(req); err != nil {
+		return &types.MsgEquivocationEvidenceResponse{}, err
+	}
+
+	// construct the evidence
+	evidence := &types.Evidence{
+		FpBtcPk:              req.FpBtcPk,
+		BlockHeight:          req.BlockHeight,
+		PubRand:              req.PubRand,
+		CanonicalAppHash:     req.CanonicalAppHash,
+		CanonicalFinalitySig: req.CanonicalFinalitySig,
+		ForkAppHash:          req.ForkAppHash,
+		ForkFinalitySig:      req.ForkFinalitySig,
+	}
+
+	// slash this finality provider, including setting its voting power to
+	// zero, extracting its BTC SK, and emit an event
+	ms.slashFinalityProvider(ctx, evidence.FpBtcPk, evidence)
+
+	// save evidence
+	ms.SetEvidence(ctx, evidence)
+
+	return &types.MsgEquivocationEvidenceResponse{}, nil
+}
+
+// Helper function
+func validateEvidence(req *types.MsgEquivocationEvidence) error {
+	if req.FpBtcPk == nil {
+		return fmt.Errorf("empty FpBtcPk")
+	}
+	if req.PubRand == nil {
+		return fmt.Errorf("empty PubRand")
+	}
+	if len(req.CanonicalAppHash) != 32 {
+		return fmt.Errorf("malformed CanonicalAppHash")
+	}
+	if len(req.ForkAppHash) != 32 {
+		return fmt.Errorf("malformed ForkAppHash")
+	}
+	if req.ForkFinalitySig == nil {
+		return fmt.Errorf("empty ForkFinalitySig")
+	}
+	if req.CanonicalFinalitySig == nil {
+		return fmt.Errorf("empty CanonicalFinalitySig")
+	}
+	return nil
+}

x/finality/keeper/msg_server_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"cosmossdk.io/core/header"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 
@@ -487,3 +488,114 @@ func TestVerifyActivationHeight(t *testing.T) {
 		blockHeight, activationHeight,
 	).Error())
 }
+
+func FuzzEquivocationEvidence(f *testing.F) {
+	datagen.AddRandomSeedsToFuzzer(f, 10)
+
+	f.Fuzz(func(t *testing.T, seed int64) {
+		r := rand.New(rand.NewSource(seed))
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		bsKeeper := types.NewMockBTCStakingKeeper(ctrl)
+		cKeeper := types.NewMockCheckpointingKeeper(ctrl)
+		iKeeper := types.NewMockIncentiveKeeper(ctrl)
+		iKeeper.EXPECT().IndexRefundableMsg(gomock.Any(), gomock.Any()).AnyTimes()
+		fKeeper, ctx := keepertest.FinalityKeeper(t, bsKeeper, iKeeper, cKeeper)
+		ms := keeper.NewMsgServerImpl(*fKeeper)
+
+		// set params with activation height
+		err := fKeeper.SetParams(ctx, types.DefaultParams())
+		require.NoError(t, err)
+		activationHeight := fKeeper.GetParams(ctx).FinalityActivationHeight
+
+		// create and register a random finality provider
+		btcSK, btcPK, err := datagen.GenRandomBTCKeyPair(r)
+		require.NoError(t, err)
+		fp, err := datagen.GenRandomFinalityProviderWithBTCSK(r, btcSK, "")
+		require.NoError(t, err)
+		fpBTCPK := bbn.NewBIP340PubKeyFromBTCPK(btcPK)
+		fpBTCPKBytes := fpBTCPK.MustMarshal()
+
+		// test invalid case - without PubRand field in MsgEquivocationEvidence
+		invalidMsg := &types.MsgEquivocationEvidence{
+			Signer:               datagen.GenRandomAccount().Address,
+			FpBtcPk:              fpBTCPK,
+			BlockHeight:          activationHeight,
+			CanonicalAppHash:     datagen.GenRandomByteArray(r, 32),
+			ForkAppHash:          datagen.GenRandomByteArray(r, 32),
+			CanonicalFinalitySig: &bbn.SchnorrEOTSSig{},
+			ForkFinalitySig:      &bbn.SchnorrEOTSSig{},
+		}
+
+		_, err = ms.EquivocationEvidence(ctx, invalidMsg)
+		require.ErrorContains(t, err, "empty PubRand")
+
+		// test valid case
+		blockHeight := activationHeight + uint64(datagen.RandomInt(r, 100))
+
+		// generate proper pub rand data
+		startHeight := blockHeight
+		numPubRand := uint64(200)
+		randListInfo, _, err := datagen.GenRandomMsgCommitPubRandList(r, btcSK, startHeight, numPubRand)
+		require.NoError(t, err)
+
+		// mock pub rand for evidence
+		pubRand := &randListInfo.PRList[0]
+
+		// mock canonical and fork app hash
+		canonicalAppHash := datagen.GenRandomByteArray(r, 32)
+		forkAppHash := datagen.GenRandomByteArray(r, 32)
+
+		// mock canonical signature
+		canonicalBytes := datagen.GenRandomByteArray(r, 32)
+		var canonicalModNScalar btcec.ModNScalar
+		overflowed := canonicalModNScalar.SetByteSlice(canonicalBytes)
+		require.False(t, overflowed)
+		canonicalSig := bbn.NewSchnorrEOTSSigFromModNScalar(&canonicalModNScalar)
+
+		// mock fork signature
+		forkBytes := datagen.GenRandomByteArray(r, 32)
+		var forkModNScalar btcec.ModNScalar
+		overflowed = forkModNScalar.SetByteSlice(forkBytes)
+		require.False(t, overflowed)
+		forkSig := bbn.NewSchnorrEOTSSigFromModNScalar(&forkModNScalar)
+
+		msg := &types.MsgEquivocationEvidence{
+			Signer:               datagen.GenRandomAccount().Address,
+			FpBtcPk:              fpBTCPK,
+			BlockHeight:          blockHeight,
+			PubRand:              pubRand,
+			CanonicalAppHash:     canonicalAppHash,
+			ForkAppHash:          forkAppHash,
+			CanonicalFinalitySig: canonicalSig,
+			ForkFinalitySig:      forkSig,
+		}
+
+		// set block height in context to be >= evidence height
+		blockAppHash := datagen.GenRandomByteArray(r, 32)
+		ctx = ctx.WithHeaderInfo(header.Info{Height: int64(blockHeight), AppHash: blockAppHash})
+		fKeeper.IndexBlock(ctx)
+		bsKeeper.EXPECT().GetFinalityProvider(gomock.Any(), gomock.Eq(fpBTCPKBytes)).Return(fp, nil).AnyTimes()
+
+		// mock voting power
+		fKeeper.SetVotingPower(ctx, fpBTCPKBytes, blockHeight, 1)
+
+		// mock slashing interface
+		bsKeeper.EXPECT().SlashFinalityProvider(gomock.Any(), gomock.Eq(fpBTCPKBytes)).Return(nil)
+		bsKeeper.EXPECT().PropagateFPSlashingToConsumers(gomock.Any(), gomock.Eq(fpBTCPK)).Return(nil)
+
+		_, err = ms.EquivocationEvidence(ctx, msg)
+		require.NoError(t, err)
+
+		storedEvidence, err := fKeeper.GetEvidence(ctx, fpBTCPK, blockHeight)
+		require.NoError(t, err)
+		require.Equal(t, msg.FpBtcPk, storedEvidence.FpBtcPk)
+		require.Equal(t, msg.BlockHeight, storedEvidence.BlockHeight)
+		require.Equal(t, msg.PubRand, storedEvidence.PubRand)
+		require.Equal(t, msg.CanonicalAppHash, storedEvidence.CanonicalAppHash)
+		require.Equal(t, msg.ForkAppHash, storedEvidence.ForkAppHash)
+		require.Equal(t, msg.CanonicalFinalitySig, storedEvidence.CanonicalFinalitySig)
+		require.Equal(t, msg.ForkFinalitySig, storedEvidence.ForkFinalitySig)
+	})
+}