Implement Protobuf Msg Services

# Summary 

Implement ADR 031: Protobuf Msg Services as documented in #7458 and #7122 .

# Roadmap

- [x] Base implementation
  - [x] #7518 Refactor `RegisterQueryService` -> `RegisterServices` and create `Configurator` type
  - [x] #7519 Implement `ServiceMsg`, `MsgRequest`, and router for a `Msg` `service` in `testdata`. Router should also handle `EventManager` stuff
  - [x] #7520 Add buf linter exception for `service` request type names (we want to use the existing `Msg` types without the `Request` suffix)
  - [x] #7520 Create `WrapServiceResult(proto.Message, error) (*sdk.Result, error)` func which takes a service method result and error and wraps it in an `*sdk.Result` or `error` for use in refactored module handlers
  - [x] Add `MsgServer` to `Configurator` and wire up modules
- [x] Modules - only modules which define `Msg`s. *See Implementation Notes below*
  - [x] #7520 x/bank
  - [x] #7533 x/crisis (@atheeshp )
  - [x] #7524 x/distribution (@atheeshp )
  - [x] x/evidence (@amaurymartiny)
  - [x] #7533 x/gov (@atheeshp )
  - [x] x/ibc
  - [x] #7557 x/slashing (@blushi)
  - [x] #7556 x/staking (@atheeshp )
  - [x] #7551 x/vesting (@clevinson)

# Implementation Notes

## Modules

1. Add a `service` definition called `Msg` in each module's tx.proto file. Re-use the existing `Msg` types for the request type and add an unique `Response` type for each `rpc` method.
2. Refactor all handler functions into an implementation of the generated `MsgServer` interface

```go
// x/bank/handler.go

// Handle MsgSend.
func handleMsgSend(ctx sdk.Context, k keeper.Keeper, msg *types.MsgSend) (*sdk.Result, error) {
    ...
    return &sdk.Result{Events: ctx.EventManager().ABCIEvents()}, nil
}
```

becomes:

```go
// x/bank/keeper/msg_server.go

type msgServer struct {
    Keeper
}

func (k msgServer) Send(goCtx context.Context, msg *types.MsgSend) (*types.MsgSendResponse, error) {
    ctx := sdk.UnwrapSDKContext(goCtx)
    ...
    return &types.MsgSendResponse{}, nil
}
```

3. Refactor the root handler to just call those `MsgService` methods. Ex:

```go
func NewHandler(k keeper.Keeper) sdk.Handler {
	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
		ctx = ctx.WithEventManager(sdk.NewEventManager())
                
                msgServer := keeper.NewMsgServerImpl(k)

		switch msg := msg.(type) {
		case *types.MsgSend:
			res, err := msgServer.Send(sdk.WrapSDKContext(ctx), msg)
                        return sdk.WrapServiceResult(ctx, res, err)

		case *types.MsgMultiSend:
			res, err := msgServer.MultiSend(sdk.WrapSDKContext(ctx), msg)
                        return sdk.WrapServiceResult(ctx, res, err)

		default:
			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized bank message type: %T", msg)
		}
	}
}
```

4. Wire up `MsgServer` in `RegisterServices` (if possible - that functionality is currently not ready, so skip this step for now)


Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Implement Protobuf Msg Services #7540

Summary

Roadmap

Implementation Notes

Modules

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development