@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/params/v1beta1/params.ts

@@ -0,0 +1,166 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+
+export interface ParameterChangeProposal {
+  title: string;
+  description: string;
+  changes: ParamChange[];
+}
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+
+export interface ParameterChangeProposalSDKType {
+  title: string;
+  description: string;
+  changes: ParamChangeSDKType[];
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+
+export interface ParamChange {
+  subspace: string;
+  key: string;
+  value: string;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+
+export interface ParamChangeSDKType {
+  subspace: string;
+  key: string;
+  value: string;
+}
+
+function createBaseParameterChangeProposal(): ParameterChangeProposal {
+  return {
+    title: "",
+    description: "",
+    changes: []
+  };
+}
+
+export const ParameterChangeProposal = {
+  encode(message: ParameterChangeProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.title !== "") {
+      writer.uint32(10).string(message.title);
+    }
+
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+
+    for (const v of message.changes) {
+      ParamChange.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ParameterChangeProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParameterChangeProposal();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.title = reader.string();
+          break;
+
+        case 2:
+          message.description = reader.string();
+          break;
+
+        case 3:
+          message.changes.push(ParamChange.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ParameterChangeProposal>): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    message.title = object.title ?? "";
+    message.description = object.description ?? "";
+    message.changes = object.changes?.map(e => ParamChange.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseParamChange(): ParamChange {
+  return {
+    subspace: "",
+    key: "",
+    value: ""
+  };
+}
+
+export const ParamChange = {
+  encode(message: ParamChange, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+
+    if (message.key !== "") {
+      writer.uint32(18).string(message.key);
+    }
+
+    if (message.value !== "") {
+      writer.uint32(26).string(message.value);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ParamChange {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParamChange();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+
+        case 2:
+          message.key = reader.string();
+          break;
+
+        case 3:
+          message.value = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ParamChange>): ParamChange {
+    const message = createBaseParamChange();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+
+};

package/src/codegen/cosmos/params/v1beta1/query.lcd.ts

@@ -0,0 +1,45 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QuerySubspacesRequest, QuerySubspacesResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+  /* Params queries a specific parameter of a module, given its subspace and
+   key. */
+
+
+  async params(params: QueryParamsRequest): Promise<QueryParamsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.subspace !== "undefined") {
+      options.params.subspace = params.subspace;
+    }
+
+    if (typeof params?.key !== "undefined") {
+      options.params.key = params.key;
+    }
+
+    const endpoint = `cosmos/params/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint, options);
+  }
+  /* Subspaces queries for all registered subspaces and all keys for a subspace.
+  
+   Since: cosmos-sdk 0.46 */
+
+
+  async subspaces(_params: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponseSDKType> {
+    const endpoint = `cosmos/params/v1beta1/subspaces`;
+    return await this.req.get<QuerySubspacesResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/cosmos/params/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,56 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QuerySubspacesRequest, QuerySubspacesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /**
+   * Params queries a specific parameter of a module, given its subspace and
+   * key.
+   */
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /**
+   * Subspaces queries for all registered subspaces and all keys for a subspace.
+   * 
+   * Since: cosmos-sdk 0.46
+   */
+
+  subspaces(request?: QuerySubspacesRequest): Promise<QuerySubspacesResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  subspaces(request: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponse> {
+    const data = QuerySubspacesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Subspaces", data);
+    return promise.then(data => QuerySubspacesResponse.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);
+    },
+
+    subspaces(request?: QuerySubspacesRequest): Promise<QuerySubspacesResponse> {
+      return queryService.subspaces(request);
+    }
+
+  };
+};

package/src/codegen/cosmos/params/v1beta1/query.ts

@@ -0,0 +1,321 @@
+import { ParamChange, ParamChangeSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** QueryParamsRequest is request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequest {
+  /** subspace defines the module to query the parameter for. */
+  subspace: string;
+  /** key defines the key of the parameter in the subspace. */
+
+  key: string;
+}
+/** QueryParamsRequest is request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequestSDKType {
+  subspace: string;
+  key: string;
+}
+/** QueryParamsResponse is response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponse {
+  /** param defines the queried parameter. */
+  param?: ParamChange;
+}
+/** QueryParamsResponse is response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponseSDKType {
+  param?: ParamChangeSDKType;
+}
+/**
+ * QuerySubspacesRequest defines a request type for querying for all registered
+ * subspaces and all keys for a subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface QuerySubspacesRequest {}
+/**
+ * QuerySubspacesRequest defines a request type for querying for all registered
+ * subspaces and all keys for a subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface QuerySubspacesRequestSDKType {}
+/**
+ * QuerySubspacesResponse defines the response types for querying for all
+ * registered subspaces and all keys for a subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface QuerySubspacesResponse {
+  subspaces: Subspace[];
+}
+/**
+ * QuerySubspacesResponse defines the response types for querying for all
+ * registered subspaces and all keys for a subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface QuerySubspacesResponseSDKType {
+  subspaces: SubspaceSDKType[];
+}
+/**
+ * Subspace defines a parameter subspace name and all the keys that exist for
+ * the subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface Subspace {
+  subspace: string;
+  keys: string[];
+}
+/**
+ * Subspace defines a parameter subspace name and all the keys that exist for
+ * the subspace.
+ * 
+ * Since: cosmos-sdk 0.46
+ */
+
+export interface SubspaceSDKType {
+  subspace: string;
+  keys: string[];
+}
+
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {
+    subspace: "",
+    key: ""
+  };
+}
+
+export const QueryParamsRequest = {
+  encode(message: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+
+    if (message.key !== "") {
+      writer.uint32(18).string(message.key);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+
+        case 2:
+          message.key = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    param: undefined
+  };
+}
+
+export const QueryParamsResponse = {
+  encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.param !== undefined) {
+      ParamChange.encode(message.param, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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.param = ParamChange.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.param = object.param !== undefined && object.param !== null ? ParamChange.fromPartial(object.param) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQuerySubspacesRequest(): QuerySubspacesRequest {
+  return {};
+}
+
+export const QuerySubspacesRequest = {
+  encode(_: QuerySubspacesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySubspacesRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySubspacesRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QuerySubspacesRequest>): QuerySubspacesRequest {
+    const message = createBaseQuerySubspacesRequest();
+    return message;
+  }
+
+};
+
+function createBaseQuerySubspacesResponse(): QuerySubspacesResponse {
+  return {
+    subspaces: []
+  };
+}
+
+export const QuerySubspacesResponse = {
+  encode(message: QuerySubspacesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.subspaces) {
+      Subspace.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySubspacesResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySubspacesResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subspaces.push(Subspace.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QuerySubspacesResponse>): QuerySubspacesResponse {
+    const message = createBaseQuerySubspacesResponse();
+    message.subspaces = object.subspaces?.map(e => Subspace.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseSubspace(): Subspace {
+  return {
+    subspace: "",
+    keys: []
+  };
+}
+
+export const Subspace = {
+  encode(message: Subspace, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+
+    for (const v of message.keys) {
+      writer.uint32(18).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Subspace {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubspace();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+
+        case 2:
+          message.keys.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Subspace>): Subspace {
+    const message = createBaseSubspace();
+    message.subspace = object.subspace ?? "";
+    message.keys = object.keys?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmos/query/v1/query.ts

@@ -0,0 +1 @@
+export {}

package/src/codegen/cosmos/reflection/v1/reflection.ts

@@ -0,0 +1,99 @@
+import { FileDescriptorProto, FileDescriptorProtoSDKType } from "../../../google/protobuf/descriptor";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** FileDescriptorsRequest is the Query/FileDescriptors request type. */
+
+export interface FileDescriptorsRequest {}
+/** FileDescriptorsRequest is the Query/FileDescriptors request type. */
+
+export interface FileDescriptorsRequestSDKType {}
+/** FileDescriptorsResponse is the Query/FileDescriptors response type. */
+
+export interface FileDescriptorsResponse {
+  /** files is the file descriptors. */
+  files: FileDescriptorProto[];
+}
+/** FileDescriptorsResponse is the Query/FileDescriptors response type. */
+
+export interface FileDescriptorsResponseSDKType {
+  files: FileDescriptorProtoSDKType[];
+}
+
+function createBaseFileDescriptorsRequest(): FileDescriptorsRequest {
+  return {};
+}
+
+export const FileDescriptorsRequest = {
+  encode(_: FileDescriptorsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FileDescriptorsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDescriptorsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<FileDescriptorsRequest>): FileDescriptorsRequest {
+    const message = createBaseFileDescriptorsRequest();
+    return message;
+  }
+
+};
+
+function createBaseFileDescriptorsResponse(): FileDescriptorsResponse {
+  return {
+    files: []
+  };
+}
+
+export const FileDescriptorsResponse = {
+  encode(message: FileDescriptorsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.files) {
+      FileDescriptorProto.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FileDescriptorsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDescriptorsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.files.push(FileDescriptorProto.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<FileDescriptorsResponse>): FileDescriptorsResponse {
+    const message = createBaseFileDescriptorsResponse();
+    message.files = object.files?.map(e => FileDescriptorProto.fromPartial(e)) || [];
+    return message;
+  }
+
+};