[CORE-696] - Add query endpoint for x/rewards GetRewardShare.

indexer/packages/v4-protos/src/codegen/dydxprotocol/rewards/query.lcd.ts

@@ -1,5 +1,5 @@
 import { LCDClient } from "@osmonauts/lcd";
-import { QueryParamsRequest, QueryParamsResponseSDKType } from "./query";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryRewardShareRequest, QueryRewardShareResponseSDKType } from "./query";
 export class LCDQueryClient {
   req: LCDClient;
 
@@ -10,6 +10,7 @@ export class LCDQueryClient {
   }) {
     this.req = requestClient;
     this.params = this.params.bind(this);
+    this.rewardShare = this.rewardShare.bind(this);
   }
   /* Queries the Params. */
 
@@ -18,5 +19,12 @@ export class LCDQueryClient {
     const endpoint = `dydxprotocol/v4/rewards/params`;
     return await this.req.get<QueryParamsResponseSDKType>(endpoint);
   }
+  /* Queries a reward share by address. */
+
+
+  async rewardShare(params: QueryRewardShareRequest): Promise<QueryRewardShareResponseSDKType> {
+    const endpoint = `dydxprotocol/v4/rewards/shares/${params.address}`;
+    return await this.req.get<QueryRewardShareResponseSDKType>(endpoint);
+  }
 
 }

indexer/packages/v4-protos/src/codegen/dydxprotocol/rewards/query.rpc.Query.ts

@@ -1,19 +1,23 @@
 import { Rpc } from "../../helpers";
 import * as _m0 from "protobufjs/minimal";
 import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
-import { QueryParamsRequest, QueryParamsResponse } from "./query";
+import { QueryParamsRequest, QueryParamsResponse, QueryRewardShareRequest, QueryRewardShareResponse } from "./query";
 /** Query defines the gRPC querier service. */
 
 export interface Query {
   /** Queries the Params. */
   params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Queries a reward share by address. */
+
+  rewardShare(request: QueryRewardShareRequest): Promise<QueryRewardShareResponse>;
 }
 export class QueryClientImpl implements Query {
   private readonly rpc: Rpc;
 
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.params = this.params.bind(this);
+    this.rewardShare = this.rewardShare.bind(this);
   }
 
   params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
@@ -22,13 +26,23 @@ export class QueryClientImpl implements Query {
     return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
   }
 
+  rewardShare(request: QueryRewardShareRequest): Promise<QueryRewardShareResponse> {
+    const data = QueryRewardShareRequest.encode(request).finish();
+    const promise = this.rpc.request("dydxprotocol.rewards.Query", "RewardShare", data);
+    return promise.then(data => QueryRewardShareResponse.decode(new _m0.Reader(data)));
+  }
+
 }
 export const createRpcQueryExtension = (base: QueryClient) => {
   const rpc = createProtobufRpcClient(base);
   const queryService = new QueryClientImpl(rpc);
   return {
     params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
       return queryService.params(request);
+    },
+
+    rewardShare(request: QueryRewardShareRequest): Promise<QueryRewardShareResponse> {
+      return queryService.rewardShare(request);
     }
 
   };

indexer/packages/v4-protos/src/codegen/dydxprotocol/rewards/query.ts

@@ -1,4 +1,5 @@
 import { Params, ParamsSDKType } from "./params";
+import { RewardShare, RewardShareSDKType } from "./reward_share";
 import * as _m0 from "protobufjs/minimal";
 import { DeepPartial } from "../../helpers";
 /** QueryParamsRequest is a request type for the Params RPC method. */
@@ -17,6 +18,26 @@ export interface QueryParamsResponse {
 export interface QueryParamsResponseSDKType {
   params?: ParamsSDKType;
 }
+/** QueryRewardShareRequest is a request type for the RewardShare RPC method. */
+
+export interface QueryRewardShareRequest {
+  address: string;
+}
+/** QueryRewardShareRequest is a request type for the RewardShare RPC method. */
+
+export interface QueryRewardShareRequestSDKType {
+  address: string;
+}
+/** QueryRewardShareResponse is a response type for the RewardsShare RPC method. */
+
+export interface QueryRewardShareResponse {
+  rewardShare?: RewardShare;
+}
+/** QueryRewardShareResponse is a response type for the RewardsShare RPC method. */
+
+export interface QueryRewardShareResponseSDKType {
+  reward_share?: RewardShareSDKType;
+}
 
 function createBaseQueryParamsRequest(): QueryParamsRequest {
   return {};
@@ -95,4 +116,94 @@ export const QueryParamsResponse = {
     return message;
   }
 
+};
+
+function createBaseQueryRewardShareRequest(): QueryRewardShareRequest {
+  return {
+    address: ""
+  };
+}
+
+export const QueryRewardShareRequest = {
+  encode(message: QueryRewardShareRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryRewardShareRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryRewardShareRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryRewardShareRequest>): QueryRewardShareRequest {
+    const message = createBaseQueryRewardShareRequest();
+    message.address = object.address ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryRewardShareResponse(): QueryRewardShareResponse {
+  return {
+    rewardShare: undefined
+  };
+}
+
+export const QueryRewardShareResponse = {
+  encode(message: QueryRewardShareResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.rewardShare !== undefined) {
+      RewardShare.encode(message.rewardShare, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryRewardShareResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryRewardShareResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.rewardShare = RewardShare.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryRewardShareResponse>): QueryRewardShareResponse {
+    const message = createBaseQueryRewardShareResponse();
+    message.rewardShare = object.rewardShare !== undefined && object.rewardShare !== null ? RewardShare.fromPartial(object.rewardShare) : undefined;
+    return message;
+  }
+
 };

proto/dydxprotocol/rewards/query.proto

@@ -1,9 +1,11 @@
 syntax = "proto3";
 package dydxprotocol.rewards;
 
+import "cosmos_proto/cosmos.proto";
 import "gogoproto/gogo.proto";
 import "google/api/annotations.proto";
 import "dydxprotocol/rewards/params.proto";
+import "dydxprotocol/rewards/reward_share.proto";
 
 option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/rewards/types";
 
@@ -13,6 +15,11 @@ service Query {
   rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
     option (google.api.http).get = "/dydxprotocol/v4/rewards/params";
   }
+
+  // Queries a reward share by address.
+  rpc RewardShare(QueryRewardShareRequest) returns (QueryRewardShareResponse) {
+    option (google.api.http).get = "/dydxprotocol/v4/rewards/shares/{address}";
+  }
 }
 
 // QueryParamsRequest is a request type for the Params RPC method.
@@ -22,3 +29,13 @@ message QueryParamsRequest {}
 message QueryParamsResponse {
   Params params = 1 [ (gogoproto.nullable) = false ];
 }
+
+// QueryRewardShareRequest is a request type for the RewardShare RPC method.
+message QueryRewardShareRequest {
+  string address = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
+}
+
+// QueryRewardShareResponse is a response type for the RewardsShare RPC method.
+message QueryRewardShareResponse {
+  RewardShare reward_share = 1 [ (gogoproto.nullable) = false ];
+}

protocol/x/rewards/client/cli/query_reward_share.go

@@ -0,0 +1,40 @@
+package cli
+
+import (
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/dydxprotocol/v4-chain/protocol/x/rewards/types"
+	"github.com/spf13/cobra"
+)
+
+func CmdQueryRewardShare() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "reward-share [address]",
+		Short: "shows the reward share for the specified address",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			argAddress := args[0]
+
+			queryClient := types.NewQueryClient(clientCtx)
+
+			res, err := queryClient.RewardShare(cmd.Context(), &types.QueryRewardShareRequest{
+				Address: argAddress,
+			})
+
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

protocol/x/rewards/client/cli/query_reward_share_test.go

@@ -0,0 +1,34 @@
+package cli_test
+
+import (
+	"fmt"
+	tmcli "github.com/cometbft/cometbft/libs/cli"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/dydxprotocol/v4-chain/protocol/dtypes"
+	"github.com/dydxprotocol/v4-chain/protocol/testutil/constants"
+	"github.com/dydxprotocol/v4-chain/protocol/x/rewards/client/cli"
+	"github.com/dydxprotocol/v4-chain/protocol/x/rewards/types"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestQueryRewardShare(t *testing.T) {
+	net, ctx := setupNetwork(t)
+
+	out, err := clitestutil.ExecTestCLICmd(
+		ctx,
+		cli.CmdQueryRewardShare(),
+		[]string{
+			constants.AliceAccAddress.String(),
+			fmt.Sprintf("--%s=json", tmcli.OutputFlag),
+		},
+	)
+
+	require.NoError(t, err)
+	var resp types.QueryRewardShareResponse
+	require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp))
+	require.Equal(t, types.RewardShare{
+		Address: constants.AliceAccAddress.String(),
+		Weight:  dtypes.NewInt(0),
+	}, resp.RewardShare)
+}

protocol/x/rewards/keeper/grpc_query.go

@@ -19,3 +19,17 @@ func (k Keeper) Params(goCtx context.Context, req *types.QueryParamsRequest) (*t
 
 	return &types.QueryParamsResponse{Params: k.GetParams(ctx)}, nil
 }
+
+func (k Keeper) RewardShare(
+	goCtx context.Context,
+	req *types.QueryRewardShareRequest,
+) (*types.QueryRewardShareResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	return &types.QueryRewardShareResponse{
+		RewardShare: k.GetRewardShare(ctx, req.Address),
+	}, nil
+}

protocol/x/rewards/keeper/grpc_query_test.go

@@ -1,6 +1,7 @@
 package keeper_test
 
 import (
+	"github.com/dydxprotocol/v4-chain/protocol/dtypes"
 	"testing"
 
 	testapp "github.com/dydxprotocol/v4-chain/protocol/testutil/app"
@@ -44,3 +45,47 @@ func TestQueryParams(t *testing.T) {
 		})
 	}
 }
+
+func TestQueryRewardShare(t *testing.T) {
+	tApp := testapp.NewTestAppBuilder(t).Build()
+	ctx := tApp.InitChain()
+	k := tApp.App.RewardsKeeper
+
+	rewardShare := types.RewardShare{
+		Address: TestAddress1,
+		Weight:  dtypes.NewInt(12_345_678),
+	}
+
+	err := k.SetRewardShare(ctx, rewardShare)
+	require.NoError(t, err)
+
+	for name, tc := range map[string]struct {
+		req *types.QueryRewardShareRequest
+		res *types.QueryRewardShareResponse
+		err error
+	}{
+		"Success": {
+			req: &types.QueryRewardShareRequest{
+				Address: rewardShare.Address,
+			},
+			res: &types.QueryRewardShareResponse{
+				RewardShare: rewardShare,
+			},
+		},
+		"Nil": {
+			req: nil,
+			res: nil,
+			err: status.Error(codes.InvalidArgument, "invalid request"),
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			res, err := k.RewardShare(ctx, tc.req)
+			if tc.err != nil {
+				require.ErrorIs(t, err, tc.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.res, res)
+			}
+		})
+	}
+}