tests(btcstaking): add RepairStaking test case

x/btcstaking/keeper/msg_server_test.go

@@ -365,3 +365,72 @@ func (suite *KeeperTestSuite) TestBurn() {
 		})
 	}
 }
+
+func (suite *KeeperTestSuite) TestRepairStaking() {
+	testCases := []struct {
+		name       string
+		request    *types.MsgRepairStaking
+		malleate   func(request *types.MsgRepairStaking)
+		validation func(request *types.MsgRepairStaking)
+		expectErr  bool
+	}{
+		{
+			name:      "fail - invalid authority",
+			request:   &types.MsgRepairStaking{Authority: "foobar"},
+			expectErr: true,
+		},
+		{
+			name: "success - valid repair request",
+			request: &types.MsgRepairStaking{
+				Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+				ReceiverInfos: []*types.ReceiverInfo{
+					{
+						Address: "lrz1tffj9qp3wpdnuds443c86wffrac4jkapkjmmcy",
+						Amount:  sdkmath.NewInt(100000000000),
+					},
+				},
+			},
+			validation: func(request *types.MsgRepairStaking) {
+				// check balance
+				for _, receiverInfo := range request.ReceiverInfos {
+					receiver, err := sdk.AccAddressFromBech32(receiverInfo.Address)
+					suite.Require().NoError(err)
+					balance := suite.lorenzoApp.BankKeeper.GetBalance(suite.ctx, receiver, types.NativeTokenDenom)
+					suite.Require().Equal(receiverInfo.Amount, balance.Amount)
+				}
+
+				// check event
+				events := suite.ctx.EventManager().Events()
+				abciEvents := events.ToABCIEvents()
+				for _, abciEvent := range abciEvents {
+					if abciEvent.Type == "lorenzo.btcstaking.v1.EventMintStBTC" {
+						eventAttribute := abciEvent.GetAttributes()
+
+						suite.Require().Equal(eventAttribute[0].Key, "amount")
+						suite.Require().Equal(eventAttribute[1].Key, "cosmos_address")
+						suite.Require().Equal(eventAttribute[2].Key, "eth_address")
+
+					}
+				}
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(fmt.Sprintf("MsgUpdateParams - %s", tc.name), func() {
+			suite.SetupTest()
+			if tc.malleate != nil {
+				tc.malleate(tc.request)
+			}
+			_, err := suite.msgServer.RepairStaking(suite.ctx, tc.request)
+			if tc.expectErr {
+				suite.Require().Error(err)
+			} else {
+				suite.Require().NoError(err)
+			}
+			if tc.validation != nil {
+				tc.validation(tc.request)
+			}
+		})
+	}
+}

x/btcstaking/keeper/repair_staking.go

@@ -13,16 +13,8 @@ func (k Keeper) Compensate(ctx sdk.Context, receiverInfos []*types.ReceiverInfo)
 			return err
 		}
 
-		coins := sdk.NewCoins(sdk.NewCoin(types.NativeTokenDenom, receiverInfo.Amount))
-
-		// mint stBTC to module account
-		if err := k.bankKeeper.MintCoins(ctx, types.ModuleName, coins); err != nil {
-			return errorsmod.Wrapf(types.ErrMintToModule, "failed to mint coins: %v", err)
-		}
-
-		// send coins to receiver
-		if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, receiver, coins); err != nil {
-			return errorsmod.Wrapf(types.ErrTransferToAddr, "failed to send coins from module to account: %v", err)
+		if err := k.MintStBTC(ctx, receiver, receiverInfo.Amount); err != nil {
+			return errorsmod.Wrapf(types.ErrMintStBTC, "failed to mint stBTC: %v", err)
 		}
 	}
 	return nil

x/btcstaking/types/msg.go

@@ -20,6 +20,7 @@ const (
 	TypeMsgRemoveReceiver    = "remove_receiver"
 	TypeMsgAddReceiver       = "add_receiver"
 	TypeMsgUpdateParams      = "update_params"
+	TypeMsgRepairStaking     = "repair_staking"
 )
 
 // ensure that these message types implement the sdk.Msg interface
@@ -260,18 +261,14 @@ func (m *MsgRepairStaking) ValidateBasic() error {
 		return errorsmod.Wrap(err, "invalid authority address")
 	}
 
-	seenMap := make(map[string]bool)
 	for _, a := range m.ReceiverInfos {
-		if seenMap[a.Address] {
-			return fmt.Errorf("duplicate address: %s", a)
-		}
 		if _, err := sdk.AccAddressFromBech32(a.Address); err != nil {
 			return fmt.Errorf("invalid address: %s", a)
 		}
 		if a.Amount.IsZero() {
 			return fmt.Errorf("amount cannot be zero")
 		}
-		seenMap[a.Address] = true
+
 	}
 
 	return nil
@@ -282,9 +279,9 @@ func (m *MsgRepairStaking) GetSignBytes() []byte {
 }
 
 func (m *MsgRepairStaking) Route() string {
-	return ""
+	return RouterKey
 }
 
 func (m *MsgRepairStaking) Type() string {
-	return "lorenzo/btcstaking/MsgRepairStaking"
+	return TypeMsgRepairStaking
 }

x/btcstaking/types/msg_test.go

@@ -220,3 +220,74 @@ func (suite *MsgsTestSuite) TestMsgBurnRequest() {
 		})
 	}
 }
+
+func (suite *MsgsTestSuite) TestMsgRepairStaking() {
+	testCases := []struct {
+		name    string
+		msg     *types.MsgRepairStaking
+		expPass bool
+	}{
+		{
+			"fail - invalid authority address",
+			&types.MsgRepairStaking{
+				Authority: "foobar",
+				ReceiverInfos: []*types.ReceiverInfo{
+					{
+						Address: "cosmos1qperwt9wrnkg5k9e5gzfgjppzpqhyav5j24d66",
+						Amount:  sdkmath.NewInt(100000000000),
+					},
+				},
+			},
+			false,
+		},
+		{
+			"fail - zero amount",
+			&types.MsgRepairStaking{
+				Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+				ReceiverInfos: []*types.ReceiverInfo{
+					{
+						Address: "cosmos1qperwt9wrnkg5k9e5gzfgjppzpqhyav5j24d66",
+						Amount:  sdkmath.NewInt(0),
+					},
+				},
+			},
+			false,
+		},
+		{
+			"fail - invalid authority address",
+			&types.MsgRepairStaking{
+				Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+				ReceiverInfos: []*types.ReceiverInfo{
+					{
+						Address: "0x5dCA2483280D9727c80b5518faC4556617fb19ZZ",
+						Amount:  sdkmath.NewInt(100000000000),
+					},
+				},
+			},
+			false,
+		},
+		{
+			"pass - valid msg",
+			&types.MsgRepairStaking{
+				Authority: authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+				ReceiverInfos: []*types.ReceiverInfo{
+					{
+						Address: "cosmos1qperwt9wrnkg5k9e5gzfgjppzpqhyav5j24d66",
+						Amount:  sdkmath.NewInt(100000000000),
+					},
+				},
+			},
+			true,
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			err := tc.msg.ValidateBasic()
+			if tc.expPass {
+				suite.NoError(err)
+			} else {
+				suite.Error(err)
+			}
+		})
+	}
+}