@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/token/params.ts

@@ -0,0 +1,196 @@
+import { Coin, CoinSDKType } from "../../cosmos/base/v1beta1/coin";
+import { Long, DeepPartial } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/** Params holds the parameters for the token module. */
+
+export interface Params {
+  /** DenomCreationFee is the fee required to create a new denom. */
+  denomCreationFee: Coin[];
+  /** DenomCreationGasConsume is the gas consumed when creating a new denom. */
+
+  denomCreationGasConsume: Long;
+}
+/** Params holds the parameters for the token module. */
+
+export interface ParamsSDKType {
+  denom_creation_fee: CoinSDKType[];
+  denom_creation_gas_consume: Long;
+}
+/** DenomAuthorityMetadata specifies metadata for admin control of a denom. */
+
+export interface DenomAuthorityMetadata {
+  /** Admin is the denom admin. Can be empty for no admin. */
+  admin: string;
+}
+/** DenomAuthorityMetadata specifies metadata for admin control of a denom. */
+
+export interface DenomAuthorityMetadataSDKType {
+  admin: string;
+}
+/** GenesisDenom defines a denom to be initialized at genesis. */
+
+export interface GenesisDenom {
+  denom: string;
+  authorityMetadata?: DenomAuthorityMetadata;
+}
+/** GenesisDenom defines a denom to be initialized at genesis. */
+
+export interface GenesisDenomSDKType {
+  denom: string;
+  authority_metadata?: DenomAuthorityMetadataSDKType;
+}
+
+function createBaseParams(): Params {
+  return {
+    denomCreationFee: [],
+    denomCreationGasConsume: Long.UZERO
+  };
+}
+
+export const Params = {
+  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.denomCreationFee) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (!message.denomCreationGasConsume.isZero()) {
+      writer.uint32(16).uint64(message.denomCreationGasConsume);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Params {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denomCreationFee.push(Coin.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.denomCreationGasConsume = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.denomCreationFee = object.denomCreationFee?.map(e => Coin.fromPartial(e)) || [];
+    message.denomCreationGasConsume = object.denomCreationGasConsume !== undefined && object.denomCreationGasConsume !== null ? Long.fromValue(object.denomCreationGasConsume) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseDenomAuthorityMetadata(): DenomAuthorityMetadata {
+  return {
+    admin: ""
+  };
+}
+
+export const DenomAuthorityMetadata = {
+  encode(message: DenomAuthorityMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.admin !== "") {
+      writer.uint32(10).string(message.admin);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DenomAuthorityMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDenomAuthorityMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.admin = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<DenomAuthorityMetadata>): DenomAuthorityMetadata {
+    const message = createBaseDenomAuthorityMetadata();
+    message.admin = object.admin ?? "";
+    return message;
+  }
+
+};
+
+function createBaseGenesisDenom(): GenesisDenom {
+  return {
+    denom: "",
+    authorityMetadata: undefined
+  };
+}
+
+export const GenesisDenom = {
+  encode(message: GenesisDenom, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    if (message.authorityMetadata !== undefined) {
+      DenomAuthorityMetadata.encode(message.authorityMetadata, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisDenom {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisDenom();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        case 2:
+          message.authorityMetadata = DenomAuthorityMetadata.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisDenom>): GenesisDenom {
+    const message = createBaseGenesisDenom();
+    message.denom = object.denom ?? "";
+    message.authorityMetadata = object.authorityMetadata !== undefined && object.authorityMetadata !== null ? DenomAuthorityMetadata.fromPartial(object.authorityMetadata) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/zogux/token/query.lcd.ts

@@ -0,0 +1,38 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponseSDKType, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this);
+    this.denomsFromCreator = this.denomsFromCreator.bind(this);
+  }
+  /* Params returns the module parameters. */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `zogux/token/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* DenomAuthorityMetadata returns the denom authority metadata. */
+
+
+  async denomAuthorityMetadata(params: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponseSDKType> {
+    const endpoint = `zogux/token/denoms/${params.denom}/authority`;
+    return await this.req.get<QueryDenomAuthorityMetadataResponseSDKType>(endpoint);
+  }
+  /* DenomsFromCreator returns all denoms created by a specific creator. */
+
+
+  async denomsFromCreator(params: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponseSDKType> {
+    const endpoint = `zogux/token/denoms/creator/${params.creator}`;
+    return await this.req.get<QueryDenomsFromCreatorResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/zogux/token/query.rpc.Query.ts

@@ -0,0 +1,63 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Params returns the module parameters. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** DenomAuthorityMetadata returns the denom authority metadata. */
+
+  denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse>;
+  /** DenomsFromCreator returns all denoms created by a specific creator. */
+
+  denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this);
+    this.denomsFromCreator = this.denomsFromCreator.bind(this);
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.token.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
+    const data = QueryDenomAuthorityMetadataRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.token.Query", "DenomAuthorityMetadata", data);
+    return promise.then(data => QueryDenomAuthorityMetadataResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
+    const data = QueryDenomsFromCreatorRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.token.Query", "DenomsFromCreator", data);
+    return promise.then(data => QueryDenomsFromCreatorResponse.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);
+    },
+
+    denomAuthorityMetadata(request: QueryDenomAuthorityMetadataRequest): Promise<QueryDenomAuthorityMetadataResponse> {
+      return queryService.denomAuthorityMetadata(request);
+    },
+
+    denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise<QueryDenomsFromCreatorResponse> {
+      return queryService.denomsFromCreator(request);
+    }
+
+  };
+};

package/src/codegen/zogux/token/query.ts

@@ -0,0 +1,342 @@
+import { Params, ParamsSDKType, DenomAuthorityMetadata, DenomAuthorityMetadataSDKType } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequest {}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequestSDKType {}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponse {
+  params?: Params;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponseSDKType {
+  params?: ParamsSDKType;
+}
+/**
+ * QueryDenomAuthorityMetadataRequest is the request type for the
+ * Query/DenomAuthorityMetadata RPC method.
+ */
+
+export interface QueryDenomAuthorityMetadataRequest {
+  denom: string;
+}
+/**
+ * QueryDenomAuthorityMetadataRequest is the request type for the
+ * Query/DenomAuthorityMetadata RPC method.
+ */
+
+export interface QueryDenomAuthorityMetadataRequestSDKType {
+  denom: string;
+}
+/**
+ * QueryDenomAuthorityMetadataResponse is the response type for the
+ * Query/DenomAuthorityMetadata RPC method.
+ */
+
+export interface QueryDenomAuthorityMetadataResponse {
+  authorityMetadata?: DenomAuthorityMetadata;
+}
+/**
+ * QueryDenomAuthorityMetadataResponse is the response type for the
+ * Query/DenomAuthorityMetadata RPC method.
+ */
+
+export interface QueryDenomAuthorityMetadataResponseSDKType {
+  authority_metadata?: DenomAuthorityMetadataSDKType;
+}
+/**
+ * QueryDenomsFromCreatorRequest is the request type for the
+ * Query/DenomsFromCreator RPC method.
+ */
+
+export interface QueryDenomsFromCreatorRequest {
+  creator: string;
+}
+/**
+ * QueryDenomsFromCreatorRequest is the request type for the
+ * Query/DenomsFromCreator RPC method.
+ */
+
+export interface QueryDenomsFromCreatorRequestSDKType {
+  creator: string;
+}
+/**
+ * QueryDenomsFromCreatorResponse is the response type for the
+ * Query/DenomsFromCreator RPC method.
+ */
+
+export interface QueryDenomsFromCreatorResponse {
+  denoms: string[];
+}
+/**
+ * QueryDenomsFromCreatorResponse is the response type for the
+ * Query/DenomsFromCreator RPC method.
+ */
+
+export interface QueryDenomsFromCreatorResponseSDKType {
+  denoms: string[];
+}
+
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+
+export const QueryParamsRequest = {
+  encode(_: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  }
+
+};
+
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: undefined
+  };
+}
+
+export const QueryParamsResponse = {
+  encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, 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.params = Params.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomAuthorityMetadataRequest(): QueryDenomAuthorityMetadataRequest {
+  return {
+    denom: ""
+  };
+}
+
+export const QueryDenomAuthorityMetadataRequest = {
+  encode(message: QueryDenomAuthorityMetadataRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomAuthorityMetadataRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomAuthorityMetadataRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomAuthorityMetadataRequest>): QueryDenomAuthorityMetadataRequest {
+    const message = createBaseQueryDenomAuthorityMetadataRequest();
+    message.denom = object.denom ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomAuthorityMetadataResponse(): QueryDenomAuthorityMetadataResponse {
+  return {
+    authorityMetadata: undefined
+  };
+}
+
+export const QueryDenomAuthorityMetadataResponse = {
+  encode(message: QueryDenomAuthorityMetadataResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authorityMetadata !== undefined) {
+      DenomAuthorityMetadata.encode(message.authorityMetadata, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomAuthorityMetadataResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomAuthorityMetadataResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authorityMetadata = DenomAuthorityMetadata.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomAuthorityMetadataResponse>): QueryDenomAuthorityMetadataResponse {
+    const message = createBaseQueryDenomAuthorityMetadataResponse();
+    message.authorityMetadata = object.authorityMetadata !== undefined && object.authorityMetadata !== null ? DenomAuthorityMetadata.fromPartial(object.authorityMetadata) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomsFromCreatorRequest(): QueryDenomsFromCreatorRequest {
+  return {
+    creator: ""
+  };
+}
+
+export const QueryDenomsFromCreatorRequest = {
+  encode(message: QueryDenomsFromCreatorRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomsFromCreatorRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomsFromCreatorRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomsFromCreatorRequest>): QueryDenomsFromCreatorRequest {
+    const message = createBaseQueryDenomsFromCreatorRequest();
+    message.creator = object.creator ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomsFromCreatorResponse(): QueryDenomsFromCreatorResponse {
+  return {
+    denoms: []
+  };
+}
+
+export const QueryDenomsFromCreatorResponse = {
+  encode(message: QueryDenomsFromCreatorResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.denoms) {
+      writer.uint32(10).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomsFromCreatorResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomsFromCreatorResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denoms.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomsFromCreatorResponse>): QueryDenomsFromCreatorResponse {
+    const message = createBaseQueryDenomsFromCreatorResponse();
+    message.denoms = object.denoms?.map(e => e) || [];
+    return message;
+  }
+
+};