feat: handle gmp message for leverage messages

x/uibc/gmp/gmp_middleware.go

@@ -2,6 +2,7 @@
 
 import (
 	"encoding/json"
+	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -13,62 +14,28 @@
 	return &Handler{}
 }
 
-func (h Handler) OnRecvPacket(ctx sdk.Context, coinReceived sdk.Coin, memo string, receiver sdk.AccAddress,
-) error {
-	if len(memo) == 0 {
-		return nil
+func (h Handler) OnRecvPacket(ctx sdk.Context, coinReceived sdk.Coin, memoStr string, receiver sdk.AccAddress,
+) (Message, error) {
+	if len(memoStr) == 0 {
+		return Message{}, nil
 	}
 
 	logger := ctx.Logger().With("handler", "gmp_handler")
 	var msg Message
 	var err error
 
-	if err = json.Unmarshal([]byte(memo), &msg); err != nil {
+	if err = json.Unmarshal([]byte(memoStr), &msg); err != nil {
 		logger.Error("cannot unmarshal memo", "err", err)
-		return err
+		return Message{}, err
 	}
 
 	switch msg.Type {
 	case TypeGeneralMessage:
-		err := h.HandleGeneralMessage(ctx, msg.SourceAddress, msg.SourceAddress, receiver, msg.Payload)
-		if err != nil {
-			logger.Error("err at HandleGeneralMessage", err)
-		}
+		return msg, fmt.Errorf("we are not supporting general message: %d", msg.Type)
 	case TypeGeneralMessageWithToken:
-		err := h.HandleGeneralMessageWithToken(
-			ctx, msg.SourceAddress, msg.SourceAddress, receiver, msg.Payload, coinReceived)
-		if err != nil {
-			logger.Error("err at HandleGeneralMessageWithToken", err)
-		}
+		return msg, nil
 	default:
 		logger.Error("unrecognized gmp message type: %d", msg.Type)
+		return msg, fmt.Errorf("unrecognized gmp message type: %d", msg.Type)
 	}
-
-	return err
-}
-
-func (h Handler) HandleGeneralMessage(ctx sdk.Context, srcChain, srcAddress string, receiver sdk.AccAddress,
-	payload []byte) error {
-	ctx.Logger().Info("HandleGeneralMessage called",
-		"srcChain", srcChain,
-		"srcAddress", srcAddress,
-		"receiver", receiver,
-		"payload", payload,
-		"handler", "gmp-handler",
-	)
-	return nil
-}
-
-func (h Handler) HandleGeneralMessageWithToken(ctx sdk.Context, srcChain, srcAddress string,
-	receiver sdk.AccAddress, payload []byte, coin sdk.Coin) error {
-
-	ctx.Logger().Info("HandleGeneralMessageWithToken called",
-		"srcChain", srcChain,
-		"srcAddress", srcAddress,
-		"receiver", receiver,
-		"payload", payload,
-		"coin", coin,
-		"handler", "gmp-token-handler",
-	)
-	return nil
 }

x/uibc/gmp/gmp_middleware_test.go

@@ -28,7 +28,7 @@ func TestGmpMemoHandler(t *testing.T) {
 			errMsg: "invalid character",
 		},
 		{
-			name: "valid memo",
+			name: "not supporting the msg",
 			memo: func() string {
 				validMemo := Message{
 					SourceChain:   "source_chain",
@@ -40,13 +40,28 @@ func TestGmpMemoHandler(t *testing.T) {
 				assert.NilError(t, err)
 				return string(m)
 			},
+			errMsg: "we are not supporting general message",
+		},
+		{
+			name: "valid memo",
+			memo: func() string {
+				validMemo := Message{
+					SourceChain:   "source_chain",
+					SourceAddress: "source_addr",
+					Payload:       nil,
+					Type:          int64(2),
+				}
+				m, err := json.Marshal(validMemo)
+				assert.NilError(t, err)
+				return string(m)
+			},
 			errMsg: "",
 		},
 	}
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			err := gmpHandler.OnRecvPacket(ctx, sdk.Coin{}, tc.memo(), nil)
+			_, err := gmpHandler.OnRecvPacket(ctx, sdk.Coin{}, tc.memo(), nil)
 			if len(tc.errMsg) != 0 {
 				assert.ErrorContains(t, err, tc.errMsg)
 			} else {

x/uibc/uics20/memo_handler.go

@@ -58,13 +58,20 @@
 		return nil, sdkerrors.Wrap(err, "can't parse ftData.Receiver bech32 address")
 	}
 
+	var memoPayload []byte
 	if strings.EqualFold(ftData.Sender, gmp.DefaultGMPAddress) {
 		events = append(events, "axelar GMP transaction")
 		mh.isGMP = true
-		return events, nil
+		gh := gmp.NewHandler()
+		gmpMessage, err := gh.OnRecvPacket(*ctx, mh.received, mh.memo, mh.receiver)
+		if err != nil {
+			return events, err
+		}
+		memoPayload = gmpMessage.Payload
+	} else {
+		memoPayload = []byte(ftData.Memo)
 	}
-
-	memo, err := deserializeMemo(mh.cdc, []byte(ftData.Memo))
+	memo, err := deserializeMemo(mh.cdc, memoPayload)
 	if err != nil {
 		recvPacketLogger(ctx).Debug("Not recognized ICS20 memo, ignoring hook execution", "err", err)
 		return nil, nil
@@ -105,10 +112,10 @@
 	}
 
 	logger := recvPacketLogger(ctx)
-	if mh.isGMP {
-		gh := gmp.NewHandler()
-		return gh.OnRecvPacket(*ctx, mh.received, mh.memo, mh.receiver)
-	}
+	// if mh.isGMP {
+	// 	gh := gmp.NewHandler(mh.cdc)
+	// 	return gh.OnRecvPacket(ctx, mh.received, mh.memo, mh.receiver)
+	// }
 
 	if len(mh.msgs) == 0 {
 		return nil // quick return - we have nothing to handle