address comments

app/app.go

@@ -659,7 +659,7 @@ func initAppModules(keepers *KeeperCache, bApp *bam.BaseApp, encodingConfig axel
 			bApp.Router(),
 		),
 		permission.NewAppModule(*getKeeper[permissionKeeper.Keeper](keepers)),
-		batcher.NewAppModule(encodingConfig.Codec, bApp.MsgServiceRouter(), initMessageAnteDecorators(encodingConfig, keepers)),
+		batcher.NewAppModule(encodingConfig.Codec, bApp.MsgServiceRouter()),
 	)
 
 	return appModules
@@ -716,6 +716,9 @@ func initAnteHandlers(encodingConfig axelarParams.EncodingConfig, keys map[strin
 			initMessageAnteDecorators(encodingConfig, keepers).ToAnteHandler()),
 	)
 
+	batchAntehandler := sdk.ChainAnteDecorators(anteDecorators...)
+	anteDecorators = append(anteDecorators, ante.NewBatchDecorator(encodingConfig.Codec, batchAntehandler))
+
 	return sdk.ChainAnteDecorators(anteDecorators...)
 }
 

proto/axelar/batcher/v1beta1/tx.proto

@@ -5,6 +5,7 @@ import "google/protobuf/any.proto";
 import "gogoproto/gogo.proto";
 
 import "axelar/permission/exported/v1beta1/types.proto";
+import "cosmos/base/abci/v1beta1/abci.proto";
 
 option go_package = "github.com/axelarnetwork/axelar-core/x/batcher/types";
 
@@ -13,10 +14,10 @@ message BatchRequest {
 
   bytes sender = 1 [ (gogoproto.casttype) =
                          "github.com/cosmos/cosmos-sdk/types.AccAddress" ];
-  repeated google.protobuf.Any must_succeed_messages = 2
-      [ (gogoproto.nullable) = false ];
-  repeated google.protobuf.Any can_fail_messages = 3
+  repeated google.protobuf.Any messages = 2
       [ (gogoproto.nullable) = false ];
 }
 
-message BatchResponse {}
+message BatchResponse {
+  repeated cosmos.base.abci.v1beta1.Result  results = 1;
+}

x/ante/batch.go

@@ -0,0 +1,86 @@
+package ante
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
+	batchertypes "github.com/axelarnetwork/axelar-core/x/batcher/types"
+)
+
+// messageWrapper implements the Tx interface for a slice of sdk messages
+type messageWrapper struct {
+	messages []sdk.Msg
+}
+
+func (m messageWrapper) ValidateBasic() error {
+	for _, message := range m.messages {
+		if err := message.ValidateBasic(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m messageWrapper) GetMsgs() []sdk.Msg {
+	return m.messages
+}
+
+func (m messageWrapper) Append(msg sdk.Msg) messageWrapper {
+	m.messages = append(m.messages, msg)
+
+	return m
+}
+
+// BatchDecorator runs anteHandler on the inner messages of a batch request
+type BatchDecorator struct {
+	cdc         codec.Codec
+	anteHandler sdk.AnteHandler
+}
+
+// NewBatchDecorator is the constructor for BatchDecorator
+func NewBatchDecorator(cdc codec.Codec, anteHandler sdk.AnteHandler) BatchDecorator {
+	return BatchDecorator{
+		cdc,
+		anteHandler,
+	}
+}
+
+// AnteHandle record qualified refund for the multiSig and vote transactions
+func (b BatchDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
+	msgs := tx.GetMsgs()
+
+	for _, msg := range msgs {
+		switch req := msg.(type) {
+		case *batchertypes.BatchRequest:
+			var messages messageWrapper
+			var err error
+
+			for _, m := range req.Messages {
+				var sdkMsg sdk.Msg
+				if err = b.cdc.UnpackAny(&m, &sdkMsg); err != nil {
+					return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, fmt.Sprintf("unpack failed: %s", err))
+				}
+
+				if !msg.GetSigners()[0].Equals(req.Sender) {
+					return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, fmt.Sprintf("message signer mismatch"))
+				}
+
+				messages = messages.Append(sdkMsg)
+			}
+
+			ctx, err = b.anteHandler(ctx, messages, simulate)
+			if err != nil {
+				return ctx, err
+			}
+		default:
+			continue
+		}
+
+	}
+
+	return next(ctx, tx, simulate)
+}

x/batcher/keeper/msg_server.go

@@ -9,68 +9,34 @@ import (
 	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	"github.com/axelarnetwork/axelar-core/x/ante"
 	"github.com/axelarnetwork/axelar-core/x/batcher/types"
 	"github.com/axelarnetwork/utils/funcs"
 )
 
 var _ types.MsgServiceServer = msgServer{}
 
 type msgServer struct {
-	cdc        codec.Codec
-	router     *baseapp.MsgServiceRouter
-	anteHandle ante.MessageAnteHandler
+	cdc    codec.Codec
+	router *baseapp.MsgServiceRouter
 }
 
-func NewMsgServer(cdc codec.Codec, msgServiceRouter *baseapp.MsgServiceRouter, anteHandle ante.MessageAnteHandler) types.MsgServiceServer {
+func NewMsgServer(cdc codec.Codec, msgServiceRouter *baseapp.MsgServiceRouter) types.MsgServiceServer {
 	return msgServer{
 		cdc,
 		msgServiceRouter,
-		anteHandle,
 	}
 }
 
 func (s msgServer) Batch(c context.Context, req *types.BatchRequest) (*types.BatchResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 
-	processMessage := func(ctx sdk.Context, i int, message *cdctypes.Any) (*sdk.Result, error) {
-		sdkMsg, err := unpackInnerMessage(s.cdc, message)
-		if err != nil {
-			return nil, fmt.Errorf("unpack failed at index %d: %s", i, err)
-		}
-
-		if err = req.ValidateInnerMessage(sdkMsg); err != nil {
-			return nil, fmt.Errorf("message validation failed at index %d: %s", i, err)
-		}
-
-		handler := s.router.Handler(sdkMsg)
-		if handler == nil {
-			return nil, fmt.Errorf("unrecognized message type at index %d: %s", i, sdkMsg)
-		}
-
-		ctx, err = s.anteHandle(ctx, []sdk.Msg{sdkMsg}, false)
-		if err != nil {
-			return nil, fmt.Errorf("antehandler failed for message at index %d: %s", i, err)
-		}
-
-		res, err := handler(ctx, sdkMsg)
-		if err != nil {
-			return nil, fmt.Errorf("execution failed for message at index %d: %s", i, err)
-		}
-
-		return res, nil
-	}
-
-	for i, message := range req.MustSucceedMessages {
-		if _, err := processMessage(ctx, i, &message); err != nil {
-			return nil, err
-		}
-	}
-
+	var results []*sdk.Result
 	var failedMessages []types.FailedMessages_FailedMessage
-	for i, message := range req.CanFailMessages {
+
+	for i, message := range req.Messages {
 		cacheCtx, writeCache := ctx.CacheContext()
-		res, err := processMessage(cacheCtx, i, &message)
+
+		res, err := s.processMessage(cacheCtx, &message)
 		if err != nil {
 			failedMessages = append(failedMessages, types.FailedMessages_FailedMessage{
 				Index: int32(i),
@@ -80,6 +46,8 @@ func (s msgServer) Batch(c context.Context, req *types.BatchRequest) (*types.Bat
 			writeCache()
 			ctx.EventManager().EmitEvents(res.GetEvents())
 		}
+
+		results = append(results, res)
 	}
 
 	if len(failedMessages) > 0 {
@@ -88,7 +56,28 @@ func (s msgServer) Batch(c context.Context, req *types.BatchRequest) (*types.Bat
 		}))
 	}
 
-	return &types.BatchResponse{}, nil
+	return &types.BatchResponse{
+		Results: results,
+	}, nil
+}
+
+func (s msgServer) processMessage(ctx sdk.Context, message *cdctypes.Any) (*sdk.Result, error) {
+	sdkMsg, err := unpackInnerMessage(s.cdc, message)
+	if err != nil {
+		return nil, fmt.Errorf("unpack failed: %s", err)
+	}
+
+	handler := s.router.Handler(sdkMsg)
+	if handler == nil {
+		return nil, fmt.Errorf("unrecognized message type: %s", sdk.MsgTypeURL(sdkMsg))
+	}
+
+	res, err := handler(ctx, sdkMsg)
+	if err != nil {
+		return nil, fmt.Errorf("execution failed: %s", err)
+	}
+
+	return res, nil
 }
 
 func unpackInnerMessage(cdc codec.Codec, any *cdctypes.Any) (sdk.Msg, error) {

x/batcher/module.go

@@ -17,7 +17,6 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 
 	"github.com/axelarnetwork/axelar-core/utils/grpc"
-	"github.com/axelarnetwork/axelar-core/x/ante"
 	"github.com/axelarnetwork/axelar-core/x/batcher/keeper"
 	"github.com/axelarnetwork/axelar-core/x/batcher/types"
 )
@@ -70,17 +69,15 @@ func (AppModuleBasic) GetQueryCmd() *cobra.Command { return nil }
 // AppModule implements module.AppModule
 type AppModule struct {
 	AppModuleBasic
-	cdc        codec.Codec
-	router     *baseapp.MsgServiceRouter
-	anteHandle ante.MessageAnteHandler
+	cdc    codec.Codec
+	router *baseapp.MsgServiceRouter
 }
 
 // NewAppModule creates a new AppModule object
-func NewAppModule(cdc codec.Codec, router *baseapp.MsgServiceRouter, anteHandle ante.MessageAnteHandler) AppModule {
+func NewAppModule(cdc codec.Codec, router *baseapp.MsgServiceRouter) AppModule {
 	return AppModule{
-		cdc:        cdc,
-		router:     router,
-		anteHandle: anteHandle,
+		cdc:    cdc,
+		router: router,
 	}
 }
 
@@ -122,7 +119,7 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 		return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 	}
 
-	types.RegisterMsgServiceServer(grpc.ServerWithSDKErrors{Server: cfg.MsgServer(), Err: types.ErrBatcher, Logger: logger}, keeper.NewMsgServer(am.cdc, am.router, am.anteHandle))
+	types.RegisterMsgServiceServer(grpc.ServerWithSDKErrors{Server: cfg.MsgServer(), Err: types.ErrBatcher, Logger: logger}, keeper.NewMsgServer(am.cdc, am.router))
 }
 
 // BeginBlock executes all state transitions this module requires at the beginning of each new block

x/batcher/types/msg_batch.go

@@ -12,7 +12,7 @@ import (
 )
 
 // NewBatchRequest is the constructor for BatchRequest
-func NewBatchRequest(sender sdk.AccAddress, mustSucceedMessages []sdk.Msg, canFailMessages []sdk.Msg) *BatchRequest {
+func NewBatchRequest(sender sdk.AccAddress, messages []sdk.Msg) *BatchRequest {
 	f := func(msg sdk.Msg) types.Any {
 		messageAny, err := cdctypes.NewAnyWithValue(msg)
 		if err != nil {
@@ -22,9 +22,8 @@ func NewBatchRequest(sender sdk.AccAddress, mustSucceedMessages []sdk.Msg, canFa
 	}
 
 	return &BatchRequest{
-		Sender:              sender,
-		MustSucceedMessages: slices.Map(mustSucceedMessages, f),
-		CanFailMessages:     slices.Map(canFailMessages, f),
+		Sender:   sender,
+		Messages: slices.Map(messages, f),
 	}
 }
 
@@ -44,7 +43,7 @@ func (m BatchRequest) ValidateBasic() error {
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, sdkerrors.Wrap(err, "sender").Error())
 	}
 
-	if len(m.MustSucceedMessages) == 0 && len(m.CanFailMessages) == 0 {
+	if len(m.Messages) == 0 {
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty batch")
 	}