[TRA-111] add vault query

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

@@ -1,5 +1,5 @@
 import { LCDClient } from "@osmonauts/lcd";
-import { QueryParamsRequest, QueryParamsResponseSDKType } from "./query";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryVaultRequest, QueryVaultResponseSDKType } from "./query";
 export class LCDQueryClient {
   req: LCDClient;
 
@@ -10,6 +10,7 @@ export class LCDQueryClient {
   }) {
     this.req = requestClient;
     this.params = this.params.bind(this);
+    this.vault = this.vault.bind(this);
   }
   /* Queries the Params. */
 
@@ -18,5 +19,12 @@ export class LCDQueryClient {
     const endpoint = `dydxprotocol/v4/vault/params`;
     return await this.req.get<QueryParamsResponseSDKType>(endpoint);
   }
+  /* Queries a Vault by type and number. */
+
+
+  async vault(params: QueryVaultRequest): Promise<QueryVaultResponseSDKType> {
+    const endpoint = `dydxprotocol/v4/vault/vaults/${params.type}/${params.number}`;
+    return await this.req.get<QueryVaultResponseSDKType>(endpoint);
+  }
 
 }

indexer/packages/v4-protos/src/codegen/dydxprotocol/vault/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, QueryVaultRequest, QueryVaultResponse } from "./query";
 /** Query defines the gRPC querier service. */
 
 export interface Query {
   /** Queries the Params. */
   params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Queries a Vault by type and number. */
+
+  vault(request: QueryVaultRequest): Promise<QueryVaultResponse>;
 }
 export class QueryClientImpl implements Query {
   private readonly rpc: Rpc;
 
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.params = this.params.bind(this);
+    this.vault = this.vault.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)));
   }
 
+  vault(request: QueryVaultRequest): Promise<QueryVaultResponse> {
+    const data = QueryVaultRequest.encode(request).finish();
+    const promise = this.rpc.request("dydxprotocol.vault.Query", "Vault", data);
+    return promise.then(data => QueryVaultResponse.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);
+    },
+
+    vault(request: QueryVaultRequest): Promise<QueryVaultResponse> {
+      return queryService.vault(request);
     }
 
   };

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

@@ -1,6 +1,8 @@
+import { VaultType, VaultTypeSDKType, VaultId, VaultIdSDKType } from "./vault";
 import { Params, ParamsSDKType } from "./params";
+import { SubaccountId, SubaccountIdSDKType } from "../subaccounts/subaccount";
 import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../helpers";
+import { DeepPartial, Long } from "../../helpers";
 /** QueryParamsRequest is a request type for the Params RPC method. */
 
 export interface QueryParamsRequest {}
@@ -17,6 +19,36 @@ export interface QueryParamsResponse {
 export interface QueryParamsResponseSDKType {
   params?: ParamsSDKType;
 }
+/** QueryVaultRequest is a request type for the Vault RPC method. */
+
+export interface QueryVaultRequest {
+  type: VaultType;
+  number: number;
+}
+/** QueryVaultRequest is a request type for the Vault RPC method. */
+
+export interface QueryVaultRequestSDKType {
+  type: VaultTypeSDKType;
+  number: number;
+}
+/** QueryVaultResponse is a response type for the Vault RPC method. */
+
+export interface QueryVaultResponse {
+  vaultId?: VaultId;
+  subaccountId?: SubaccountId;
+  equity: Long;
+  inventory: Long;
+  totalShares: Long;
+}
+/** QueryVaultResponse is a response type for the Vault RPC method. */
+
+export interface QueryVaultResponseSDKType {
+  vault_id?: VaultIdSDKType;
+  subaccount_id?: SubaccountIdSDKType;
+  equity: Long;
+  inventory: Long;
+  total_shares: Long;
+}
 
 function createBaseQueryParamsRequest(): QueryParamsRequest {
   return {};
@@ -95,4 +127,144 @@ export const QueryParamsResponse = {
     return message;
   }
 
+};
+
+function createBaseQueryVaultRequest(): QueryVaultRequest {
+  return {
+    type: 0,
+    number: 0
+  };
+}
+
+export const QueryVaultRequest = {
+  encode(message: QueryVaultRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+
+    if (message.number !== 0) {
+      writer.uint32(16).uint32(message.number);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryVaultRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVaultRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.type = (reader.int32() as any);
+          break;
+
+        case 2:
+          message.number = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryVaultRequest>): QueryVaultRequest {
+    const message = createBaseQueryVaultRequest();
+    message.type = object.type ?? 0;
+    message.number = object.number ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseQueryVaultResponse(): QueryVaultResponse {
+  return {
+    vaultId: undefined,
+    subaccountId: undefined,
+    equity: Long.UZERO,
+    inventory: Long.UZERO,
+    totalShares: Long.UZERO
+  };
+}
+
+export const QueryVaultResponse = {
+  encode(message: QueryVaultResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.vaultId !== undefined) {
+      VaultId.encode(message.vaultId, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.subaccountId !== undefined) {
+      SubaccountId.encode(message.subaccountId, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (!message.equity.isZero()) {
+      writer.uint32(24).uint64(message.equity);
+    }
+
+    if (!message.inventory.isZero()) {
+      writer.uint32(32).uint64(message.inventory);
+    }
+
+    if (!message.totalShares.isZero()) {
+      writer.uint32(40).uint64(message.totalShares);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryVaultResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVaultResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.vaultId = VaultId.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.subaccountId = SubaccountId.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.equity = (reader.uint64() as Long);
+          break;
+
+        case 4:
+          message.inventory = (reader.uint64() as Long);
+          break;
+
+        case 5:
+          message.totalShares = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryVaultResponse>): QueryVaultResponse {
+    const message = createBaseQueryVaultResponse();
+    message.vaultId = object.vaultId !== undefined && object.vaultId !== null ? VaultId.fromPartial(object.vaultId) : undefined;
+    message.subaccountId = object.subaccountId !== undefined && object.subaccountId !== null ? SubaccountId.fromPartial(object.subaccountId) : undefined;
+    message.equity = object.equity !== undefined && object.equity !== null ? Long.fromValue(object.equity) : Long.UZERO;
+    message.inventory = object.inventory !== undefined && object.inventory !== null ? Long.fromValue(object.inventory) : Long.UZERO;
+    message.totalShares = object.totalShares !== undefined && object.totalShares !== null ? Long.fromValue(object.totalShares) : Long.UZERO;
+    return message;
+  }
+
 };

proto/dydxprotocol/vault/query.proto

@@ -3,7 +3,9 @@ package dydxprotocol.vault;
 
 import "gogoproto/gogo.proto";
 import "google/api/annotations.proto";
+import "dydxprotocol/subaccounts/subaccount.proto";
 import "dydxprotocol/vault/params.proto";
+import "dydxprotocol/vault/vault.proto";
 
 option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/vault/types";
 
@@ -13,6 +15,11 @@ service Query {
   rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
     option (google.api.http).get = "/dydxprotocol/v4/vault/params";
   }
+  // Queries a Vault by type and number.
+  rpc Vault(QueryVaultRequest) returns (QueryVaultResponse) {
+    option (google.api.http).get =
+        "/dydxprotocol/v4/vault/vaults/{type}/{number}";
+  }
 }
 
 // QueryParamsRequest is a request type for the Params RPC method.
@@ -22,3 +29,19 @@ message QueryParamsRequest {}
 message QueryParamsResponse {
   Params params = 1 [ (gogoproto.nullable) = false ];
 }
+
+// QueryVaultRequest is a request type for the Vault RPC method.
+message QueryVaultRequest {
+  VaultType type = 1;
+  uint32 number = 2;
+}
+
+// QueryVaultResponse is a response type for the Vault RPC method.
+message QueryVaultResponse {
+  VaultId vault_id = 1 [ (gogoproto.nullable) = false ];
+  dydxprotocol.subaccounts.SubaccountId subaccount_id = 2
+      [ (gogoproto.nullable) = false ];
+  uint64 equity = 3;
+  uint64 inventory = 4;
+  uint64 total_shares = 5;
+}

protocol/x/vault/client/cli/query.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"context"
 	"fmt"
+	"strconv"
 
 	"github.com/spf13/cobra"
 
@@ -23,6 +24,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
 	}
 
 	cmd.AddCommand(CmdQueryParams())
+	cmd.AddCommand(CmdQueryVault())
 
 	return cmd
 }
@@ -49,3 +51,48 @@ func CmdQueryParams() *cobra.Command {
 
 	return cmd
 }
+
+func CmdQueryVault() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-vault [type] [number]",
+		Short: "get a vault by its type and number",
+		Long:  "get a vault by its type and number. Current support types are: clob.",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			queryClient := types.NewQueryClient(clientCtx)
+
+			// Parse vault type.
+			rawType := args[0]
+			var vaultType types.VaultType
+			switch rawType {
+			case "clob":
+				vaultType = types.VaultType_VAULT_TYPE_CLOB
+			default:
+				return fmt.Errorf("invalid vault type %s", rawType)
+			}
+
+			// Parse vault number.
+			vaultNumber, err := strconv.ParseUint(args[1], 10, 32)
+			if err != nil {
+				return err
+			}
+
+			res, err := queryClient.Vault(
+				context.Background(),
+				&types.QueryVaultRequest{
+					Type:   vaultType,
+					Number: uint32(vaultNumber),
+				},
+			)
+			if err != nil {
+				return err
+			}
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}