@xpla/xplajs 1.7.0-beta.0

package/src/xpla/reward/v1beta1/genesis.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+const reward_1 = require("./reward");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseGenesisState() {
+    return {
+        params: reward_1.Params.fromPartial({})
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/xpla.reward.v1beta1.GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || reward_1.Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || reward_1.Params.isAmino(o.params));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            reward_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = reward_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? reward_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = reward_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? reward_1.Params.toAmino(message.params) : reward_1.Params.toAmino(reward_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.reward.v1beta1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);

package/src/xpla/reward/v1beta1/genesis.ts

@@ -0,0 +1,92 @@
+import { Params, ParamsAmino } from "./reward";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** GenesisState defines the reward module's genesis state. */
+export interface GenesisState {
+  /** params defines all the paramaters of the module. */
+  params: Params;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/xpla.reward.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the reward module's genesis state. */
+export interface GenesisStateAmino {
+  /** params defines all the paramaters of the module. */
+  params: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "/xpla.reward.v1beta1.GenesisState";
+  value: GenesisStateAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: Params.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/xpla.reward.v1beta1.GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Params.is(o.params));
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Params.isAmino(o.params));
+  },
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/xpla.reward.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);

package/src/xpla/reward/v1beta1/query.d.ts

@@ -0,0 +1,136 @@
+import { Params, ParamsAmino } from "./reward";
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/xpla.reward.v1beta1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "/xpla.reward.v1beta1.QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/xpla.reward.v1beta1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseAmino {
+    /** params defines the parameters of the module. */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "/xpla.reward.v1beta1.QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/**
+ * QueryPoolRequest is the request type for the Query/Pool RPC
+ * method.
+ */
+export interface QueryPoolRequest {
+}
+export interface QueryPoolRequestProtoMsg {
+    typeUrl: "/xpla.reward.v1beta1.QueryPoolRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryPoolRequest is the request type for the Query/Pool RPC
+ * method.
+ */
+export interface QueryPoolRequestAmino {
+}
+export interface QueryPoolRequestAminoMsg {
+    type: "/xpla.reward.v1beta1.QueryPoolRequest";
+    value: QueryPoolRequestAmino;
+}
+/**
+ * QueryPoolResponse is the response type for the Query/Pool
+ * RPC method.
+ */
+export interface QueryPoolResponse {
+    /** pool defines reward pool's coins. */
+    pool: Coin[];
+}
+export interface QueryPoolResponseProtoMsg {
+    typeUrl: "/xpla.reward.v1beta1.QueryPoolResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryPoolResponse is the response type for the Query/Pool
+ * RPC method.
+ */
+export interface QueryPoolResponseAmino {
+    /** pool defines reward pool's coins. */
+    pool: CoinAmino[];
+}
+export interface QueryPoolResponseAminoMsg {
+    type: "/xpla.reward.v1beta1.QueryPoolResponse";
+    value: QueryPoolResponseAmino;
+}
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryParamsRequest;
+    isAmino(o: any): o is QueryParamsRequestAmino;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryParamsResponse;
+    isAmino(o: any): o is QueryParamsResponseAmino;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};
+export declare const QueryPoolRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryPoolRequest;
+    isAmino(o: any): o is QueryPoolRequestAmino;
+    encode(_: QueryPoolRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryPoolRequest;
+    fromPartial(_: DeepPartial<QueryPoolRequest>): QueryPoolRequest;
+    fromAmino(_: QueryPoolRequestAmino): QueryPoolRequest;
+    toAmino(_: QueryPoolRequest): QueryPoolRequestAmino;
+    fromAminoMsg(object: QueryPoolRequestAminoMsg): QueryPoolRequest;
+    fromProtoMsg(message: QueryPoolRequestProtoMsg): QueryPoolRequest;
+    toProto(message: QueryPoolRequest): Uint8Array;
+    toProtoMsg(message: QueryPoolRequest): QueryPoolRequestProtoMsg;
+};
+export declare const QueryPoolResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryPoolResponse;
+    isAmino(o: any): o is QueryPoolResponseAmino;
+    encode(message: QueryPoolResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryPoolResponse;
+    fromPartial(object: DeepPartial<QueryPoolResponse>): QueryPoolResponse;
+    fromAmino(object: QueryPoolResponseAmino): QueryPoolResponse;
+    toAmino(message: QueryPoolResponse): QueryPoolResponseAmino;
+    fromAminoMsg(object: QueryPoolResponseAminoMsg): QueryPoolResponse;
+    fromProtoMsg(message: QueryPoolResponseProtoMsg): QueryPoolResponse;
+    toProto(message: QueryPoolResponse): Uint8Array;
+    toProtoMsg(message: QueryPoolResponse): QueryPoolResponseProtoMsg;
+};

package/src/xpla/reward/v1beta1/query.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryPoolResponse = exports.QueryPoolRequest = exports.QueryParamsResponse = exports.QueryParamsRequest = void 0;
+const reward_1 = require("./reward");
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseQueryParamsRequest() {
+    return {};
+}
+exports.QueryParamsRequest = {
+    typeUrl: "/xpla.reward.v1beta1.QueryParamsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.reward.v1beta1.QueryParamsRequest",
+            value: exports.QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryParamsRequest.typeUrl, exports.QueryParamsRequest);
+function createBaseQueryParamsResponse() {
+    return {
+        params: reward_1.Params.fromPartial({})
+    };
+}
+exports.QueryParamsResponse = {
+    typeUrl: "/xpla.reward.v1beta1.QueryParamsResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryParamsResponse.typeUrl || reward_1.Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryParamsResponse.typeUrl || reward_1.Params.isAmino(o.params));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            reward_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = reward_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? reward_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = reward_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? reward_1.Params.toAmino(message.params) : reward_1.Params.toAmino(reward_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.reward.v1beta1.QueryParamsResponse",
+            value: exports.QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryParamsResponse.typeUrl, exports.QueryParamsResponse);
+function createBaseQueryPoolRequest() {
+    return {};
+}
+exports.QueryPoolRequest = {
+    typeUrl: "/xpla.reward.v1beta1.QueryPoolRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryPoolRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryPoolRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPoolRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryPoolRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryPoolRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryPoolRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryPoolRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryPoolRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.reward.v1beta1.QueryPoolRequest",
+            value: exports.QueryPoolRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryPoolRequest.typeUrl, exports.QueryPoolRequest);
+function createBaseQueryPoolResponse() {
+    return {
+        pool: []
+    };
+}
+exports.QueryPoolResponse = {
+    typeUrl: "/xpla.reward.v1beta1.QueryPoolResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryPoolResponse.typeUrl || Array.isArray(o.pool) && (!o.pool.length || coin_1.Coin.is(o.pool[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryPoolResponse.typeUrl || Array.isArray(o.pool) && (!o.pool.length || coin_1.Coin.isAmino(o.pool[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.pool) {
+            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPoolResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pool.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPoolResponse();
+        message.pool = object.pool?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPoolResponse();
+        message.pool = object.pool?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.pool) {
+            obj.pool = message.pool.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.pool = message.pool;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryPoolResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryPoolResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryPoolResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.reward.v1beta1.QueryPoolResponse",
+            value: exports.QueryPoolResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryPoolResponse.typeUrl, exports.QueryPoolResponse);

package/src/xpla/reward/v1beta1/query.lcd.ts

@@ -0,0 +1,22 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryPoolRequest, QueryPoolResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* Params queries params of the reward module. */
+  params = async (_params: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const endpoint = `xpla/reward/v1beta1/params`;
+    return await this.req.get<QueryParamsResponse>(endpoint);
+  };
+  /* Pool queries the reward module pool coins. */
+  pool = async (_params: QueryPoolRequest = {}): Promise<QueryPoolResponse> => {
+    const endpoint = `xpla/reward/v1beta1/pool`;
+    return await this.req.get<QueryPoolResponse>(endpoint);
+  };
+}

package/src/xpla/reward/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,41 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryPoolRequest, QueryPoolResponse } from "./query";
+/** Query defines the gRPC querier service for reward module. */
+export interface Query {
+  /** Params queries params of the reward module. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Pool queries the reward module pool coins. */
+  pool(request?: QueryPoolRequest): Promise<QueryPoolResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* Params queries params of the reward module. */
+  params = async (request: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("xpla.reward.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  };
+  /* Pool queries the reward module pool coins. */
+  pool = async (request: QueryPoolRequest = {}): Promise<QueryPoolResponse> => {
+    const data = QueryPoolRequest.encode(request).finish();
+    const promise = this.rpc.request("xpla.reward.v1beta1.Query", "Pool", data);
+    return promise.then(data => QueryPoolResponse.decode(new BinaryReader(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);
+    },
+    pool(request?: QueryPoolRequest): Promise<QueryPoolResponse> {
+      return queryService.pool(request);
+    }
+  };
+};

package/src/xpla/reward/v1beta1/query.rpc.func.d.ts

@@ -0,0 +1,4 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { QueryParamsRequest, QueryParamsResponse, QueryPoolRequest, QueryPoolResponse } from "./query";
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;
+export declare const createGetPool: (clientResolver?: RpcResolver) => (request: QueryPoolRequest) => Promise<QueryPoolResponse>;

package/src/xpla/reward/v1beta1/query.rpc.func.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetPool = exports.createGetParams = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryParamsRequest.encode,
+    decode: query_1.QueryParamsResponse.decode,
+    service: "xpla.reward.v1beta1.Query",
+    method: "Params",
+    clientResolver
+});
+exports.createGetParams = createGetParams;
+const createGetPool = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryPoolRequest.encode,
+    decode: query_1.QueryPoolResponse.decode,
+    service: "xpla.reward.v1beta1.Query",
+    method: "Pool",
+    clientResolver
+});
+exports.createGetPool = createGetPool;

package/src/xpla/reward/v1beta1/query.rpc.func.ts

@@ -0,0 +1,16 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { QueryParamsRequest, QueryParamsResponse, QueryPoolRequest, QueryPoolResponse } from "./query";
+export const createGetParams = (clientResolver?: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+  encode: QueryParamsRequest.encode,
+  decode: QueryParamsResponse.decode,
+  service: "xpla.reward.v1beta1.Query",
+  method: "Params",
+  clientResolver
+});
+export const createGetPool = (clientResolver?: RpcResolver) => buildQuery<QueryPoolRequest, QueryPoolResponse>({
+  encode: QueryPoolRequest.encode,
+  decode: QueryPoolResponse.decode,
+  service: "xpla.reward.v1beta1.Query",
+  method: "Pool",
+  clientResolver
+});