feat(batcher): batch message request

app/app.go

@@ -105,6 +105,7 @@ import (
 	axelarnetKeeper "github.com/axelarnetwork/axelar-core/x/axelarnet/keeper"
 	axelarnetTypes "github.com/axelarnetwork/axelar-core/x/axelarnet/types"
 	axelarbankkeeper "github.com/axelarnetwork/axelar-core/x/bank/keeper"
+	"github.com/axelarnetwork/axelar-core/x/batcher"
 	"github.com/axelarnetwork/axelar-core/x/evm"
 	evmKeeper "github.com/axelarnetwork/axelar-core/x/evm/keeper"
 	evmTypes "github.com/axelarnetwork/axelar-core/x/evm/types"
@@ -607,7 +608,9 @@ func initAppModules(keepers *KeeperCache, bApp *bam.BaseApp, encodingConfig axel
 			bApp.Router(),
 		),
 		permission.NewAppModule(*getKeeper[permissionKeeper.Keeper](keepers)),
+		batcher.NewAppModule(bApp.MsgServiceRouter(), initMessageAnteDecorators(encodingConfig, keepers)),
 	)
+
 	return appModules
 }
 

proto/axelar/batcher/v1beta1/events.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+package axelar.batcher.v1beta1;
+
+option go_package = "github.com/axelarnetwork/axelar-core/x/batcher/types";
+option (gogoproto.messagename_all) = true;
+
+import "gogoproto/gogo.proto";
+
+message FailedMessages {
+  message FailedMessage {
+    int32 index = 1;
+    string error = 2;
+  }
+  repeated FailedMessage messages = 1 [ (gogoproto.nullable) = false ];
+}

proto/axelar/batcher/v1beta1/genesis.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package axelar.batcher.v1beta1;
+
+option go_package = "github.com/axelarnetwork/axelar-core/x/batcher/types";
+
+import "gogoproto/gogo.proto";
+
+option (gogoproto.goproto_getters_all) = false;
+
+// GenesisState represents the genesis state
+message GenesisState {}

proto/axelar/batcher/v1beta1/service.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+package axelar.batcher.v1beta1;
+
+option go_package = "github.com/axelarnetwork/axelar-core/x/batcher/types";
+
+import "gogoproto/gogo.proto";
+import "google/api/annotations.proto";
+import "axelar/batcher/v1beta1/tx.proto";
+
+option (gogoproto.goproto_registration) = true;
+
+// Msg defines the nexus Msg service.
+service MsgService {
+  rpc Batch(BatchRequest) returns (BatchResponse) {
+    option (google.api.http) = {
+      post : "/axelar/batcher/batch"
+      body : "*"
+    };
+  }
+}

proto/axelar/batcher/v1beta1/tx.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+package axelar.batcher.v1beta1;
+
+import "google/protobuf/any.proto";
+import "gogoproto/gogo.proto";
+
+import "axelar/permission/exported/v1beta1/types.proto";
+
+option go_package = "github.com/axelarnetwork/axelar-core/x/batcher/types";
+
+message BatchRequest {
+  option (permission.exported.v1beta1.permission_role) = ROLE_UNRESTRICTED;
+
+  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
+      [ (gogoproto.nullable) = false ];
+}
+
+message BatchResponse {}

third_party/proto/ibc/applications/transfer/v1/query.proto

@@ -11,24 +11,24 @@ option go_package = "github.com/cosmos/ibc-go/v4/modules/apps/transfer/types";
 
 // Query provides defines the gRPC querier service.
 service Query {
-  // DenomTrace queries a denomination trace information.
-  rpc DenomTrace(QueryDenomTraceRequest) returns (QueryDenomTraceResponse) {
-    option (google.api.http).get = "/ibc/apps/transfer/v1/denom_traces/{hash}";
-  }
-
   // DenomTraces queries all denomination traces.
   rpc DenomTraces(QueryDenomTracesRequest) returns (QueryDenomTracesResponse) {
     option (google.api.http).get = "/ibc/apps/transfer/v1/denom_traces";
   }
 
+  // DenomTrace queries a denomination trace information.
+  rpc DenomTrace(QueryDenomTraceRequest) returns (QueryDenomTraceResponse) {
+    option (google.api.http).get = "/ibc/apps/transfer/v1/denom_traces/{hash=**}";
+  }
+
   // Params queries all parameters of the ibc-transfer module.
   rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
     option (google.api.http).get = "/ibc/apps/transfer/v1/params";
   }
 
   // DenomHash queries a denomination hash information.
   rpc DenomHash(QueryDenomHashRequest) returns (QueryDenomHashResponse) {
-    option (google.api.http).get = "/ibc/apps/transfer/v1/denom_hashes/{trace}";
+    option (google.api.http).get = "/ibc/apps/transfer/v1/denom_hashes/{trace=**}";
   }
 
   // EscrowAddress returns the escrow address for a particular port and channel id.

x/batcher/keeper/msg_server.go

@@ -0,0 +1,80 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+	"github.com/axelarnetwork/axelar-core/x/ante"
+	"github.com/axelarnetwork/axelar-core/x/batcher/types"
+	"github.com/axelarnetwork/utils/funcs"
+	baseapp "github.com/cosmos/cosmos-sdk/baseapp"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var _ types.MsgServiceServer = msgServer{}
+
+type msgServer struct {
+	router     *baseapp.MsgServiceRouter
+	anteHandle ante.MessageAnteHandler
+}
+
+func NewMsgServer(msgServiceRouter *baseapp.MsgServiceRouter, anteHandle ante.MessageAnteHandler) types.MsgServiceServer {
+	return msgServer{
+		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 := message.GetCachedValue().(sdk.Msg)
+
+		handler := s.router.Handler(sdkMsg)
+		if handler == nil {
+			return nil, fmt.Errorf("unrecognized message type at index %d: %T", 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 failedMsgs []types.FailedMessages_FailedMessage
+	for i, message := range req.CanFailMessages {
+		cacheCtx, writeCache := ctx.CacheContext()
+		res, err := processMessage(cacheCtx, i, &message)
+		if err != nil {
+			failedMsgs = append(failedMsgs, types.FailedMessages_FailedMessage{
+				Index: int32(i),
+				Error: err.Error(),
+			})
+		} else {
+			writeCache()
+			ctx.EventManager().EmitEvents(res.GetEvents())
+		}
+	}
+
+	if len(failedMsgs) > 0 {
+		funcs.MustNoErr(ctx.EventManager().EmitTypedEvent(&types.FailedMessages{
+			Messages: failedMsgs,
+		}))
+	}
+
+	return &types.BatchResponse{}, nil
+}