@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/consensus/module/v1/module.ts

@@ -0,0 +1,58 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the consensus module. */
+
+export interface Module {
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+/** Module is the config object of the consensus module. */
+
+export interface ModuleSDKType {
+  authority: string;
+}
+
+function createBaseModule(): Module {
+  return {
+    authority: ""
+  };
+}
+
+export const Module = {
+  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.authority = object.authority ?? "";
+    return message;
+  }
+
+};

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

@@ -0,0 +1,22 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+  }
+  /* Params queries the parameters of x/consensus module. */
+
+
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/consensus/v1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/cosmos/consensus/v1/query.rpc.Query.ts

@@ -0,0 +1,35 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Params queries the parameters of x/consensus module. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.consensus.v1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.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);
+    }
+
+  };
+};

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

@@ -0,0 +1,103 @@
+import { ConsensusParams, ConsensusParamsSDKType } from "../../../tendermint/types/params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** QueryParamsRequest defines the request type for querying x/consensus parameters. */
+
+export interface QueryParamsRequest {}
+/** QueryParamsRequest defines the request type for querying x/consensus parameters. */
+
+export interface QueryParamsRequestSDKType {}
+/** QueryParamsResponse defines the response type for querying x/consensus parameters. */
+
+export interface QueryParamsResponse {
+  /**
+   * params are the tendermint consensus params stored in the consensus module.
+   * Please note that `params.version` is not populated in this response, it is
+   * tracked separately in the x/upgrade module.
+   */
+  params?: ConsensusParams;
+}
+/** QueryParamsResponse defines the response type for querying x/consensus parameters. */
+
+export interface QueryParamsResponseSDKType {
+  params?: ConsensusParamsSDKType;
+}
+
+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) {
+      ConsensusParams.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 = ConsensusParams.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 ? ConsensusParams.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/consensus/v1/tx.rpc.msg.ts

@@ -0,0 +1,29 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+/** Msg defines the consensus Msg service. */
+
+export interface Msg {
+  /**
+   * UpdateParams defines a governance operation for updating the x/consensus module parameters.
+   * The authority is defined in the keeper.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.updateParams = this.updateParams.bind(this);
+  }
+
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("cosmos.consensus.v1.Msg", "UpdateParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/cosmos/consensus/v1/tx.ts

@@ -0,0 +1,163 @@
+import { BlockParams, BlockParamsSDKType, EvidenceParams, EvidenceParamsSDKType, ValidatorParams, ValidatorParamsSDKType, ABCIParams, ABCIParamsSDKType } from "../../../tendermint/types/params";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+
+export interface MsgUpdateParams {
+  /** authority is the address that controls the module (defaults to x/gov unless overwritten). */
+  authority: string;
+  /**
+   * params defines the x/consensus parameters to update.
+   * VersionsParams is not included in this Msg because it is tracked
+   * separarately in x/upgrade.
+   * 
+   * NOTE: All parameters must be supplied.
+   */
+
+  block?: BlockParams;
+  evidence?: EvidenceParams;
+  validator?: ValidatorParams;
+  /** Since: cosmos-sdk 0.50 */
+
+  abci?: ABCIParams;
+}
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+
+export interface MsgUpdateParamsSDKType {
+  authority: string;
+  block?: BlockParamsSDKType;
+  evidence?: EvidenceParamsSDKType;
+  validator?: ValidatorParamsSDKType;
+  abci?: ABCIParamsSDKType;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+
+export interface MsgUpdateParamsResponse {}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+
+export interface MsgUpdateParamsResponseSDKType {}
+
+function createBaseMsgUpdateParams(): MsgUpdateParams {
+  return {
+    authority: "",
+    block: undefined,
+    evidence: undefined,
+    validator: undefined,
+    abci: undefined
+  };
+}
+
+export const MsgUpdateParams = {
+  encode(message: MsgUpdateParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.block !== undefined) {
+      BlockParams.encode(message.block, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.evidence !== undefined) {
+      EvidenceParams.encode(message.evidence, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.validator !== undefined) {
+      ValidatorParams.encode(message.validator, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.abci !== undefined) {
+      ABCIParams.encode(message.abci, writer.uint32(42).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParams {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.block = BlockParams.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.evidence = EvidenceParams.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.validator = ValidatorParams.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.abci = ABCIParams.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.block = object.block !== undefined && object.block !== null ? BlockParams.fromPartial(object.block) : undefined;
+    message.evidence = object.evidence !== undefined && object.evidence !== null ? EvidenceParams.fromPartial(object.evidence) : undefined;
+    message.validator = object.validator !== undefined && object.validator !== null ? ValidatorParams.fromPartial(object.validator) : undefined;
+    message.abci = object.abci !== undefined && object.abci !== null ? ABCIParams.fromPartial(object.abci) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse {
+  return {};
+}
+
+export const MsgUpdateParamsResponse = {
+  encode(_: MsgUpdateParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParamsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/crisis/module/v1/module.ts

@@ -0,0 +1,72 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the crisis module. */
+
+export interface Module {
+  /** fee_collector_name is the name of the FeeCollector ModuleAccount. */
+  feeCollectorName: string;
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+
+  authority: string;
+}
+/** Module is the config object of the crisis module. */
+
+export interface ModuleSDKType {
+  fee_collector_name: string;
+  authority: string;
+}
+
+function createBaseModule(): Module {
+  return {
+    feeCollectorName: "",
+    authority: ""
+  };
+}
+
+export const Module = {
+  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.feeCollectorName !== "") {
+      writer.uint32(10).string(message.feeCollectorName);
+    }
+
+    if (message.authority !== "") {
+      writer.uint32(18).string(message.authority);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.feeCollectorName = reader.string();
+          break;
+
+        case 2:
+          message.authority = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.feeCollectorName = object.feeCollectorName ?? "";
+    message.authority = object.authority ?? "";
+    return message;
+  }
+
+};

package/src/codegen/cosmos/crisis/v1beta1/genesis.ts

@@ -0,0 +1,62 @@
+import { Coin, CoinSDKType } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the crisis module's genesis state. */
+
+export interface GenesisState {
+  /**
+   * constant_fee is the fee used to verify the invariant in the crisis
+   * module.
+   */
+  constantFee?: Coin;
+}
+/** GenesisState defines the crisis module's genesis state. */
+
+export interface GenesisStateSDKType {
+  constant_fee?: CoinSDKType;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    constantFee: undefined
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.constantFee !== undefined) {
+      Coin.encode(message.constantFee, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 3:
+          message.constantFee = Coin.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.constantFee = object.constantFee !== undefined && object.constantFee !== null ? Coin.fromPartial(object.constantFee) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/crisis/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,39 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgVerifyInvariant, MsgVerifyInvariantResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+/** Msg defines the bank Msg service. */
+
+export interface Msg {
+  /** VerifyInvariant defines a method to verify a particular invariant. */
+  verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse>;
+  /**
+   * UpdateParams defines a governance operation for updating the x/crisis module
+   * parameters. The authority is defined in the keeper.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.verifyInvariant = this.verifyInvariant.bind(this);
+    this.updateParams = this.updateParams.bind(this);
+  }
+
+  verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse> {
+    const data = MsgVerifyInvariant.encode(request).finish();
+    const promise = this.rpc.request("cosmos.crisis.v1beta1.Msg", "VerifyInvariant", data);
+    return promise.then(data => MsgVerifyInvariantResponse.decode(new _m0.Reader(data)));
+  }
+
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("cosmos.crisis.v1beta1.Msg", "UpdateParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+}