@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/cosmos/counter/v1/query.ts

@@ -0,0 +1,171 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** QueryGetCountRequest defines the request type for querying x/mock count. */
+export interface QueryGetCountRequest {}
+export interface QueryGetCountRequestProtoMsg {
+  typeUrl: "/cosmos.counter.v1.QueryGetCountRequest";
+  value: Uint8Array;
+}
+/**
+ * QueryGetCountRequest defines the request type for querying x/mock count.
+ * @name QueryGetCountRequestAmino
+ * @package cosmos.counter.v1
+ * @see proto type: cosmos.counter.v1.QueryGetCountRequest
+ */
+export interface QueryGetCountRequestAmino {}
+export interface QueryGetCountRequestAminoMsg {
+  type: "cosmos-sdk/QueryGetCountRequest";
+  value: QueryGetCountRequestAmino;
+}
+/** QueryGetCountRequest defines the request type for querying x/mock count. */
+export interface QueryGetCountRequestSDKType {}
+/** QueryGetCountResponse defines the response type for querying x/mock count. */
+export interface QueryGetCountResponse {
+  totalCount: bigint;
+}
+export interface QueryGetCountResponseProtoMsg {
+  typeUrl: "/cosmos.counter.v1.QueryGetCountResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryGetCountResponse defines the response type for querying x/mock count.
+ * @name QueryGetCountResponseAmino
+ * @package cosmos.counter.v1
+ * @see proto type: cosmos.counter.v1.QueryGetCountResponse
+ */
+export interface QueryGetCountResponseAmino {
+  total_count?: string;
+}
+export interface QueryGetCountResponseAminoMsg {
+  type: "cosmos-sdk/QueryGetCountResponse";
+  value: QueryGetCountResponseAmino;
+}
+/** QueryGetCountResponse defines the response type for querying x/mock count. */
+export interface QueryGetCountResponseSDKType {
+  total_count: bigint;
+}
+function createBaseQueryGetCountRequest(): QueryGetCountRequest {
+  return {};
+}
+export const QueryGetCountRequest = {
+  typeUrl: "/cosmos.counter.v1.QueryGetCountRequest",
+  encode(_: QueryGetCountRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGetCountRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGetCountRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<QueryGetCountRequest>): QueryGetCountRequest {
+    const message = createBaseQueryGetCountRequest();
+    return message;
+  },
+  fromAmino(_: QueryGetCountRequestAmino): QueryGetCountRequest {
+    const message = createBaseQueryGetCountRequest();
+    return message;
+  },
+  toAmino(_: QueryGetCountRequest): QueryGetCountRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryGetCountRequestAminoMsg): QueryGetCountRequest {
+    return QueryGetCountRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGetCountRequest): QueryGetCountRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGetCountRequest",
+      value: QueryGetCountRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGetCountRequestProtoMsg): QueryGetCountRequest {
+    return QueryGetCountRequest.decode(message.value);
+  },
+  toProto(message: QueryGetCountRequest): Uint8Array {
+    return QueryGetCountRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGetCountRequest): QueryGetCountRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.counter.v1.QueryGetCountRequest",
+      value: QueryGetCountRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGetCountResponse(): QueryGetCountResponse {
+  return {
+    totalCount: BigInt(0)
+  };
+}
+export const QueryGetCountResponse = {
+  typeUrl: "/cosmos.counter.v1.QueryGetCountResponse",
+  encode(message: QueryGetCountResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.totalCount !== BigInt(0)) {
+      writer.uint32(8).int64(message.totalCount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGetCountResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGetCountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.totalCount = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGetCountResponse>): QueryGetCountResponse {
+    const message = createBaseQueryGetCountResponse();
+    message.totalCount = object.totalCount !== undefined && object.totalCount !== null ? BigInt(object.totalCount.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: QueryGetCountResponseAmino): QueryGetCountResponse {
+    const message = createBaseQueryGetCountResponse();
+    if (object.total_count !== undefined && object.total_count !== null) {
+      message.totalCount = BigInt(object.total_count);
+    }
+    return message;
+  },
+  toAmino(message: QueryGetCountResponse): QueryGetCountResponseAmino {
+    const obj: any = {};
+    obj.total_count = message.totalCount !== BigInt(0) ? message.totalCount?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGetCountResponseAminoMsg): QueryGetCountResponse {
+    return QueryGetCountResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGetCountResponse): QueryGetCountResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGetCountResponse",
+      value: QueryGetCountResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGetCountResponseProtoMsg): QueryGetCountResponse {
+    return QueryGetCountResponse.decode(message.value);
+  },
+  toProto(message: QueryGetCountResponse): Uint8Array {
+    return QueryGetCountResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGetCountResponse): QueryGetCountResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.counter.v1.QueryGetCountResponse",
+      value: QueryGetCountResponse.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/counter/v1/tx.amino.ts

@@ -0,0 +1,9 @@
+//@ts-nocheck
+import { MsgIncreaseCounter } from "./tx";
+export const AminoConverter = {
+  "/cosmos.counter.v1.MsgIncreaseCounter": {
+    aminoType: "cosmos-sdk/increase_counter",
+    toAmino: MsgIncreaseCounter.toAmino,
+    fromAmino: MsgIncreaseCounter.fromAmino
+  }
+};

package/types/cosmos/counter/v1/tx.registry.ts

@@ -0,0 +1,35 @@
+//@ts-nocheck
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgIncreaseCounter } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.counter.v1.MsgIncreaseCounter", MsgIncreaseCounter]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    increaseCount(value: MsgIncreaseCounter) {
+      return {
+        typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter",
+        value: MsgIncreaseCounter.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    increaseCount(value: MsgIncreaseCounter) {
+      return {
+        typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    increaseCount(value: MsgIncreaseCounter) {
+      return {
+        typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter",
+        value: MsgIncreaseCounter.fromPartial(value)
+      };
+    }
+  }
+};

package/types/cosmos/counter/v1/tx.rpc.msg.ts

@@ -0,0 +1,21 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgIncreaseCounter, MsgIncreaseCountResponse } from "./tx";
+/** Msg defines the counter Msg service. */
+export interface Msg {
+  /** IncreaseCount increments the counter by the specified amount. */
+  increaseCount(request: MsgIncreaseCounter): Promise<MsgIncreaseCountResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.increaseCount = this.increaseCount.bind(this);
+  }
+  increaseCount(request: MsgIncreaseCounter): Promise<MsgIncreaseCountResponse> {
+    const data = MsgIncreaseCounter.encode(request).finish();
+    const promise = this.rpc.request("cosmos.counter.v1.Msg", "IncreaseCount", data);
+    return promise.then(data => MsgIncreaseCountResponse.decode(new BinaryReader(data)));
+  }
+}

package/types/cosmos/counter/v1/tx.ts

@@ -0,0 +1,217 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** MsgIncreaseCounter defines a count Msg service counter. */
+export interface MsgIncreaseCounter {
+  /** signer is the address that controls the module (defaults to x/gov unless overwritten). */
+  signer: string;
+  /** count is the number of times to increment the counter. */
+  count: bigint;
+}
+export interface MsgIncreaseCounterProtoMsg {
+  typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter";
+  value: Uint8Array;
+}
+/**
+ * MsgIncreaseCounter defines a count Msg service counter.
+ * @name MsgIncreaseCounterAmino
+ * @package cosmos.counter.v1
+ * @see proto type: cosmos.counter.v1.MsgIncreaseCounter
+ */
+export interface MsgIncreaseCounterAmino {
+  /**
+   * signer is the address that controls the module (defaults to x/gov unless overwritten).
+   */
+  signer?: string;
+  /**
+   * count is the number of times to increment the counter.
+   */
+  count?: string;
+}
+export interface MsgIncreaseCounterAminoMsg {
+  type: "cosmos-sdk/increase_counter";
+  value: MsgIncreaseCounterAmino;
+}
+/** MsgIncreaseCounter defines a count Msg service counter. */
+export interface MsgIncreaseCounterSDKType {
+  signer: string;
+  count: bigint;
+}
+/** MsgIncreaseCountResponse is the Msg/Counter response type. */
+export interface MsgIncreaseCountResponse {
+  /** new_count is the number of times the counter was incremented. */
+  newCount: bigint;
+}
+export interface MsgIncreaseCountResponseProtoMsg {
+  typeUrl: "/cosmos.counter.v1.MsgIncreaseCountResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgIncreaseCountResponse is the Msg/Counter response type.
+ * @name MsgIncreaseCountResponseAmino
+ * @package cosmos.counter.v1
+ * @see proto type: cosmos.counter.v1.MsgIncreaseCountResponse
+ */
+export interface MsgIncreaseCountResponseAmino {
+  /**
+   * new_count is the number of times the counter was incremented.
+   */
+  new_count?: string;
+}
+export interface MsgIncreaseCountResponseAminoMsg {
+  type: "cosmos-sdk/MsgIncreaseCountResponse";
+  value: MsgIncreaseCountResponseAmino;
+}
+/** MsgIncreaseCountResponse is the Msg/Counter response type. */
+export interface MsgIncreaseCountResponseSDKType {
+  new_count: bigint;
+}
+function createBaseMsgIncreaseCounter(): MsgIncreaseCounter {
+  return {
+    signer: "",
+    count: BigInt(0)
+  };
+}
+export const MsgIncreaseCounter = {
+  typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter",
+  encode(message: MsgIncreaseCounter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.signer !== "") {
+      writer.uint32(10).string(message.signer);
+    }
+    if (message.count !== BigInt(0)) {
+      writer.uint32(16).int64(message.count);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgIncreaseCounter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgIncreaseCounter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.signer = reader.string();
+          break;
+        case 2:
+          message.count = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgIncreaseCounter>): MsgIncreaseCounter {
+    const message = createBaseMsgIncreaseCounter();
+    message.signer = object.signer ?? "";
+    message.count = object.count !== undefined && object.count !== null ? BigInt(object.count.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: MsgIncreaseCounterAmino): MsgIncreaseCounter {
+    const message = createBaseMsgIncreaseCounter();
+    if (object.signer !== undefined && object.signer !== null) {
+      message.signer = object.signer;
+    }
+    if (object.count !== undefined && object.count !== null) {
+      message.count = BigInt(object.count);
+    }
+    return message;
+  },
+  toAmino(message: MsgIncreaseCounter): MsgIncreaseCounterAmino {
+    const obj: any = {};
+    obj.signer = message.signer === "" ? undefined : message.signer;
+    obj.count = message.count !== BigInt(0) ? message.count?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgIncreaseCounterAminoMsg): MsgIncreaseCounter {
+    return MsgIncreaseCounter.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgIncreaseCounter): MsgIncreaseCounterAminoMsg {
+    return {
+      type: "cosmos-sdk/increase_counter",
+      value: MsgIncreaseCounter.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgIncreaseCounterProtoMsg): MsgIncreaseCounter {
+    return MsgIncreaseCounter.decode(message.value);
+  },
+  toProto(message: MsgIncreaseCounter): Uint8Array {
+    return MsgIncreaseCounter.encode(message).finish();
+  },
+  toProtoMsg(message: MsgIncreaseCounter): MsgIncreaseCounterProtoMsg {
+    return {
+      typeUrl: "/cosmos.counter.v1.MsgIncreaseCounter",
+      value: MsgIncreaseCounter.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgIncreaseCountResponse(): MsgIncreaseCountResponse {
+  return {
+    newCount: BigInt(0)
+  };
+}
+export const MsgIncreaseCountResponse = {
+  typeUrl: "/cosmos.counter.v1.MsgIncreaseCountResponse",
+  encode(message: MsgIncreaseCountResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.newCount !== BigInt(0)) {
+      writer.uint32(8).int64(message.newCount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgIncreaseCountResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgIncreaseCountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.newCount = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgIncreaseCountResponse>): MsgIncreaseCountResponse {
+    const message = createBaseMsgIncreaseCountResponse();
+    message.newCount = object.newCount !== undefined && object.newCount !== null ? BigInt(object.newCount.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: MsgIncreaseCountResponseAmino): MsgIncreaseCountResponse {
+    const message = createBaseMsgIncreaseCountResponse();
+    if (object.new_count !== undefined && object.new_count !== null) {
+      message.newCount = BigInt(object.new_count);
+    }
+    return message;
+  },
+  toAmino(message: MsgIncreaseCountResponse): MsgIncreaseCountResponseAmino {
+    const obj: any = {};
+    obj.new_count = message.newCount !== BigInt(0) ? message.newCount?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgIncreaseCountResponseAminoMsg): MsgIncreaseCountResponse {
+    return MsgIncreaseCountResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgIncreaseCountResponse): MsgIncreaseCountResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgIncreaseCountResponse",
+      value: MsgIncreaseCountResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgIncreaseCountResponseProtoMsg): MsgIncreaseCountResponse {
+    return MsgIncreaseCountResponse.decode(message.value);
+  },
+  toProto(message: MsgIncreaseCountResponse): Uint8Array {
+    return MsgIncreaseCountResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgIncreaseCountResponse): MsgIncreaseCountResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.counter.v1.MsgIncreaseCountResponse",
+      value: MsgIncreaseCountResponse.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/crisis/module/v1/module.ts

@@ -0,0 +1,119 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** 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;
+}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.crisis.module.v1.Module";
+  value: Uint8Array;
+}
+/**
+ * Module is the config object of the crisis module.
+ * @name ModuleAmino
+ * @package cosmos.crisis.module.v1
+ * @see proto type: cosmos.crisis.module.v1.Module
+ */
+export interface ModuleAmino {
+  /**
+   * fee_collector_name is the name of the FeeCollector ModuleAccount.
+   */
+  fee_collector_name?: string;
+  /**
+   * authority defines the custom module authority. If not set, defaults to the governance module.
+   */
+  authority?: string;
+}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+/** 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 = {
+  typeUrl: "/cosmos.crisis.module.v1.Module",
+  encode(message: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.feeCollectorName !== "") {
+      writer.uint32(10).string(message.feeCollectorName);
+    }
+    if (message.authority !== "") {
+      writer.uint32(18).string(message.authority);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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: Partial<Module>): Module {
+    const message = createBaseModule();
+    message.feeCollectorName = object.feeCollectorName ?? "";
+    message.authority = object.authority ?? "";
+    return message;
+  },
+  fromAmino(object: ModuleAmino): Module {
+    const message = createBaseModule();
+    if (object.fee_collector_name !== undefined && object.fee_collector_name !== null) {
+      message.feeCollectorName = object.fee_collector_name;
+    }
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    return message;
+  },
+  toAmino(message: Module): ModuleAmino {
+    const obj: any = {};
+    obj.fee_collector_name = message.feeCollectorName === "" ? undefined : message.feeCollectorName;
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.crisis.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/crisis/v1beta1/genesis.ts

@@ -0,0 +1,105 @@
+//@ts-nocheck
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** 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;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.crisis.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/**
+ * GenesisState defines the crisis module's genesis state.
+ * @name GenesisStateAmino
+ * @package cosmos.crisis.v1beta1
+ * @see proto type: cosmos.crisis.v1beta1.GenesisState
+ */
+export interface GenesisStateAmino {
+  /**
+   * constant_fee is the fee used to verify the invariant in the crisis
+   * module.
+   */
+  constant_fee: CoinAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the crisis module's genesis state. */
+export interface GenesisStateSDKType {
+  constant_fee: CoinSDKType;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    constantFee: Coin.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.crisis.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.constantFee !== undefined) {
+      Coin.encode(message.constantFee, writer.uint32(26).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 3:
+          message.constantFee = Coin.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.constantFee = object.constantFee !== undefined && object.constantFee !== null ? Coin.fromPartial(object.constantFee) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.constant_fee !== undefined && object.constant_fee !== null) {
+      message.constantFee = Coin.fromAmino(object.constant_fee);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.constant_fee = message.constantFee ? Coin.toAmino(message.constantFee) : Coin.toAmino(Coin.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/cosmos.crisis.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/crisis/v1beta1/tx.amino.ts

@@ -0,0 +1,14 @@
+//@ts-nocheck
+import { MsgVerifyInvariant, MsgUpdateParams } from "./tx";
+export const AminoConverter = {
+  "/cosmos.crisis.v1beta1.MsgVerifyInvariant": {
+    aminoType: "cosmos-sdk/MsgVerifyInvariant",
+    toAmino: MsgVerifyInvariant.toAmino,
+    fromAmino: MsgVerifyInvariant.fromAmino
+  },
+  "/cosmos.crisis.v1beta1.MsgUpdateParams": {
+    aminoType: "cosmos-sdk/x/crisis/MsgUpdateParams",
+    toAmino: MsgUpdateParams.toAmino,
+    fromAmino: MsgUpdateParams.fromAmino
+  }
+};