add extended registry

src/codegen/binary.ts

@@ -0,0 +1,534 @@
+/**
+* This file and any referenced files were automatically generated by @cosmology/telescope@1.5.4
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or yarn proto command to regenerate this bundle.
+*/
+
+
+// Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+
+// * Redistributions of source code must retain the above copyright
+//   notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+//   notice, this list of conditions and the following disclaimer in the
+//   documentation and/or other materials provided with the distribution.
+// * Neither the name of its author, nor the names of its contributors
+//   may be used to endorse or promote products derived from this software
+//   without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ---
+
+// Code generated by the command line utilities is owned by the owner
+// of the input file used when generating it. This code is not
+// standalone and requires a support library to be linked with it. This
+// support library is itself covered by the above license.
+
+import { utf8Length, utf8Read, utf8Write } from "./utf8";
+import {
+  int64ToString,
+  readInt32,
+  readUInt32,
+  uInt64ToString,
+  varint32read,
+  varint64read,
+  writeVarint32,
+  writeVarint64,
+  int64FromString,
+  int64Length,
+  writeFixed32,
+  writeByte,
+  zzDecode,
+  zzEncode,
+} from "./varint";
+
+export enum WireType {
+  Varint = 0,
+
+  Fixed64 = 1,
+
+  Bytes = 2,
+
+  Fixed32 = 5,
+}
+
+// Reader
+export interface IBinaryReader {
+  buf: Uint8Array;
+  pos: number;
+  type: number;
+  len: number;
+  tag(): [number, WireType, number];
+  skip(length?: number): this;
+  skipType(wireType: number): this;
+  uint32(): number;
+  int32(): number;
+  sint32(): number;
+  fixed32(): number;
+  sfixed32(): number;
+  int64(): bigint;
+  uint64(): bigint;
+  sint64(): bigint;
+  fixed64(): bigint;
+  sfixed64(): bigint;
+  float(): number;
+  double(): number;
+  bool(): boolean;
+  bytes(): Uint8Array;
+  string(): string;
+}
+
+export class BinaryReader implements IBinaryReader {
+  buf: Uint8Array;
+  pos: number;
+  type: number;
+  len: number;
+
+  assertBounds(): void {
+    if (this.pos > this.len) throw new RangeError("premature EOF");
+  }
+
+  constructor(buf?: ArrayLike<number>) {
+    this.buf = buf ? new Uint8Array(buf) : new Uint8Array(0);
+    this.pos = 0;
+    this.type = 0;
+    this.len = this.buf.length;
+  }
+
+  tag(): [number, WireType, number] {
+    const tag = this.uint32(),
+      fieldNo = tag >>> 3,
+      wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error(
+        "illegal tag: field no " + fieldNo + " wire type " + wireType
+      );
+    return [fieldNo, wireType, tag];
+  }
+
+  skip(length?: number) {
+    if (typeof length === "number") {
+      if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+      this.pos += length;
+    } else {
+      do {
+        if (this.pos >= this.len) throw indexOutOfRange(this);
+      } while (this.buf[this.pos++] & 128);
+    }
+    return this;
+  }
+
+  skipType(wireType: number) {
+    switch (wireType) {
+      case WireType.Varint:
+        this.skip();
+        break;
+      case WireType.Fixed64:
+        this.skip(8);
+        break;
+      case WireType.Bytes:
+        this.skip(this.uint32());
+        break;
+      case 3:
+        while ((wireType = this.uint32() & 7) !== 4) {
+          this.skipType(wireType);
+        }
+        break;
+      case WireType.Fixed32:
+        this.skip(4);
+        break;
+
+      /* istanbul ignore next */
+      default:
+        throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+    }
+    return this;
+  }
+
+  uint32(): number {
+    return varint32read.bind(this)();
+  }
+
+  int32(): number {
+    return this.uint32() | 0;
+  }
+
+  sint32(): number {
+    const num = this.uint32();
+    return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
+  }
+
+  fixed32(): number {
+    const val = readUInt32(this.buf, this.pos);
+    this.pos += 4;
+    return val;
+  }
+
+  sfixed32(): number {
+    const val = readInt32(this.buf, this.pos);
+    this.pos += 4;
+    return val;
+  }
+
+  int64(): bigint {
+    const [lo, hi] = varint64read.bind(this)();
+    return BigInt(int64ToString(lo, hi));
+  }
+
+  uint64(): bigint {
+    const [lo, hi] = varint64read.bind(this)();
+    return BigInt(uInt64ToString(lo, hi));
+  }
+
+  sint64(): bigint {
+    let [lo, hi] = varint64read.bind(this)();
+    // zig zag
+    [lo, hi] = zzDecode(lo, hi);
+    return BigInt(int64ToString(lo, hi));
+  }
+
+  fixed64(): bigint {
+    const lo = this.sfixed32();
+    const hi = this.sfixed32();
+    return BigInt(uInt64ToString(lo, hi));
+  }
+  sfixed64(): bigint {
+    const lo = this.sfixed32();
+    const hi = this.sfixed32();
+    return BigInt(int64ToString(lo, hi));
+  }
+
+  float(): number {
+    throw new Error("float not supported");
+  }
+
+  double(): number {
+    throw new Error("double not supported");
+  }
+
+  bool(): boolean {
+    const [lo, hi] = varint64read.bind(this)();
+    return lo !== 0 || hi !== 0;
+  }
+
+  bytes(): Uint8Array {
+    const len = this.uint32(),
+      start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+
+  string(): string {
+    const bytes = this.bytes();
+    return utf8Read(bytes, 0, bytes.length);
+  }
+}
+
+// Writer
+export interface IBinaryWriter {
+  len: number;
+  head: IOp;
+  tail: IOp;
+  states: State | null;
+  finish(): Uint8Array;
+  fork(): IBinaryWriter;
+  reset(): IBinaryWriter;
+  ldelim(): IBinaryWriter;
+  tag(fieldNo: number, type: WireType): IBinaryWriter;
+  uint32(value: number): IBinaryWriter;
+  int32(value: number): IBinaryWriter;
+  sint32(value: number): IBinaryWriter;
+  int64(value: string | number | bigint): IBinaryWriter;
+  uint64: (value: string | number | bigint) => IBinaryWriter;
+  sint64(value: string | number | bigint): IBinaryWriter;
+  fixed64(value: string | number | bigint): IBinaryWriter;
+  sfixed64: (value: string | number | bigint) => IBinaryWriter;
+  bool(value: boolean): IBinaryWriter;
+  fixed32(value: number): IBinaryWriter;
+  sfixed32: (value: number) => IBinaryWriter;
+  float(value: number): IBinaryWriter;
+  double(value: number): IBinaryWriter;
+  bytes(value: Uint8Array): IBinaryWriter;
+  string(value: string): IBinaryWriter;
+}
+
+interface IOp {
+  len: number;
+  next?: IOp;
+  proceed(buf: Uint8Array | number[], pos: number): void;
+}
+
+class Op<T> implements IOp {
+  fn?: ((val: T, buf: Uint8Array | number[], pos: number) => void) | null;
+  len: number;
+  val: T;
+  next?: IOp;
+
+  constructor(
+    fn:
+      | ((
+          val: T,
+          buf: Uint8Array | number[],
+          pos: number
+        ) => void | undefined | null)
+      | null,
+    len: number,
+    val: T
+  ) {
+    this.fn = fn;
+    this.len = len;
+    this.val = val;
+  }
+
+  proceed(buf: Uint8Array | number[], pos: number) {
+    if (this.fn) {
+      this.fn(this.val, buf, pos);
+    }
+  }
+}
+
+class State {
+  head: IOp;
+  tail: IOp;
+  len: number;
+  next: State | null;
+
+  constructor(writer: BinaryWriter) {
+    this.head = writer.head;
+    this.tail = writer.tail;
+    this.len = writer.len;
+    this.next = writer.states;
+  }
+}
+
+export class BinaryWriter implements IBinaryWriter {
+  len = 0;
+  head: IOp;
+  tail: IOp;
+  states: State | null;
+
+  constructor() {
+    this.head = new Op(null, 0, 0);
+    this.tail = this.head;
+    this.states = null;
+  }
+
+  static create() {
+    return new BinaryWriter();
+  }
+
+  static alloc(size: number): Uint8Array | number[] {
+    if (typeof Uint8Array !== "undefined") {
+      return pool(
+        (size) => new Uint8Array(size),
+        Uint8Array.prototype.subarray
+      )(size);
+    } else {
+      return new Array(size);
+    }
+  }
+
+  private _push<T>(
+    fn: (val: T, buf: Uint8Array | number[], pos: number) => void,
+    len: number,
+    val: T
+  ) {
+    this.tail = this.tail.next = new Op(fn, len, val);
+    this.len += len;
+    return this;
+  }
+
+  finish(): Uint8Array {
+    let head = this.head.next,
+      pos = 0;
+    const buf = BinaryWriter.alloc(this.len);
+    while (head) {
+      head.proceed(buf, pos);
+      pos += head.len;
+      head = head.next;
+    }
+    return buf as Uint8Array;
+  }
+
+  fork(): BinaryWriter {
+    this.states = new State(this);
+    this.head = this.tail = new Op(null, 0, 0);
+    this.len = 0;
+    return this;
+  }
+
+  reset(): BinaryWriter {
+    if (this.states) {
+      this.head = this.states.head;
+      this.tail = this.states.tail;
+      this.len = this.states.len;
+      this.states = this.states.next;
+    } else {
+      this.head = this.tail = new Op(null, 0, 0);
+      this.len = 0;
+    }
+    return this;
+  }
+
+  ldelim(): BinaryWriter {
+    const head = this.head,
+      tail = this.tail,
+      len = this.len;
+    this.reset().uint32(len);
+    if (len) {
+      this.tail.next = head.next; // skip noop
+      this.tail = tail;
+      this.len += len;
+    }
+    return this;
+  }
+
+  tag(fieldNo: number, type: WireType): BinaryWriter {
+    return this.uint32(((fieldNo << 3) | type) >>> 0);
+  }
+
+  uint32(value: number): BinaryWriter {
+    this.len += (this.tail = this.tail.next =
+      new Op(
+        writeVarint32,
+        (value = value >>> 0) < 128
+          ? 1
+          : value < 16384
+          ? 2
+          : value < 2097152
+          ? 3
+          : value < 268435456
+          ? 4
+          : 5,
+        value
+      )).len;
+    return this;
+  }
+
+  int32(value: number): BinaryWriter {
+    return value < 0
+      ? this._push(writeVarint64, 10, int64FromString(value.toString())) // 10 bytes per spec
+      : this.uint32(value);
+  }
+
+  sint32(value: number): BinaryWriter {
+    return this.uint32(((value << 1) ^ (value >> 31)) >>> 0);
+  }
+
+  int64(value: string | number | bigint): BinaryWriter {
+    const { lo, hi } = int64FromString(value.toString());
+    return this._push(writeVarint64, int64Length(lo, hi), { lo, hi });
+  }
+
+  // uint64 is the same with int64
+  uint64 = BinaryWriter.prototype.int64;
+
+  sint64(value: string | number | bigint): BinaryWriter {
+    let { lo, hi } = int64FromString(value.toString());
+    // zig zag
+    [lo, hi] = zzEncode(lo, hi);
+    return this._push(writeVarint64, int64Length(lo, hi), { lo, hi });
+  }
+
+  fixed64(value: string | number | bigint): BinaryWriter {
+    const { lo, hi } = int64FromString(value.toString());
+    return this._push(writeFixed32, 4, lo)._push(writeFixed32, 4, hi);
+  }
+
+  // sfixed64 is the same with fixed64
+  sfixed64 = BinaryWriter.prototype.fixed64;
+
+  bool(value: boolean): BinaryWriter {
+    return this._push(writeByte, 1, value ? 1 : 0);
+  }
+
+  fixed32(value: number): BinaryWriter {
+    return this._push(writeFixed32, 4, value >>> 0);
+  }
+
+  // sfixed32 is the same with fixed32
+  sfixed32 = BinaryWriter.prototype.fixed32;
+
+  float(value: number): BinaryWriter {
+    throw new Error("float not supported" + value);
+  }
+
+  double(value: number): BinaryWriter {
+    throw new Error("double not supported" + value);
+  }
+
+  bytes(value: Uint8Array): BinaryWriter {
+    const len = value.length >>> 0;
+    if (!len) return this._push(writeByte, 1, 0);
+    return this.uint32(len)._push(writeBytes, len, value);
+  }
+
+  string(value: string): BinaryWriter {
+    const len = utf8Length(value);
+    return len
+      ? this.uint32(len)._push(utf8Write, len, value)
+      : this._push(writeByte, 1, 0);
+  }
+}
+
+function writeBytes(
+  val: Uint8Array | number[],
+  buf: Uint8Array | number[],
+  pos: number
+) {
+  if (typeof Uint8Array !== "undefined") {
+    (buf as Uint8Array).set(val, pos);
+  } else {
+    for (let i = 0; i < val.length; ++i) buf[pos + i] = val[i];
+  }
+}
+
+function pool(
+  alloc: (size: number) => Uint8Array,
+  slice: (begin?: number, end?: number) => Uint8Array,
+  size?: number
+): (size: number) => Uint8Array {
+  const SIZE = size || 8192;
+  const MAX = SIZE >>> 1;
+  let slab: Uint8Array | null = null;
+  let offset = SIZE;
+  return function pool_alloc(size): Uint8Array {
+    if (size < 1 || size > MAX) return alloc(size);
+    if (offset + size > SIZE) {
+      slab = alloc(SIZE);
+      offset = 0;
+    }
+    const buf: Uint8Array = slice.call(slab, offset, (offset += size));
+    if (offset & 7)
+      // align to 32 bit
+      offset = (offset | 7) + 1;
+    return buf;
+  };
+}
+
+function indexOutOfRange(reader: BinaryReader, writeLength?: number) {
+  return RangeError(
+    "index out of range: " +
+      reader.pos +
+      " + " +
+      (writeLength || 1) +
+      " > " +
+      reader.len
+  );
+}

src/codegen/cosmos/auth/v1beta1/auth.ts

@@ -0,0 +1,497 @@
+import { Any, AnyAmino, AnySDKType } from '../../../google/protobuf/any';
+import { BinaryReader, BinaryWriter } from '../../../binary';
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccount {
+  address: string;
+  pubKey?: Any;
+  accountNumber: bigint;
+  sequence: bigint;
+}
+export interface BaseAccountProtoMsg {
+  typeUrl: '/cosmos.auth.v1beta1.BaseAccount';
+  value: Uint8Array;
+}
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccountAmino {
+  address?: string;
+  pub_key?: AnyAmino;
+  account_number?: string;
+  sequence?: string;
+}
+export interface BaseAccountAminoMsg {
+  type: 'cosmos-sdk/BaseAccount';
+  value: BaseAccountAmino;
+}
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccountSDKType {
+  address: string;
+  pub_key?: AnySDKType;
+  account_number: bigint;
+  sequence: bigint;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccount {
+  baseAccount?: BaseAccount;
+  name: string;
+  permissions: string[];
+}
+export interface ModuleAccountProtoMsg {
+  typeUrl: '/cosmos.auth.v1beta1.ModuleAccount';
+  value: Uint8Array;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccountAmino {
+  base_account?: BaseAccountAmino;
+  name?: string;
+  permissions?: string[];
+}
+export interface ModuleAccountAminoMsg {
+  type: 'cosmos-sdk/ModuleAccount';
+  value: ModuleAccountAmino;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccountSDKType {
+  base_account?: BaseAccountSDKType;
+  name: string;
+  permissions: string[];
+}
+/** Params defines the parameters for the auth module. */
+export interface Params {
+  maxMemoCharacters: bigint;
+  txSigLimit: bigint;
+  txSizeCostPerByte: bigint;
+  sigVerifyCostEd25519: bigint;
+  sigVerifyCostSecp256k1: bigint;
+}
+export interface ParamsProtoMsg {
+  typeUrl: '/cosmos.auth.v1beta1.Params';
+  value: Uint8Array;
+}
+/** Params defines the parameters for the auth module. */
+export interface ParamsAmino {
+  max_memo_characters?: string;
+  tx_sig_limit?: string;
+  tx_size_cost_per_byte?: string;
+  sig_verify_cost_ed25519?: string;
+  sig_verify_cost_secp256k1?: string;
+}
+export interface ParamsAminoMsg {
+  type: 'cosmos-sdk/Params';
+  value: ParamsAmino;
+}
+/** Params defines the parameters for the auth module. */
+export interface ParamsSDKType {
+  max_memo_characters: bigint;
+  tx_sig_limit: bigint;
+  tx_size_cost_per_byte: bigint;
+  sig_verify_cost_ed25519: bigint;
+  sig_verify_cost_secp256k1: bigint;
+}
+function createBaseBaseAccount(): BaseAccount {
+  return {
+    address: '',
+    pubKey: undefined,
+    accountNumber: BigInt(0),
+    sequence: BigInt(0),
+  };
+}
+export const BaseAccount = {
+  typeUrl: '/cosmos.auth.v1beta1.BaseAccount',
+  encode(
+    message: BaseAccount,
+    writer: BinaryWriter = BinaryWriter.create()
+  ): BinaryWriter {
+    if (message.address !== '') {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.pubKey !== undefined) {
+      Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.accountNumber !== BigInt(0)) {
+      writer.uint32(24).uint64(message.accountNumber);
+    }
+    if (message.sequence !== BigInt(0)) {
+      writer.uint32(32).uint64(message.sequence);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): BaseAccount {
+    const reader =
+      input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBaseAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.pubKey = Any.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.accountNumber = reader.uint64();
+          break;
+        case 4:
+          message.sequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<BaseAccount>): BaseAccount {
+    const message = createBaseBaseAccount();
+    message.address = object.address ?? '';
+    message.pubKey =
+      object.pubKey !== undefined && object.pubKey !== null
+        ? Any.fromPartial(object.pubKey)
+        : undefined;
+    message.accountNumber =
+      object.accountNumber !== undefined && object.accountNumber !== null
+        ? BigInt(object.accountNumber.toString())
+        : BigInt(0);
+    message.sequence =
+      object.sequence !== undefined && object.sequence !== null
+        ? BigInt(object.sequence.toString())
+        : BigInt(0);
+    return message;
+  },
+  fromAmino(object: BaseAccountAmino): BaseAccount {
+    const message = createBaseBaseAccount();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.pub_key !== undefined && object.pub_key !== null) {
+      message.pubKey = Any.fromAmino(object.pub_key);
+    }
+    if (object.account_number !== undefined && object.account_number !== null) {
+      message.accountNumber = BigInt(object.account_number);
+    }
+    if (object.sequence !== undefined && object.sequence !== null) {
+      message.sequence = BigInt(object.sequence);
+    }
+    return message;
+  },
+  toAmino(message: BaseAccount): BaseAccountAmino {
+    const obj: any = {};
+    obj.address = message.address === '' ? undefined : message.address;
+    obj.pub_key = message.pubKey ? Any.toAmino(message.pubKey) : undefined;
+    obj.account_number =
+      message.accountNumber !== BigInt(0)
+        ? message.accountNumber.toString()
+        : undefined;
+    obj.sequence =
+      message.sequence !== BigInt(0) ? message.sequence.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: BaseAccountAminoMsg): BaseAccount {
+    return BaseAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message: BaseAccount): BaseAccountAminoMsg {
+    return {
+      type: 'cosmos-sdk/BaseAccount',
+      value: BaseAccount.toAmino(message),
+    };
+  },
+  fromProtoMsg(message: BaseAccountProtoMsg): BaseAccount {
+    return BaseAccount.decode(message.value);
+  },
+  toProto(message: BaseAccount): Uint8Array {
+    return BaseAccount.encode(message).finish();
+  },
+  toProtoMsg(message: BaseAccount): BaseAccountProtoMsg {
+    return {
+      typeUrl: '/cosmos.auth.v1beta1.BaseAccount',
+      value: BaseAccount.encode(message).finish(),
+    };
+  },
+};
+function createBaseModuleAccount(): ModuleAccount {
+  return {
+    baseAccount: undefined,
+    name: '',
+    permissions: [],
+  };
+}
+export const ModuleAccount = {
+  typeUrl: '/cosmos.auth.v1beta1.ModuleAccount',
+  encode(
+    message: ModuleAccount,
+    writer: BinaryWriter = BinaryWriter.create()
+  ): BinaryWriter {
+    if (message.baseAccount !== undefined) {
+      BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    if (message.name !== '') {
+      writer.uint32(18).string(message.name);
+    }
+    for (const v of message.permissions) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ModuleAccount {
+    const reader =
+      input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.permissions.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ModuleAccount>): ModuleAccount {
+    const message = createBaseModuleAccount();
+    message.baseAccount =
+      object.baseAccount !== undefined && object.baseAccount !== null
+        ? BaseAccount.fromPartial(object.baseAccount)
+        : undefined;
+    message.name = object.name ?? '';
+    message.permissions = object.permissions?.map((e) => e) || [];
+    return message;
+  },
+  fromAmino(object: ModuleAccountAmino): ModuleAccount {
+    const message = createBaseModuleAccount();
+    if (object.base_account !== undefined && object.base_account !== null) {
+      message.baseAccount = BaseAccount.fromAmino(object.base_account);
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    message.permissions = object.permissions?.map((e) => e) || [];
+    return message;
+  },
+  toAmino(message: ModuleAccount): ModuleAccountAmino {
+    const obj: any = {};
+    obj.base_account = message.baseAccount
+      ? BaseAccount.toAmino(message.baseAccount)
+      : undefined;
+    obj.name = message.name === '' ? undefined : message.name;
+    if (message.permissions) {
+      obj.permissions = message.permissions.map((e) => e);
+    } else {
+      obj.permissions = message.permissions;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAccountAminoMsg): ModuleAccount {
+    return ModuleAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message: ModuleAccount): ModuleAccountAminoMsg {
+    return {
+      type: 'cosmos-sdk/ModuleAccount',
+      value: ModuleAccount.toAmino(message),
+    };
+  },
+  fromProtoMsg(message: ModuleAccountProtoMsg): ModuleAccount {
+    return ModuleAccount.decode(message.value);
+  },
+  toProto(message: ModuleAccount): Uint8Array {
+    return ModuleAccount.encode(message).finish();
+  },
+  toProtoMsg(message: ModuleAccount): ModuleAccountProtoMsg {
+    return {
+      typeUrl: '/cosmos.auth.v1beta1.ModuleAccount',
+      value: ModuleAccount.encode(message).finish(),
+    };
+  },
+};
+function createBaseParams(): Params {
+  return {
+    maxMemoCharacters: BigInt(0),
+    txSigLimit: BigInt(0),
+    txSizeCostPerByte: BigInt(0),
+    sigVerifyCostEd25519: BigInt(0),
+    sigVerifyCostSecp256k1: BigInt(0),
+  };
+}
+export const Params = {
+  typeUrl: '/cosmos.auth.v1beta1.Params',
+  encode(
+    message: Params,
+    writer: BinaryWriter = BinaryWriter.create()
+  ): BinaryWriter {
+    if (message.maxMemoCharacters !== BigInt(0)) {
+      writer.uint32(8).uint64(message.maxMemoCharacters);
+    }
+    if (message.txSigLimit !== BigInt(0)) {
+      writer.uint32(16).uint64(message.txSigLimit);
+    }
+    if (message.txSizeCostPerByte !== BigInt(0)) {
+      writer.uint32(24).uint64(message.txSizeCostPerByte);
+    }
+    if (message.sigVerifyCostEd25519 !== BigInt(0)) {
+      writer.uint32(32).uint64(message.sigVerifyCostEd25519);
+    }
+    if (message.sigVerifyCostSecp256k1 !== BigInt(0)) {
+      writer.uint32(40).uint64(message.sigVerifyCostSecp256k1);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader =
+      input instanceof BinaryReader ? input : new BinaryReader(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.maxMemoCharacters = reader.uint64();
+          break;
+        case 2:
+          message.txSigLimit = reader.uint64();
+          break;
+        case 3:
+          message.txSizeCostPerByte = reader.uint64();
+          break;
+        case 4:
+          message.sigVerifyCostEd25519 = reader.uint64();
+          break;
+        case 5:
+          message.sigVerifyCostSecp256k1 = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Params>): Params {
+    const message = createBaseParams();
+    message.maxMemoCharacters =
+      object.maxMemoCharacters !== undefined &&
+      object.maxMemoCharacters !== null
+        ? BigInt(object.maxMemoCharacters.toString())
+        : BigInt(0);
+    message.txSigLimit =
+      object.txSigLimit !== undefined && object.txSigLimit !== null
+        ? BigInt(object.txSigLimit.toString())
+        : BigInt(0);
+    message.txSizeCostPerByte =
+      object.txSizeCostPerByte !== undefined &&
+      object.txSizeCostPerByte !== null
+        ? BigInt(object.txSizeCostPerByte.toString())
+        : BigInt(0);
+    message.sigVerifyCostEd25519 =
+      object.sigVerifyCostEd25519 !== undefined &&
+      object.sigVerifyCostEd25519 !== null
+        ? BigInt(object.sigVerifyCostEd25519.toString())
+        : BigInt(0);
+    message.sigVerifyCostSecp256k1 =
+      object.sigVerifyCostSecp256k1 !== undefined &&
+      object.sigVerifyCostSecp256k1 !== null
+        ? BigInt(object.sigVerifyCostSecp256k1.toString())
+        : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (
+      object.max_memo_characters !== undefined &&
+      object.max_memo_characters !== null
+    ) {
+      message.maxMemoCharacters = BigInt(object.max_memo_characters);
+    }
+    if (object.tx_sig_limit !== undefined && object.tx_sig_limit !== null) {
+      message.txSigLimit = BigInt(object.tx_sig_limit);
+    }
+    if (
+      object.tx_size_cost_per_byte !== undefined &&
+      object.tx_size_cost_per_byte !== null
+    ) {
+      message.txSizeCostPerByte = BigInt(object.tx_size_cost_per_byte);
+    }
+    if (
+      object.sig_verify_cost_ed25519 !== undefined &&
+      object.sig_verify_cost_ed25519 !== null
+    ) {
+      message.sigVerifyCostEd25519 = BigInt(object.sig_verify_cost_ed25519);
+    }
+    if (
+      object.sig_verify_cost_secp256k1 !== undefined &&
+      object.sig_verify_cost_secp256k1 !== null
+    ) {
+      message.sigVerifyCostSecp256k1 = BigInt(object.sig_verify_cost_secp256k1);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.max_memo_characters =
+      message.maxMemoCharacters !== BigInt(0)
+        ? message.maxMemoCharacters.toString()
+        : undefined;
+    obj.tx_sig_limit =
+      message.txSigLimit !== BigInt(0)
+        ? message.txSigLimit.toString()
+        : undefined;
+    obj.tx_size_cost_per_byte =
+      message.txSizeCostPerByte !== BigInt(0)
+        ? message.txSizeCostPerByte.toString()
+        : undefined;
+    obj.sig_verify_cost_ed25519 =
+      message.sigVerifyCostEd25519 !== BigInt(0)
+        ? message.sigVerifyCostEd25519.toString()
+        : undefined;
+    obj.sig_verify_cost_secp256k1 =
+      message.sigVerifyCostSecp256k1 !== BigInt(0)
+        ? message.sigVerifyCostSecp256k1.toString()
+        : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: 'cosmos-sdk/Params',
+      value: Params.toAmino(message),
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: '/cosmos.auth.v1beta1.Params',
+      value: Params.encode(message).finish(),
+    };
+  },
+};

src/codegen/cosmos/auth/v1beta1/genesis.ts

@@ -0,0 +1,113 @@
+import { Params, ParamsAmino, ParamsSDKType } from "./auth";
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the auth module's genesis state. */
+export interface GenesisState {
+  /** params defines all the paramaters of the module. */
+  params: Params;
+  /** accounts are the accounts present at genesis. */
+  accounts: Any[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the auth module's genesis state. */
+export interface GenesisStateAmino {
+  /** params defines all the paramaters of the module. */
+  params?: ParamsAmino;
+  /** accounts are the accounts present at genesis. */
+  accounts?: AnyAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the auth module's genesis state. */
+export interface GenesisStateSDKType {
+  params: ParamsSDKType;
+  accounts: AnySDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: Params.fromPartial({}),
+    accounts: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.auth.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.accounts) {
+      Any.encode(v!, writer.uint32(18).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;
+        case 2:
+          message.accounts.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.accounts = object.accounts?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    message.accounts = object.accounts?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    if (message.accounts) {
+      obj.accounts = message.accounts.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.accounts = message.accounts;
+    }
+    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.auth.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/auth/v1beta1/query.lcd.ts

@@ -0,0 +1,47 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAccountsRequest, QueryAccountsResponseSDKType, QueryAccountRequest, QueryAccountResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.accounts = this.accounts.bind(this);
+    this.account = this.account.bind(this);
+    this.params = this.params.bind(this);
+    this.moduleAccountByName = this.moduleAccountByName.bind(this);
+  }
+  /* Accounts returns all the existing accounts
+  
+   Since: cosmos-sdk 0.43 */
+  async accounts(params: QueryAccountsRequest = {
+    pagination: undefined
+  }): Promise<QueryAccountsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/auth/v1beta1/accounts`;
+    return await this.req.get<QueryAccountsResponseSDKType>(endpoint, options);
+  }
+  /* Account returns account details based on address. */
+  async account(params: QueryAccountRequest): Promise<QueryAccountResponseSDKType> {
+    const endpoint = `cosmos/auth/v1beta1/accounts/${params.address}`;
+    return await this.req.get<QueryAccountResponseSDKType>(endpoint);
+  }
+  /* Params queries all parameters. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/auth/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* ModuleAccountByName returns the module account info by module name */
+  async moduleAccountByName(params: QueryModuleAccountByNameRequest): Promise<QueryModuleAccountByNameResponseSDKType> {
+    const endpoint = `cosmos/auth/v1beta1/module_accounts/${params.name}`;
+    return await this.req.get<QueryModuleAccountByNameResponseSDKType>(endpoint);
+  }
+}

src/codegen/cosmos/auth/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,69 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /**
+   * Accounts returns all the existing accounts
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  accounts(request?: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+  /** Account returns account details based on address. */
+  account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+  /** Params queries all parameters. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** ModuleAccountByName returns the module account info by module name */
+  moduleAccountByName(request: QueryModuleAccountByNameRequest): Promise<QueryModuleAccountByNameResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.accounts = this.accounts.bind(this);
+    this.account = this.account.bind(this);
+    this.params = this.params.bind(this);
+    this.moduleAccountByName = this.moduleAccountByName.bind(this);
+  }
+  accounts(request: QueryAccountsRequest = {
+    pagination: undefined
+  }): Promise<QueryAccountsResponse> {
+    const data = QueryAccountsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Accounts", data);
+    return promise.then(data => QueryAccountsResponse.decode(new BinaryReader(data)));
+  }
+  account(request: QueryAccountRequest): Promise<QueryAccountResponse> {
+    const data = QueryAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Account", data);
+    return promise.then(data => QueryAccountResponse.decode(new BinaryReader(data)));
+  }
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  moduleAccountByName(request: QueryModuleAccountByNameRequest): Promise<QueryModuleAccountByNameResponse> {
+    const data = QueryModuleAccountByNameRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "ModuleAccountByName", data);
+    return promise.then(data => QueryModuleAccountByNameResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    accounts(request?: QueryAccountsRequest): Promise<QueryAccountsResponse> {
+      return queryService.accounts(request);
+    },
+    account(request: QueryAccountRequest): Promise<QueryAccountResponse> {
+      return queryService.account(request);
+    },
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    moduleAccountByName(request: QueryModuleAccountByNameRequest): Promise<QueryModuleAccountByNameResponse> {
+      return queryService.moduleAccountByName(request);
+    }
+  };
+};

src/codegen/cosmos/auth/v1beta1/query.ts

@@ -0,0 +1,750 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { Params, ParamsAmino, ParamsSDKType } from "./auth";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * QueryAccountsRequest is the request type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsRequest {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryAccountsRequestProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountsRequest";
+  value: Uint8Array;
+}
+/**
+ * QueryAccountsRequest is the request type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsRequestAmino {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryAccountsRequestAminoMsg {
+  type: "cosmos-sdk/QueryAccountsRequest";
+  value: QueryAccountsRequestAmino;
+}
+/**
+ * QueryAccountsRequest is the request type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsRequestSDKType {
+  pagination?: PageRequestSDKType;
+}
+/**
+ * QueryAccountsResponse is the response type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsResponse {
+  /** accounts are the existing accounts */
+  accounts: Any[];
+  /** pagination defines the pagination in the response. */
+  pagination?: PageResponse;
+}
+export interface QueryAccountsResponseProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountsResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryAccountsResponse is the response type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsResponseAmino {
+  /** accounts are the existing accounts */
+  accounts?: AnyAmino[];
+  /** pagination defines the pagination in the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryAccountsResponseAminoMsg {
+  type: "cosmos-sdk/QueryAccountsResponse";
+  value: QueryAccountsResponseAmino;
+}
+/**
+ * QueryAccountsResponse is the response type for the Query/Accounts RPC method.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsResponseSDKType {
+  accounts: AnySDKType[];
+  pagination?: PageResponseSDKType;
+}
+/** QueryAccountRequest is the request type for the Query/Account RPC method. */
+export interface QueryAccountRequest {
+  /** address defines the address to query for. */
+  address: string;
+}
+export interface QueryAccountRequestProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountRequest";
+  value: Uint8Array;
+}
+/** QueryAccountRequest is the request type for the Query/Account RPC method. */
+export interface QueryAccountRequestAmino {
+  /** address defines the address to query for. */
+  address?: string;
+}
+export interface QueryAccountRequestAminoMsg {
+  type: "cosmos-sdk/QueryAccountRequest";
+  value: QueryAccountRequestAmino;
+}
+/** QueryAccountRequest is the request type for the Query/Account RPC method. */
+export interface QueryAccountRequestSDKType {
+  address: string;
+}
+/** QueryAccountResponse is the response type for the Query/Account RPC method. */
+export interface QueryAccountResponse {
+  /** account defines the account of the corresponding address. */
+  account?: Any;
+}
+export interface QueryAccountResponseProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountResponse";
+  value: Uint8Array;
+}
+/** QueryAccountResponse is the response type for the Query/Account RPC method. */
+export interface QueryAccountResponseAmino {
+  /** account defines the account of the corresponding address. */
+  account?: AnyAmino;
+}
+export interface QueryAccountResponseAminoMsg {
+  type: "cosmos-sdk/QueryAccountResponse";
+  value: QueryAccountResponseAmino;
+}
+/** QueryAccountResponse is the response type for the Query/Account RPC method. */
+export interface QueryAccountResponseSDKType {
+  account?: AnySDKType;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {}
+export interface QueryParamsRequestProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryParamsRequest";
+  value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {}
+export interface QueryParamsRequestAminoMsg {
+  type: "cosmos-sdk/QueryParamsRequest";
+  value: QueryParamsRequestAmino;
+}
+/** 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 defines the parameters of the module. */
+  params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+  typeUrl: "/cosmos.auth.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: "cosmos-sdk/QueryParamsResponse";
+  value: QueryParamsResponseAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseSDKType {
+  params: ParamsSDKType;
+}
+/** QueryModuleAccountByNameRequest is the request type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameRequest {
+  name: string;
+}
+export interface QueryModuleAccountByNameRequestProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameRequest";
+  value: Uint8Array;
+}
+/** QueryModuleAccountByNameRequest is the request type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameRequestAmino {
+  name?: string;
+}
+export interface QueryModuleAccountByNameRequestAminoMsg {
+  type: "cosmos-sdk/QueryModuleAccountByNameRequest";
+  value: QueryModuleAccountByNameRequestAmino;
+}
+/** QueryModuleAccountByNameRequest is the request type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameRequestSDKType {
+  name: string;
+}
+/** QueryModuleAccountByNameResponse is the response type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameResponse {
+  account?: Any;
+}
+export interface QueryModuleAccountByNameResponseProtoMsg {
+  typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameResponse";
+  value: Uint8Array;
+}
+/** QueryModuleAccountByNameResponse is the response type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameResponseAmino {
+  account?: AnyAmino;
+}
+export interface QueryModuleAccountByNameResponseAminoMsg {
+  type: "cosmos-sdk/QueryModuleAccountByNameResponse";
+  value: QueryModuleAccountByNameResponseAmino;
+}
+/** QueryModuleAccountByNameResponse is the response type for the Query/ModuleAccountByName RPC method. */
+export interface QueryModuleAccountByNameResponseSDKType {
+  account?: AnySDKType;
+}
+function createBaseQueryAccountsRequest(): QueryAccountsRequest {
+  return {
+    pagination: undefined
+  };
+}
+export const QueryAccountsRequest = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountsRequest",
+  encode(message: QueryAccountsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAccountsRequest>): QueryAccountsRequest {
+    const message = createBaseQueryAccountsRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAccountsRequestAmino): QueryAccountsRequest {
+    const message = createBaseQueryAccountsRequest();
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAccountsRequest): QueryAccountsRequestAmino {
+    const obj: any = {};
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAccountsRequestAminoMsg): QueryAccountsRequest {
+    return QueryAccountsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAccountsRequest): QueryAccountsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAccountsRequest",
+      value: QueryAccountsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAccountsRequestProtoMsg): QueryAccountsRequest {
+    return QueryAccountsRequest.decode(message.value);
+  },
+  toProto(message: QueryAccountsRequest): Uint8Array {
+    return QueryAccountsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAccountsRequest): QueryAccountsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryAccountsRequest",
+      value: QueryAccountsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAccountsResponse(): QueryAccountsResponse {
+  return {
+    accounts: [],
+    pagination: undefined
+  };
+}
+export const QueryAccountsResponse = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountsResponse",
+  encode(message: QueryAccountsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.accounts) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.accounts.push(Any.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAccountsResponse>): QueryAccountsResponse {
+    const message = createBaseQueryAccountsResponse();
+    message.accounts = object.accounts?.map(e => Any.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAccountsResponseAmino): QueryAccountsResponse {
+    const message = createBaseQueryAccountsResponse();
+    message.accounts = object.accounts?.map(e => Any.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAccountsResponse): QueryAccountsResponseAmino {
+    const obj: any = {};
+    if (message.accounts) {
+      obj.accounts = message.accounts.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.accounts = message.accounts;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAccountsResponseAminoMsg): QueryAccountsResponse {
+    return QueryAccountsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAccountsResponse): QueryAccountsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAccountsResponse",
+      value: QueryAccountsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAccountsResponseProtoMsg): QueryAccountsResponse {
+    return QueryAccountsResponse.decode(message.value);
+  },
+  toProto(message: QueryAccountsResponse): Uint8Array {
+    return QueryAccountsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAccountsResponse): QueryAccountsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryAccountsResponse",
+      value: QueryAccountsResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAccountRequest(): QueryAccountRequest {
+  return {
+    address: ""
+  };
+}
+export const QueryAccountRequest = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountRequest",
+  encode(message: QueryAccountRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAccountRequest>): QueryAccountRequest {
+    const message = createBaseQueryAccountRequest();
+    message.address = object.address ?? "";
+    return message;
+  },
+  fromAmino(object: QueryAccountRequestAmino): QueryAccountRequest {
+    const message = createBaseQueryAccountRequest();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    return message;
+  },
+  toAmino(message: QueryAccountRequest): QueryAccountRequestAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAccountRequestAminoMsg): QueryAccountRequest {
+    return QueryAccountRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAccountRequest): QueryAccountRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAccountRequest",
+      value: QueryAccountRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAccountRequestProtoMsg): QueryAccountRequest {
+    return QueryAccountRequest.decode(message.value);
+  },
+  toProto(message: QueryAccountRequest): Uint8Array {
+    return QueryAccountRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAccountRequest): QueryAccountRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryAccountRequest",
+      value: QueryAccountRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAccountResponse(): QueryAccountResponse {
+  return {
+    account: undefined
+  };
+}
+export const QueryAccountResponse = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryAccountResponse",
+  encode(message: QueryAccountResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.account !== undefined) {
+      Any.encode(message.account, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAccountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.account = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAccountResponse>): QueryAccountResponse {
+    const message = createBaseQueryAccountResponse();
+    message.account = object.account !== undefined && object.account !== null ? Any.fromPartial(object.account) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAccountResponseAmino): QueryAccountResponse {
+    const message = createBaseQueryAccountResponse();
+    if (object.account !== undefined && object.account !== null) {
+      message.account = Any.fromAmino(object.account);
+    }
+    return message;
+  },
+  toAmino(message: QueryAccountResponse): QueryAccountResponseAmino {
+    const obj: any = {};
+    obj.account = message.account ? Any.toAmino(message.account) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAccountResponseAminoMsg): QueryAccountResponse {
+    return QueryAccountResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAccountResponse): QueryAccountResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAccountResponse",
+      value: QueryAccountResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAccountResponseProtoMsg): QueryAccountResponse {
+    return QueryAccountResponse.decode(message.value);
+  },
+  toProto(message: QueryAccountResponse): Uint8Array {
+    return QueryAccountResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAccountResponse): QueryAccountResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryAccountResponse",
+      value: QueryAccountResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+export const QueryParamsRequest = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryParamsRequest",
+  encode(_: QueryParamsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof BinaryReader ? input : new 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(_: Partial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  toAmino(_: QueryParamsRequest): QueryParamsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest {
+    return QueryParamsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsRequest",
+      value: QueryParamsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest {
+    return QueryParamsRequest.decode(message.value);
+  },
+  toProto(message: QueryParamsRequest): Uint8Array {
+    return QueryParamsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryParamsRequest",
+      value: QueryParamsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: Params.fromPartial({})
+  };
+}
+export const QueryParamsResponse = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryParamsResponse",
+  encode(message: QueryParamsResponse, 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): QueryParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new 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 = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: QueryParamsResponse): QueryParamsResponseAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse {
+    return QueryParamsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsResponse",
+      value: QueryParamsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse {
+    return QueryParamsResponse.decode(message.value);
+  },
+  toProto(message: QueryParamsResponse): Uint8Array {
+    return QueryParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryParamsResponse",
+      value: QueryParamsResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryModuleAccountByNameRequest(): QueryModuleAccountByNameRequest {
+  return {
+    name: ""
+  };
+}
+export const QueryModuleAccountByNameRequest = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameRequest",
+  encode(message: QueryModuleAccountByNameRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryModuleAccountByNameRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryModuleAccountByNameRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryModuleAccountByNameRequest>): QueryModuleAccountByNameRequest {
+    const message = createBaseQueryModuleAccountByNameRequest();
+    message.name = object.name ?? "";
+    return message;
+  },
+  fromAmino(object: QueryModuleAccountByNameRequestAmino): QueryModuleAccountByNameRequest {
+    const message = createBaseQueryModuleAccountByNameRequest();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    return message;
+  },
+  toAmino(message: QueryModuleAccountByNameRequest): QueryModuleAccountByNameRequestAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    return obj;
+  },
+  fromAminoMsg(object: QueryModuleAccountByNameRequestAminoMsg): QueryModuleAccountByNameRequest {
+    return QueryModuleAccountByNameRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryModuleAccountByNameRequest): QueryModuleAccountByNameRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryModuleAccountByNameRequest",
+      value: QueryModuleAccountByNameRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryModuleAccountByNameRequestProtoMsg): QueryModuleAccountByNameRequest {
+    return QueryModuleAccountByNameRequest.decode(message.value);
+  },
+  toProto(message: QueryModuleAccountByNameRequest): Uint8Array {
+    return QueryModuleAccountByNameRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryModuleAccountByNameRequest): QueryModuleAccountByNameRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameRequest",
+      value: QueryModuleAccountByNameRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryModuleAccountByNameResponse(): QueryModuleAccountByNameResponse {
+  return {
+    account: undefined
+  };
+}
+export const QueryModuleAccountByNameResponse = {
+  typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameResponse",
+  encode(message: QueryModuleAccountByNameResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.account !== undefined) {
+      Any.encode(message.account, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryModuleAccountByNameResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryModuleAccountByNameResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.account = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryModuleAccountByNameResponse>): QueryModuleAccountByNameResponse {
+    const message = createBaseQueryModuleAccountByNameResponse();
+    message.account = object.account !== undefined && object.account !== null ? Any.fromPartial(object.account) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryModuleAccountByNameResponseAmino): QueryModuleAccountByNameResponse {
+    const message = createBaseQueryModuleAccountByNameResponse();
+    if (object.account !== undefined && object.account !== null) {
+      message.account = Any.fromAmino(object.account);
+    }
+    return message;
+  },
+  toAmino(message: QueryModuleAccountByNameResponse): QueryModuleAccountByNameResponseAmino {
+    const obj: any = {};
+    obj.account = message.account ? Any.toAmino(message.account) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryModuleAccountByNameResponseAminoMsg): QueryModuleAccountByNameResponse {
+    return QueryModuleAccountByNameResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryModuleAccountByNameResponse): QueryModuleAccountByNameResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryModuleAccountByNameResponse",
+      value: QueryModuleAccountByNameResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryModuleAccountByNameResponseProtoMsg): QueryModuleAccountByNameResponse {
+    return QueryModuleAccountByNameResponse.decode(message.value);
+  },
+  toProto(message: QueryModuleAccountByNameResponse): Uint8Array {
+    return QueryModuleAccountByNameResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryModuleAccountByNameResponse): QueryModuleAccountByNameResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.QueryModuleAccountByNameResponse",
+      value: QueryModuleAccountByNameResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/authz/v1beta1/authz.ts

@@ -0,0 +1,366 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+/**
+ * GenericAuthorization gives the grantee unrestricted permissions to execute
+ * the provided method on behalf of the granter's account.
+ */
+export interface GenericAuthorization {
+  /** Msg, identified by it's type URL, to grant unrestricted permissions to execute */
+  msg: string;
+}
+export interface GenericAuthorizationProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.GenericAuthorization";
+  value: Uint8Array;
+}
+/**
+ * GenericAuthorization gives the grantee unrestricted permissions to execute
+ * the provided method on behalf of the granter's account.
+ */
+export interface GenericAuthorizationAmino {
+  /** Msg, identified by it's type URL, to grant unrestricted permissions to execute */
+  msg?: string;
+}
+export interface GenericAuthorizationAminoMsg {
+  type: "cosmos-sdk/GenericAuthorization";
+  value: GenericAuthorizationAmino;
+}
+/**
+ * GenericAuthorization gives the grantee unrestricted permissions to execute
+ * the provided method on behalf of the granter's account.
+ */
+export interface GenericAuthorizationSDKType {
+  msg: string;
+}
+/**
+ * Grant gives permissions to execute
+ * the provide method with expiration time.
+ */
+export interface Grant {
+  authorization?: Any;
+  expiration: Date;
+}
+export interface GrantProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.Grant";
+  value: Uint8Array;
+}
+/**
+ * Grant gives permissions to execute
+ * the provide method with expiration time.
+ */
+export interface GrantAmino {
+  authorization?: AnyAmino;
+  expiration?: string;
+}
+export interface GrantAminoMsg {
+  type: "cosmos-sdk/Grant";
+  value: GrantAmino;
+}
+/**
+ * Grant gives permissions to execute
+ * the provide method with expiration time.
+ */
+export interface GrantSDKType {
+  authorization?: AnySDKType;
+  expiration: Date;
+}
+/**
+ * GrantAuthorization extends a grant with both the addresses of the grantee and granter.
+ * It is used in genesis.proto and query.proto
+ * 
+ * Since: cosmos-sdk 0.45.2
+ */
+export interface GrantAuthorization {
+  granter: string;
+  grantee: string;
+  authorization?: Any;
+  expiration: Date;
+}
+export interface GrantAuthorizationProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.GrantAuthorization";
+  value: Uint8Array;
+}
+/**
+ * GrantAuthorization extends a grant with both the addresses of the grantee and granter.
+ * It is used in genesis.proto and query.proto
+ * 
+ * Since: cosmos-sdk 0.45.2
+ */
+export interface GrantAuthorizationAmino {
+  granter?: string;
+  grantee?: string;
+  authorization?: AnyAmino;
+  expiration?: string;
+}
+export interface GrantAuthorizationAminoMsg {
+  type: "cosmos-sdk/GrantAuthorization";
+  value: GrantAuthorizationAmino;
+}
+/**
+ * GrantAuthorization extends a grant with both the addresses of the grantee and granter.
+ * It is used in genesis.proto and query.proto
+ * 
+ * Since: cosmos-sdk 0.45.2
+ */
+export interface GrantAuthorizationSDKType {
+  granter: string;
+  grantee: string;
+  authorization?: AnySDKType;
+  expiration: Date;
+}
+function createBaseGenericAuthorization(): GenericAuthorization {
+  return {
+    msg: ""
+  };
+}
+export const GenericAuthorization = {
+  typeUrl: "/cosmos.authz.v1beta1.GenericAuthorization",
+  encode(message: GenericAuthorization, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.msg !== "") {
+      writer.uint32(10).string(message.msg);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenericAuthorization {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenericAuthorization();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.msg = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenericAuthorization>): GenericAuthorization {
+    const message = createBaseGenericAuthorization();
+    message.msg = object.msg ?? "";
+    return message;
+  },
+  fromAmino(object: GenericAuthorizationAmino): GenericAuthorization {
+    const message = createBaseGenericAuthorization();
+    if (object.msg !== undefined && object.msg !== null) {
+      message.msg = object.msg;
+    }
+    return message;
+  },
+  toAmino(message: GenericAuthorization): GenericAuthorizationAmino {
+    const obj: any = {};
+    obj.msg = message.msg === "" ? undefined : message.msg;
+    return obj;
+  },
+  fromAminoMsg(object: GenericAuthorizationAminoMsg): GenericAuthorization {
+    return GenericAuthorization.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenericAuthorization): GenericAuthorizationAminoMsg {
+    return {
+      type: "cosmos-sdk/GenericAuthorization",
+      value: GenericAuthorization.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenericAuthorizationProtoMsg): GenericAuthorization {
+    return GenericAuthorization.decode(message.value);
+  },
+  toProto(message: GenericAuthorization): Uint8Array {
+    return GenericAuthorization.encode(message).finish();
+  },
+  toProtoMsg(message: GenericAuthorization): GenericAuthorizationProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.GenericAuthorization",
+      value: GenericAuthorization.encode(message).finish()
+    };
+  }
+};
+function createBaseGrant(): Grant {
+  return {
+    authorization: undefined,
+    expiration: new Date()
+  };
+}
+export const Grant = {
+  typeUrl: "/cosmos.authz.v1beta1.Grant",
+  encode(message: Grant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authorization !== undefined) {
+      Any.encode(message.authorization, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.expiration !== undefined) {
+      Timestamp.encode(toTimestamp(message.expiration), writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Grant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGrant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authorization = Any.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.expiration = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Grant>): Grant {
+    const message = createBaseGrant();
+    message.authorization = object.authorization !== undefined && object.authorization !== null ? Any.fromPartial(object.authorization) : undefined;
+    message.expiration = object.expiration ?? undefined;
+    return message;
+  },
+  fromAmino(object: GrantAmino): Grant {
+    const message = createBaseGrant();
+    if (object.authorization !== undefined && object.authorization !== null) {
+      message.authorization = Any.fromAmino(object.authorization);
+    }
+    if (object.expiration !== undefined && object.expiration !== null) {
+      message.expiration = fromTimestamp(Timestamp.fromAmino(object.expiration));
+    }
+    return message;
+  },
+  toAmino(message: Grant): GrantAmino {
+    const obj: any = {};
+    obj.authorization = message.authorization ? Any.toAmino(message.authorization) : undefined;
+    obj.expiration = message.expiration ? Timestamp.toAmino(toTimestamp(message.expiration)) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GrantAminoMsg): Grant {
+    return Grant.fromAmino(object.value);
+  },
+  toAminoMsg(message: Grant): GrantAminoMsg {
+    return {
+      type: "cosmos-sdk/Grant",
+      value: Grant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GrantProtoMsg): Grant {
+    return Grant.decode(message.value);
+  },
+  toProto(message: Grant): Uint8Array {
+    return Grant.encode(message).finish();
+  },
+  toProtoMsg(message: Grant): GrantProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.Grant",
+      value: Grant.encode(message).finish()
+    };
+  }
+};
+function createBaseGrantAuthorization(): GrantAuthorization {
+  return {
+    granter: "",
+    grantee: "",
+    authorization: undefined,
+    expiration: new Date()
+  };
+}
+export const GrantAuthorization = {
+  typeUrl: "/cosmos.authz.v1beta1.GrantAuthorization",
+  encode(message: GrantAuthorization, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.authorization !== undefined) {
+      Any.encode(message.authorization, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.expiration !== undefined) {
+      Timestamp.encode(toTimestamp(message.expiration), writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GrantAuthorization {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGrantAuthorization();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.authorization = Any.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.expiration = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GrantAuthorization>): GrantAuthorization {
+    const message = createBaseGrantAuthorization();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.authorization = object.authorization !== undefined && object.authorization !== null ? Any.fromPartial(object.authorization) : undefined;
+    message.expiration = object.expiration ?? undefined;
+    return message;
+  },
+  fromAmino(object: GrantAuthorizationAmino): GrantAuthorization {
+    const message = createBaseGrantAuthorization();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.authorization !== undefined && object.authorization !== null) {
+      message.authorization = Any.fromAmino(object.authorization);
+    }
+    if (object.expiration !== undefined && object.expiration !== null) {
+      message.expiration = fromTimestamp(Timestamp.fromAmino(object.expiration));
+    }
+    return message;
+  },
+  toAmino(message: GrantAuthorization): GrantAuthorizationAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.authorization = message.authorization ? Any.toAmino(message.authorization) : undefined;
+    obj.expiration = message.expiration ? Timestamp.toAmino(toTimestamp(message.expiration)) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GrantAuthorizationAminoMsg): GrantAuthorization {
+    return GrantAuthorization.fromAmino(object.value);
+  },
+  toAminoMsg(message: GrantAuthorization): GrantAuthorizationAminoMsg {
+    return {
+      type: "cosmos-sdk/GrantAuthorization",
+      value: GrantAuthorization.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GrantAuthorizationProtoMsg): GrantAuthorization {
+    return GrantAuthorization.decode(message.value);
+  },
+  toProto(message: GrantAuthorization): Uint8Array {
+    return GrantAuthorization.encode(message).finish();
+  },
+  toProtoMsg(message: GrantAuthorization): GrantAuthorizationProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.GrantAuthorization",
+      value: GrantAuthorization.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/authz/v1beta1/event.ts

@@ -0,0 +1,251 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrant {
+  /** Msg type URL for which an autorization is granted */
+  msgTypeUrl: string;
+  /** Granter account address */
+  granter: string;
+  /** Grantee account address */
+  grantee: string;
+}
+export interface EventGrantProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.EventGrant";
+  value: Uint8Array;
+}
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrantAmino {
+  /** Msg type URL for which an autorization is granted */
+  msg_type_url?: string;
+  /** Granter account address */
+  granter?: string;
+  /** Grantee account address */
+  grantee?: string;
+}
+export interface EventGrantAminoMsg {
+  type: "cosmos-sdk/EventGrant";
+  value: EventGrantAmino;
+}
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrantSDKType {
+  msg_type_url: string;
+  granter: string;
+  grantee: string;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevoke {
+  /** Msg type URL for which an autorization is revoked */
+  msgTypeUrl: string;
+  /** Granter account address */
+  granter: string;
+  /** Grantee account address */
+  grantee: string;
+}
+export interface EventRevokeProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.EventRevoke";
+  value: Uint8Array;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevokeAmino {
+  /** Msg type URL for which an autorization is revoked */
+  msg_type_url?: string;
+  /** Granter account address */
+  granter?: string;
+  /** Grantee account address */
+  grantee?: string;
+}
+export interface EventRevokeAminoMsg {
+  type: "cosmos-sdk/EventRevoke";
+  value: EventRevokeAmino;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevokeSDKType {
+  msg_type_url: string;
+  granter: string;
+  grantee: string;
+}
+function createBaseEventGrant(): EventGrant {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventGrant = {
+  typeUrl: "/cosmos.authz.v1beta1.EventGrant",
+  encode(message: EventGrant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(18).string(message.msgTypeUrl);
+    }
+    if (message.granter !== "") {
+      writer.uint32(26).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(34).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EventGrant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventGrant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.msgTypeUrl = reader.string();
+          break;
+        case 3:
+          message.granter = reader.string();
+          break;
+        case 4:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<EventGrant>): EventGrant {
+    const message = createBaseEventGrant();
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: EventGrantAmino): EventGrant {
+    const message = createBaseEventGrant();
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: EventGrant): EventGrantAmino {
+    const obj: any = {};
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: EventGrantAminoMsg): EventGrant {
+    return EventGrant.fromAmino(object.value);
+  },
+  toAminoMsg(message: EventGrant): EventGrantAminoMsg {
+    return {
+      type: "cosmos-sdk/EventGrant",
+      value: EventGrant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EventGrantProtoMsg): EventGrant {
+    return EventGrant.decode(message.value);
+  },
+  toProto(message: EventGrant): Uint8Array {
+    return EventGrant.encode(message).finish();
+  },
+  toProtoMsg(message: EventGrant): EventGrantProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.EventGrant",
+      value: EventGrant.encode(message).finish()
+    };
+  }
+};
+function createBaseEventRevoke(): EventRevoke {
+  return {
+    msgTypeUrl: "",
+    granter: "",
+    grantee: ""
+  };
+}
+export const EventRevoke = {
+  typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
+  encode(message: EventRevoke, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(18).string(message.msgTypeUrl);
+    }
+    if (message.granter !== "") {
+      writer.uint32(26).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(34).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EventRevoke {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventRevoke();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.msgTypeUrl = reader.string();
+          break;
+        case 3:
+          message.granter = reader.string();
+          break;
+        case 4:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<EventRevoke>): EventRevoke {
+    const message = createBaseEventRevoke();
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: EventRevokeAmino): EventRevoke {
+    const message = createBaseEventRevoke();
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: EventRevoke): EventRevokeAmino {
+    const obj: any = {};
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: EventRevokeAminoMsg): EventRevoke {
+    return EventRevoke.fromAmino(object.value);
+  },
+  toAminoMsg(message: EventRevoke): EventRevokeAminoMsg {
+    return {
+      type: "cosmos-sdk/EventRevoke",
+      value: EventRevoke.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EventRevokeProtoMsg): EventRevoke {
+    return EventRevoke.decode(message.value);
+  },
+  toProto(message: EventRevoke): Uint8Array {
+    return EventRevoke.encode(message).finish();
+  },
+  toProtoMsg(message: EventRevoke): EventRevokeProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.EventRevoke",
+      value: EventRevoke.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/authz/v1beta1/genesis.ts

@@ -0,0 +1,93 @@
+import { GrantAuthorization, GrantAuthorizationAmino, GrantAuthorizationSDKType } from "./authz";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisState {
+  authorization: GrantAuthorization[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisStateAmino {
+  authorization?: GrantAuthorizationAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisStateSDKType {
+  authorization: GrantAuthorizationSDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    authorization: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.authz.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.authorization) {
+      GrantAuthorization.encode(v!, 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.authorization.push(GrantAuthorization.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.authorization = object.authorization?.map(e => GrantAuthorization.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.authorization = object.authorization?.map(e => GrantAuthorization.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.authorization) {
+      obj.authorization = message.authorization.map(e => e ? GrantAuthorization.toAmino(e) : undefined);
+    } else {
+      obj.authorization = message.authorization;
+    }
+    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.authz.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/authz/v1beta1/query.lcd.ts

@@ -0,0 +1,62 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryGrantsRequest, QueryGrantsResponseSDKType, QueryGranterGrantsRequest, QueryGranterGrantsResponseSDKType, QueryGranteeGrantsRequest, QueryGranteeGrantsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.grants = this.grants.bind(this);
+    this.granterGrants = this.granterGrants.bind(this);
+    this.granteeGrants = this.granteeGrants.bind(this);
+  }
+  /* Returns list of `Authorization`, granted to the grantee by the granter. */
+  async grants(params: QueryGrantsRequest): Promise<QueryGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.granter !== "undefined") {
+      options.params.granter = params.granter;
+    }
+    if (typeof params?.grantee !== "undefined") {
+      options.params.grantee = params.grantee;
+    }
+    if (typeof params?.msgTypeUrl !== "undefined") {
+      options.params.msg_type_url = params.msgTypeUrl;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants`;
+    return await this.req.get<QueryGrantsResponseSDKType>(endpoint, options);
+  }
+  /* GranterGrants returns list of `GrantAuthorization`, granted by granter.
+  
+   Since: cosmos-sdk 0.45.2 */
+  async granterGrants(params: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants/granter/${params.granter}`;
+    return await this.req.get<QueryGranterGrantsResponseSDKType>(endpoint, options);
+  }
+  /* GranteeGrants returns a list of `GrantAuthorization` by grantee.
+  
+   Since: cosmos-sdk 0.45.2 */
+  async granteeGrants(params: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/authz/v1beta1/grants/grantee/${params.grantee}`;
+    return await this.req.get<QueryGranteeGrantsResponseSDKType>(endpoint, options);
+  }
+}

src/codegen/cosmos/authz/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,60 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Returns list of `Authorization`, granted to the grantee by the granter. */
+  grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse>;
+  /**
+   * GranterGrants returns list of `GrantAuthorization`, granted by granter.
+   * 
+   * Since: cosmos-sdk 0.45.2
+   */
+  granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse>;
+  /**
+   * GranteeGrants returns a list of `GrantAuthorization` by grantee.
+   * 
+   * Since: cosmos-sdk 0.45.2
+   */
+  granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.grants = this.grants.bind(this);
+    this.granterGrants = this.granterGrants.bind(this);
+    this.granteeGrants = this.granteeGrants.bind(this);
+  }
+  grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse> {
+    const data = QueryGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "Grants", data);
+    return promise.then(data => QueryGrantsResponse.decode(new BinaryReader(data)));
+  }
+  granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse> {
+    const data = QueryGranterGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "GranterGrants", data);
+    return promise.then(data => QueryGranterGrantsResponse.decode(new BinaryReader(data)));
+  }
+  granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse> {
+    const data = QueryGranteeGrantsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Query", "GranteeGrants", data);
+    return promise.then(data => QueryGranteeGrantsResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse> {
+      return queryService.grants(request);
+    },
+    granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse> {
+      return queryService.granterGrants(request);
+    },
+    granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse> {
+      return queryService.granteeGrants(request);
+    }
+  };
+};

src/codegen/cosmos/authz/v1beta1/query.ts

@@ -0,0 +1,683 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { Grant, GrantAmino, GrantSDKType, GrantAuthorization, GrantAuthorizationAmino, GrantAuthorizationSDKType } from "./authz";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** QueryGrantsRequest is the request type for the Query/Grants RPC method. */
+export interface QueryGrantsRequest {
+  granter: string;
+  grantee: string;
+  /** Optional, msg_type_url, when set, will query only grants matching given msg type. */
+  msgTypeUrl: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryGrantsRequestProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGrantsRequest";
+  value: Uint8Array;
+}
+/** QueryGrantsRequest is the request type for the Query/Grants RPC method. */
+export interface QueryGrantsRequestAmino {
+  granter?: string;
+  grantee?: string;
+  /** Optional, msg_type_url, when set, will query only grants matching given msg type. */
+  msg_type_url?: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryGrantsRequestAminoMsg {
+  type: "cosmos-sdk/QueryGrantsRequest";
+  value: QueryGrantsRequestAmino;
+}
+/** QueryGrantsRequest is the request type for the Query/Grants RPC method. */
+export interface QueryGrantsRequestSDKType {
+  granter: string;
+  grantee: string;
+  msg_type_url: string;
+  pagination?: PageRequestSDKType;
+}
+/** QueryGrantsResponse is the response type for the Query/Authorizations RPC method. */
+export interface QueryGrantsResponse {
+  /** authorizations is a list of grants granted for grantee by granter. */
+  grants: Grant[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponse;
+}
+export interface QueryGrantsResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGrantsResponse";
+  value: Uint8Array;
+}
+/** QueryGrantsResponse is the response type for the Query/Authorizations RPC method. */
+export interface QueryGrantsResponseAmino {
+  /** authorizations is a list of grants granted for grantee by granter. */
+  grants?: GrantAmino[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryGrantsResponseAminoMsg {
+  type: "cosmos-sdk/QueryGrantsResponse";
+  value: QueryGrantsResponseAmino;
+}
+/** QueryGrantsResponse is the response type for the Query/Authorizations RPC method. */
+export interface QueryGrantsResponseSDKType {
+  grants: GrantSDKType[];
+  pagination?: PageResponseSDKType;
+}
+/** QueryGranterGrantsRequest is the request type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsRequest {
+  granter: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryGranterGrantsRequestProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsRequest";
+  value: Uint8Array;
+}
+/** QueryGranterGrantsRequest is the request type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsRequestAmino {
+  granter?: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryGranterGrantsRequestAminoMsg {
+  type: "cosmos-sdk/QueryGranterGrantsRequest";
+  value: QueryGranterGrantsRequestAmino;
+}
+/** QueryGranterGrantsRequest is the request type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsRequestSDKType {
+  granter: string;
+  pagination?: PageRequestSDKType;
+}
+/** QueryGranterGrantsResponse is the response type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsResponse {
+  /** grants is a list of grants granted by the granter. */
+  grants: GrantAuthorization[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponse;
+}
+export interface QueryGranterGrantsResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsResponse";
+  value: Uint8Array;
+}
+/** QueryGranterGrantsResponse is the response type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsResponseAmino {
+  /** grants is a list of grants granted by the granter. */
+  grants?: GrantAuthorizationAmino[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryGranterGrantsResponseAminoMsg {
+  type: "cosmos-sdk/QueryGranterGrantsResponse";
+  value: QueryGranterGrantsResponseAmino;
+}
+/** QueryGranterGrantsResponse is the response type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsResponseSDKType {
+  grants: GrantAuthorizationSDKType[];
+  pagination?: PageResponseSDKType;
+}
+/** QueryGranteeGrantsRequest is the request type for the Query/IssuedGrants RPC method. */
+export interface QueryGranteeGrantsRequest {
+  grantee: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryGranteeGrantsRequestProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsRequest";
+  value: Uint8Array;
+}
+/** QueryGranteeGrantsRequest is the request type for the Query/IssuedGrants RPC method. */
+export interface QueryGranteeGrantsRequestAmino {
+  grantee?: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryGranteeGrantsRequestAminoMsg {
+  type: "cosmos-sdk/QueryGranteeGrantsRequest";
+  value: QueryGranteeGrantsRequestAmino;
+}
+/** QueryGranteeGrantsRequest is the request type for the Query/IssuedGrants RPC method. */
+export interface QueryGranteeGrantsRequestSDKType {
+  grantee: string;
+  pagination?: PageRequestSDKType;
+}
+/** QueryGranteeGrantsResponse is the response type for the Query/GranteeGrants RPC method. */
+export interface QueryGranteeGrantsResponse {
+  /** grants is a list of grants granted to the grantee. */
+  grants: GrantAuthorization[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponse;
+}
+export interface QueryGranteeGrantsResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsResponse";
+  value: Uint8Array;
+}
+/** QueryGranteeGrantsResponse is the response type for the Query/GranteeGrants RPC method. */
+export interface QueryGranteeGrantsResponseAmino {
+  /** grants is a list of grants granted to the grantee. */
+  grants?: GrantAuthorizationAmino[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryGranteeGrantsResponseAminoMsg {
+  type: "cosmos-sdk/QueryGranteeGrantsResponse";
+  value: QueryGranteeGrantsResponseAmino;
+}
+/** QueryGranteeGrantsResponse is the response type for the Query/GranteeGrants RPC method. */
+export interface QueryGranteeGrantsResponseSDKType {
+  grants: GrantAuthorizationSDKType[];
+  pagination?: PageResponseSDKType;
+}
+function createBaseQueryGrantsRequest(): QueryGrantsRequest {
+  return {
+    granter: "",
+    grantee: "",
+    msgTypeUrl: "",
+    pagination: undefined
+  };
+}
+export const QueryGrantsRequest = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGrantsRequest",
+  encode(message: QueryGrantsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(26).string(message.msgTypeUrl);
+    }
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGrantsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGrantsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.msgTypeUrl = reader.string();
+          break;
+        case 4:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGrantsRequest>): QueryGrantsRequest {
+    const message = createBaseQueryGrantsRequest();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGrantsRequestAmino): QueryGrantsRequest {
+    const message = createBaseQueryGrantsRequest();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGrantsRequest): QueryGrantsRequestAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGrantsRequestAminoMsg): QueryGrantsRequest {
+    return QueryGrantsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGrantsRequest): QueryGrantsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGrantsRequest",
+      value: QueryGrantsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGrantsRequestProtoMsg): QueryGrantsRequest {
+    return QueryGrantsRequest.decode(message.value);
+  },
+  toProto(message: QueryGrantsRequest): Uint8Array {
+    return QueryGrantsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGrantsRequest): QueryGrantsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGrantsRequest",
+      value: QueryGrantsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGrantsResponse(): QueryGrantsResponse {
+  return {
+    grants: [],
+    pagination: undefined
+  };
+}
+export const QueryGrantsResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGrantsResponse",
+  encode(message: QueryGrantsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.grants) {
+      Grant.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGrantsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGrantsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grants.push(Grant.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGrantsResponse>): QueryGrantsResponse {
+    const message = createBaseQueryGrantsResponse();
+    message.grants = object.grants?.map(e => Grant.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGrantsResponseAmino): QueryGrantsResponse {
+    const message = createBaseQueryGrantsResponse();
+    message.grants = object.grants?.map(e => Grant.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGrantsResponse): QueryGrantsResponseAmino {
+    const obj: any = {};
+    if (message.grants) {
+      obj.grants = message.grants.map(e => e ? Grant.toAmino(e) : undefined);
+    } else {
+      obj.grants = message.grants;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGrantsResponseAminoMsg): QueryGrantsResponse {
+    return QueryGrantsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGrantsResponse): QueryGrantsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGrantsResponse",
+      value: QueryGrantsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGrantsResponseProtoMsg): QueryGrantsResponse {
+    return QueryGrantsResponse.decode(message.value);
+  },
+  toProto(message: QueryGrantsResponse): Uint8Array {
+    return QueryGrantsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGrantsResponse): QueryGrantsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGrantsResponse",
+      value: QueryGrantsResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGranterGrantsRequest(): QueryGranterGrantsRequest {
+  return {
+    granter: "",
+    pagination: undefined
+  };
+}
+export const QueryGranterGrantsRequest = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsRequest",
+  encode(message: QueryGranterGrantsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGranterGrantsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGranterGrantsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGranterGrantsRequest>): QueryGranterGrantsRequest {
+    const message = createBaseQueryGranterGrantsRequest();
+    message.granter = object.granter ?? "";
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGranterGrantsRequestAmino): QueryGranterGrantsRequest {
+    const message = createBaseQueryGranterGrantsRequest();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGranterGrantsRequest): QueryGranterGrantsRequestAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGranterGrantsRequestAminoMsg): QueryGranterGrantsRequest {
+    return QueryGranterGrantsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGranterGrantsRequest): QueryGranterGrantsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGranterGrantsRequest",
+      value: QueryGranterGrantsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGranterGrantsRequestProtoMsg): QueryGranterGrantsRequest {
+    return QueryGranterGrantsRequest.decode(message.value);
+  },
+  toProto(message: QueryGranterGrantsRequest): Uint8Array {
+    return QueryGranterGrantsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGranterGrantsRequest): QueryGranterGrantsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsRequest",
+      value: QueryGranterGrantsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGranterGrantsResponse(): QueryGranterGrantsResponse {
+  return {
+    grants: [],
+    pagination: undefined
+  };
+}
+export const QueryGranterGrantsResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsResponse",
+  encode(message: QueryGranterGrantsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.grants) {
+      GrantAuthorization.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGranterGrantsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGranterGrantsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grants.push(GrantAuthorization.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGranterGrantsResponse>): QueryGranterGrantsResponse {
+    const message = createBaseQueryGranterGrantsResponse();
+    message.grants = object.grants?.map(e => GrantAuthorization.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGranterGrantsResponseAmino): QueryGranterGrantsResponse {
+    const message = createBaseQueryGranterGrantsResponse();
+    message.grants = object.grants?.map(e => GrantAuthorization.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGranterGrantsResponse): QueryGranterGrantsResponseAmino {
+    const obj: any = {};
+    if (message.grants) {
+      obj.grants = message.grants.map(e => e ? GrantAuthorization.toAmino(e) : undefined);
+    } else {
+      obj.grants = message.grants;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGranterGrantsResponseAminoMsg): QueryGranterGrantsResponse {
+    return QueryGranterGrantsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGranterGrantsResponse): QueryGranterGrantsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGranterGrantsResponse",
+      value: QueryGranterGrantsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGranterGrantsResponseProtoMsg): QueryGranterGrantsResponse {
+    return QueryGranterGrantsResponse.decode(message.value);
+  },
+  toProto(message: QueryGranterGrantsResponse): Uint8Array {
+    return QueryGranterGrantsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGranterGrantsResponse): QueryGranterGrantsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGranterGrantsResponse",
+      value: QueryGranterGrantsResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGranteeGrantsRequest(): QueryGranteeGrantsRequest {
+  return {
+    grantee: "",
+    pagination: undefined
+  };
+}
+export const QueryGranteeGrantsRequest = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsRequest",
+  encode(message: QueryGranteeGrantsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.grantee !== "") {
+      writer.uint32(10).string(message.grantee);
+    }
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGranteeGrantsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGranteeGrantsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grantee = reader.string();
+          break;
+        case 2:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGranteeGrantsRequest>): QueryGranteeGrantsRequest {
+    const message = createBaseQueryGranteeGrantsRequest();
+    message.grantee = object.grantee ?? "";
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGranteeGrantsRequestAmino): QueryGranteeGrantsRequest {
+    const message = createBaseQueryGranteeGrantsRequest();
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGranteeGrantsRequest): QueryGranteeGrantsRequestAmino {
+    const obj: any = {};
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGranteeGrantsRequestAminoMsg): QueryGranteeGrantsRequest {
+    return QueryGranteeGrantsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGranteeGrantsRequest): QueryGranteeGrantsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGranteeGrantsRequest",
+      value: QueryGranteeGrantsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGranteeGrantsRequestProtoMsg): QueryGranteeGrantsRequest {
+    return QueryGranteeGrantsRequest.decode(message.value);
+  },
+  toProto(message: QueryGranteeGrantsRequest): Uint8Array {
+    return QueryGranteeGrantsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGranteeGrantsRequest): QueryGranteeGrantsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsRequest",
+      value: QueryGranteeGrantsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryGranteeGrantsResponse(): QueryGranteeGrantsResponse {
+  return {
+    grants: [],
+    pagination: undefined
+  };
+}
+export const QueryGranteeGrantsResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsResponse",
+  encode(message: QueryGranteeGrantsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.grants) {
+      GrantAuthorization.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryGranteeGrantsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryGranteeGrantsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grants.push(GrantAuthorization.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryGranteeGrantsResponse>): QueryGranteeGrantsResponse {
+    const message = createBaseQueryGranteeGrantsResponse();
+    message.grants = object.grants?.map(e => GrantAuthorization.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryGranteeGrantsResponseAmino): QueryGranteeGrantsResponse {
+    const message = createBaseQueryGranteeGrantsResponse();
+    message.grants = object.grants?.map(e => GrantAuthorization.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryGranteeGrantsResponse): QueryGranteeGrantsResponseAmino {
+    const obj: any = {};
+    if (message.grants) {
+      obj.grants = message.grants.map(e => e ? GrantAuthorization.toAmino(e) : undefined);
+    } else {
+      obj.grants = message.grants;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryGranteeGrantsResponseAminoMsg): QueryGranteeGrantsResponse {
+    return QueryGranteeGrantsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryGranteeGrantsResponse): QueryGranteeGrantsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryGranteeGrantsResponse",
+      value: QueryGranteeGrantsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryGranteeGrantsResponseProtoMsg): QueryGranteeGrantsResponse {
+    return QueryGranteeGrantsResponse.decode(message.value);
+  },
+  toProto(message: QueryGranteeGrantsResponse): Uint8Array {
+    return QueryGranteeGrantsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryGranteeGrantsResponse): QueryGranteeGrantsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.QueryGranteeGrantsResponse",
+      value: QueryGranteeGrantsResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/authz/v1beta1/tx.amino.ts

@@ -0,0 +1,18 @@
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export const AminoConverter = {
+  "/cosmos.authz.v1beta1.MsgGrant": {
+    aminoType: "cosmos-sdk/MsgGrant",
+    toAmino: MsgGrant.toAmino,
+    fromAmino: MsgGrant.fromAmino
+  },
+  "/cosmos.authz.v1beta1.MsgExec": {
+    aminoType: "cosmos-sdk/MsgExec",
+    toAmino: MsgExec.toAmino,
+    fromAmino: MsgExec.fromAmino
+  },
+  "/cosmos.authz.v1beta1.MsgRevoke": {
+    aminoType: "cosmos-sdk/MsgRevoke",
+    toAmino: MsgRevoke.toAmino,
+    fromAmino: MsgRevoke.fromAmino
+  }
+};

src/codegen/cosmos/authz/v1beta1/tx.registry.ts

@@ -0,0 +1,70 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.authz.v1beta1.MsgGrant", MsgGrant], ["/cosmos.authz.v1beta1.MsgExec", MsgExec], ["/cosmos.authz.v1beta1.MsgRevoke", MsgRevoke]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value: MsgGrant.encode(value).finish()
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value: MsgExec.encode(value).finish()
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value: MsgRevoke.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    grant(value: MsgGrant) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+        value: MsgGrant.fromPartial(value)
+      };
+    },
+    exec(value: MsgExec) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+        value: MsgExec.fromPartial(value)
+      };
+    },
+    revoke(value: MsgRevoke) {
+      return {
+        typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+        value: MsgRevoke.fromPartial(value)
+      };
+    }
+  }
+};

src/codegen/cosmos/authz/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,48 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgGrant, MsgGrantResponse, MsgExec, MsgExecResponse, MsgRevoke, MsgRevokeResponse } from "./tx";
+/** Msg defines the authz Msg service. */
+export interface Msg {
+  /**
+   * Grant grants the provided authorization to the grantee on the granter's
+   * account with the provided expiration time. If there is already a grant
+   * for the given (granter, grantee, Authorization) triple, then the grant
+   * will be overwritten.
+   */
+  grant(request: MsgGrant): Promise<MsgGrantResponse>;
+  /**
+   * Exec attempts to execute the provided messages using
+   * authorizations granted to the grantee. Each message should have only
+   * one signer corresponding to the granter of the authorization.
+   */
+  exec(request: MsgExec): Promise<MsgExecResponse>;
+  /**
+   * Revoke revokes any authorization corresponding to the provided method name on the
+   * granter's account that has been granted to the grantee.
+   */
+  revoke(request: MsgRevoke): Promise<MsgRevokeResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.grant = this.grant.bind(this);
+    this.exec = this.exec.bind(this);
+    this.revoke = this.revoke.bind(this);
+  }
+  grant(request: MsgGrant): Promise<MsgGrantResponse> {
+    const data = MsgGrant.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Grant", data);
+    return promise.then(data => MsgGrantResponse.decode(new BinaryReader(data)));
+  }
+  exec(request: MsgExec): Promise<MsgExecResponse> {
+    const data = MsgExec.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Exec", data);
+    return promise.then(data => MsgExecResponse.decode(new BinaryReader(data)));
+  }
+  revoke(request: MsgRevoke): Promise<MsgRevokeResponse> {
+    const data = MsgRevoke.encode(request).finish();
+    const promise = this.rpc.request("cosmos.authz.v1beta1.Msg", "Revoke", data);
+    return promise.then(data => MsgRevokeResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/authz/v1beta1/tx.ts

@@ -0,0 +1,619 @@
+import { Grant, GrantAmino, GrantSDKType } from "./authz";
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+export interface MsgGrant {
+  granter: string;
+  grantee: string;
+  grant: Grant;
+}
+export interface MsgGrantProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgGrant";
+  value: Uint8Array;
+}
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+export interface MsgGrantAmino {
+  granter?: string;
+  grantee?: string;
+  grant?: GrantAmino;
+}
+export interface MsgGrantAminoMsg {
+  type: "cosmos-sdk/MsgGrant";
+  value: MsgGrantAmino;
+}
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+export interface MsgGrantSDKType {
+  granter: string;
+  grantee: string;
+  grant: GrantSDKType;
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+export interface MsgExecResponse {
+  results: Uint8Array[];
+}
+export interface MsgExecResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse";
+  value: Uint8Array;
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+export interface MsgExecResponseAmino {
+  results?: string[];
+}
+export interface MsgExecResponseAminoMsg {
+  type: "cosmos-sdk/MsgExecResponse";
+  value: MsgExecResponseAmino;
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+export interface MsgExecResponseSDKType {
+  results: Uint8Array[];
+}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+export interface MsgExec {
+  grantee: string;
+  /**
+   * Authorization Msg requests to execute. Each msg must implement Authorization interface
+   * The x/authz will try to find a grant matching (msg.signers[0], grantee, MsgTypeURL(msg))
+   * triple and validate it.
+   */
+  msgs: Any[];
+}
+export interface MsgExecProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgExec";
+  value: Uint8Array;
+}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+export interface MsgExecAmino {
+  grantee?: string;
+  /**
+   * Authorization Msg requests to execute. Each msg must implement Authorization interface
+   * The x/authz will try to find a grant matching (msg.signers[0], grantee, MsgTypeURL(msg))
+   * triple and validate it.
+   */
+  msgs?: AnyAmino[];
+}
+export interface MsgExecAminoMsg {
+  type: "cosmos-sdk/MsgExec";
+  value: MsgExecAmino;
+}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+export interface MsgExecSDKType {
+  grantee: string;
+  msgs: AnySDKType[];
+}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+export interface MsgGrantResponse {}
+export interface MsgGrantResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse";
+  value: Uint8Array;
+}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+export interface MsgGrantResponseAmino {}
+export interface MsgGrantResponseAminoMsg {
+  type: "cosmos-sdk/MsgGrantResponse";
+  value: MsgGrantResponseAmino;
+}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+export interface MsgGrantResponseSDKType {}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+export interface MsgRevoke {
+  granter: string;
+  grantee: string;
+  msgTypeUrl: string;
+}
+export interface MsgRevokeProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgRevoke";
+  value: Uint8Array;
+}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+export interface MsgRevokeAmino {
+  granter?: string;
+  grantee?: string;
+  msg_type_url?: string;
+}
+export interface MsgRevokeAminoMsg {
+  type: "cosmos-sdk/MsgRevoke";
+  value: MsgRevokeAmino;
+}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+export interface MsgRevokeSDKType {
+  granter: string;
+  grantee: string;
+  msg_type_url: string;
+}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+export interface MsgRevokeResponse {}
+export interface MsgRevokeResponseProtoMsg {
+  typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse";
+  value: Uint8Array;
+}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+export interface MsgRevokeResponseAmino {}
+export interface MsgRevokeResponseAminoMsg {
+  type: "cosmos-sdk/MsgRevokeResponse";
+  value: MsgRevokeResponseAmino;
+}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+export interface MsgRevokeResponseSDKType {}
+function createBaseMsgGrant(): MsgGrant {
+  return {
+    granter: "",
+    grantee: "",
+    grant: Grant.fromPartial({})
+  };
+}
+export const MsgGrant = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+  encode(message: MsgGrant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.grant !== undefined) {
+      Grant.encode(message.grant, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgGrant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.grant = Grant.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgGrant>): MsgGrant {
+    const message = createBaseMsgGrant();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.grant = object.grant !== undefined && object.grant !== null ? Grant.fromPartial(object.grant) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgGrantAmino): MsgGrant {
+    const message = createBaseMsgGrant();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.grant !== undefined && object.grant !== null) {
+      message.grant = Grant.fromAmino(object.grant);
+    }
+    return message;
+  },
+  toAmino(message: MsgGrant): MsgGrantAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.grant = message.grant ? Grant.toAmino(message.grant) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgGrantAminoMsg): MsgGrant {
+    return MsgGrant.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgGrant): MsgGrantAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgGrant",
+      value: MsgGrant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgGrantProtoMsg): MsgGrant {
+    return MsgGrant.decode(message.value);
+  },
+  toProto(message: MsgGrant): Uint8Array {
+    return MsgGrant.encode(message).finish();
+  },
+  toProtoMsg(message: MsgGrant): MsgGrantProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgGrant",
+      value: MsgGrant.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgExecResponse(): MsgExecResponse {
+  return {
+    results: []
+  };
+}
+export const MsgExecResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse",
+  encode(message: MsgExecResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.results) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgExecResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.results.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgExecResponse>): MsgExecResponse {
+    const message = createBaseMsgExecResponse();
+    message.results = object.results?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: MsgExecResponseAmino): MsgExecResponse {
+    const message = createBaseMsgExecResponse();
+    message.results = object.results?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgExecResponse): MsgExecResponseAmino {
+    const obj: any = {};
+    if (message.results) {
+      obj.results = message.results.map(e => base64FromBytes(e));
+    } else {
+      obj.results = message.results;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgExecResponseAminoMsg): MsgExecResponse {
+    return MsgExecResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgExecResponse): MsgExecResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgExecResponse",
+      value: MsgExecResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgExecResponseProtoMsg): MsgExecResponse {
+    return MsgExecResponse.decode(message.value);
+  },
+  toProto(message: MsgExecResponse): Uint8Array {
+    return MsgExecResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgExecResponse): MsgExecResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgExecResponse",
+      value: MsgExecResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgExec(): MsgExec {
+  return {
+    grantee: "",
+    msgs: []
+  };
+}
+export const MsgExec = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+  encode(message: MsgExec, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.grantee !== "") {
+      writer.uint32(10).string(message.grantee);
+    }
+    for (const v of message.msgs) {
+      Any.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgExec {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgExec();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grantee = reader.string();
+          break;
+        case 2:
+          message.msgs.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgExec>): MsgExec {
+    const message = createBaseMsgExec();
+    message.grantee = object.grantee ?? "";
+    message.msgs = object.msgs?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: MsgExecAmino): MsgExec {
+    const message = createBaseMsgExec();
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    message.msgs = object.msgs?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgExec): MsgExecAmino {
+    const obj: any = {};
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    if (message.msgs) {
+      obj.msgs = message.msgs.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.msgs = message.msgs;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgExecAminoMsg): MsgExec {
+    return MsgExec.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgExec): MsgExecAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgExec",
+      value: MsgExec.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgExecProtoMsg): MsgExec {
+    return MsgExec.decode(message.value);
+  },
+  toProto(message: MsgExec): Uint8Array {
+    return MsgExec.encode(message).finish();
+  },
+  toProtoMsg(message: MsgExec): MsgExecProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgExec",
+      value: MsgExec.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgGrantResponse(): MsgGrantResponse {
+  return {};
+}
+export const MsgGrantResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse",
+  encode(_: MsgGrantResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgGrantResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrantResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgGrantResponse>): MsgGrantResponse {
+    const message = createBaseMsgGrantResponse();
+    return message;
+  },
+  fromAmino(_: MsgGrantResponseAmino): MsgGrantResponse {
+    const message = createBaseMsgGrantResponse();
+    return message;
+  },
+  toAmino(_: MsgGrantResponse): MsgGrantResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgGrantResponseAminoMsg): MsgGrantResponse {
+    return MsgGrantResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgGrantResponse): MsgGrantResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgGrantResponse",
+      value: MsgGrantResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgGrantResponseProtoMsg): MsgGrantResponse {
+    return MsgGrantResponse.decode(message.value);
+  },
+  toProto(message: MsgGrantResponse): Uint8Array {
+    return MsgGrantResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgGrantResponse): MsgGrantResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgGrantResponse",
+      value: MsgGrantResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgRevoke(): MsgRevoke {
+  return {
+    granter: "",
+    grantee: "",
+    msgTypeUrl: ""
+  };
+}
+export const MsgRevoke = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+  encode(message: MsgRevoke, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.msgTypeUrl !== "") {
+      writer.uint32(26).string(message.msgTypeUrl);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRevoke {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevoke();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.msgTypeUrl = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgRevoke>): MsgRevoke {
+    const message = createBaseMsgRevoke();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.msgTypeUrl = object.msgTypeUrl ?? "";
+    return message;
+  },
+  fromAmino(object: MsgRevokeAmino): MsgRevoke {
+    const message = createBaseMsgRevoke();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
+      message.msgTypeUrl = object.msg_type_url;
+    }
+    return message;
+  },
+  toAmino(message: MsgRevoke): MsgRevokeAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
+    return obj;
+  },
+  fromAminoMsg(object: MsgRevokeAminoMsg): MsgRevoke {
+    return MsgRevoke.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgRevoke): MsgRevokeAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgRevoke",
+      value: MsgRevoke.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgRevokeProtoMsg): MsgRevoke {
+    return MsgRevoke.decode(message.value);
+  },
+  toProto(message: MsgRevoke): Uint8Array {
+    return MsgRevoke.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRevoke): MsgRevokeProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgRevoke",
+      value: MsgRevoke.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgRevokeResponse(): MsgRevokeResponse {
+  return {};
+}
+export const MsgRevokeResponse = {
+  typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse",
+  encode(_: MsgRevokeResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevokeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgRevokeResponse>): MsgRevokeResponse {
+    const message = createBaseMsgRevokeResponse();
+    return message;
+  },
+  fromAmino(_: MsgRevokeResponseAmino): MsgRevokeResponse {
+    const message = createBaseMsgRevokeResponse();
+    return message;
+  },
+  toAmino(_: MsgRevokeResponse): MsgRevokeResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgRevokeResponseAminoMsg): MsgRevokeResponse {
+    return MsgRevokeResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgRevokeResponse): MsgRevokeResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgRevokeResponse",
+      value: MsgRevokeResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgRevokeResponseProtoMsg): MsgRevokeResponse {
+    return MsgRevokeResponse.decode(message.value);
+  },
+  toProto(message: MsgRevokeResponse): Uint8Array {
+    return MsgRevokeResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRevokeResponse): MsgRevokeResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.authz.v1beta1.MsgRevokeResponse",
+      value: MsgRevokeResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/bank/v1beta1/authz.ts

@@ -0,0 +1,108 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorization {
+  spendLimit: Coin[];
+}
+export interface SendAuthorizationProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.SendAuthorization";
+  value: Uint8Array;
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorizationAmino {
+  spend_limit?: CoinAmino[];
+}
+export interface SendAuthorizationAminoMsg {
+  type: "cosmos-sdk/SendAuthorization";
+  value: SendAuthorizationAmino;
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorizationSDKType {
+  spend_limit: CoinSDKType[];
+}
+function createBaseSendAuthorization(): SendAuthorization {
+  return {
+    spendLimit: []
+  };
+}
+export const SendAuthorization = {
+  typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+  encode(message: SendAuthorization, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.spendLimit) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SendAuthorization {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendAuthorization();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.spendLimit.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SendAuthorization>): SendAuthorization {
+    const message = createBaseSendAuthorization();
+    message.spendLimit = object.spendLimit?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: SendAuthorizationAmino): SendAuthorization {
+    const message = createBaseSendAuthorization();
+    message.spendLimit = object.spend_limit?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: SendAuthorization): SendAuthorizationAmino {
+    const obj: any = {};
+    if (message.spendLimit) {
+      obj.spend_limit = message.spendLimit.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.spend_limit = message.spendLimit;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SendAuthorizationAminoMsg): SendAuthorization {
+    return SendAuthorization.fromAmino(object.value);
+  },
+  toAminoMsg(message: SendAuthorization): SendAuthorizationAminoMsg {
+    return {
+      type: "cosmos-sdk/SendAuthorization",
+      value: SendAuthorization.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SendAuthorizationProtoMsg): SendAuthorization {
+    return SendAuthorization.decode(message.value);
+  },
+  toProto(message: SendAuthorization): Uint8Array {
+    return SendAuthorization.encode(message).finish();
+  },
+  toProtoMsg(message: SendAuthorization): SendAuthorizationProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+      value: SendAuthorization.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/bank/v1beta1/bank.ts

@@ -0,0 +1,896 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** Params defines the parameters for the bank module. */
+export interface Params {
+  sendEnabled: SendEnabled[];
+  defaultSendEnabled: boolean;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Params";
+  value: Uint8Array;
+}
+/** Params defines the parameters for the bank module. */
+export interface ParamsAmino {
+  send_enabled?: SendEnabledAmino[];
+  default_send_enabled?: boolean;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/Params";
+  value: ParamsAmino;
+}
+/** Params defines the parameters for the bank module. */
+export interface ParamsSDKType {
+  send_enabled: SendEnabledSDKType[];
+  default_send_enabled: boolean;
+}
+/**
+ * SendEnabled maps coin denom to a send_enabled status (whether a denom is
+ * sendable).
+ */
+export interface SendEnabled {
+  denom: string;
+  enabled: boolean;
+}
+export interface SendEnabledProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.SendEnabled";
+  value: Uint8Array;
+}
+/**
+ * SendEnabled maps coin denom to a send_enabled status (whether a denom is
+ * sendable).
+ */
+export interface SendEnabledAmino {
+  denom?: string;
+  enabled?: boolean;
+}
+export interface SendEnabledAminoMsg {
+  type: "cosmos-sdk/SendEnabled";
+  value: SendEnabledAmino;
+}
+/**
+ * SendEnabled maps coin denom to a send_enabled status (whether a denom is
+ * sendable).
+ */
+export interface SendEnabledSDKType {
+  denom: string;
+  enabled: boolean;
+}
+/** Input models transaction input. */
+export interface Input {
+  address: string;
+  coins: Coin[];
+}
+export interface InputProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Input";
+  value: Uint8Array;
+}
+/** Input models transaction input. */
+export interface InputAmino {
+  address?: string;
+  coins?: CoinAmino[];
+}
+export interface InputAminoMsg {
+  type: "cosmos-sdk/Input";
+  value: InputAmino;
+}
+/** Input models transaction input. */
+export interface InputSDKType {
+  address: string;
+  coins: CoinSDKType[];
+}
+/** Output models transaction outputs. */
+export interface Output {
+  address: string;
+  coins: Coin[];
+}
+export interface OutputProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Output";
+  value: Uint8Array;
+}
+/** Output models transaction outputs. */
+export interface OutputAmino {
+  address?: string;
+  coins?: CoinAmino[];
+}
+export interface OutputAminoMsg {
+  type: "cosmos-sdk/Output";
+  value: OutputAmino;
+}
+/** Output models transaction outputs. */
+export interface OutputSDKType {
+  address: string;
+  coins: CoinSDKType[];
+}
+/**
+ * Supply represents a struct that passively keeps track of the total supply
+ * amounts in the network.
+ * This message is deprecated now that supply is indexed by denom.
+ */
+/** @deprecated */
+export interface Supply {
+  total: Coin[];
+}
+export interface SupplyProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Supply";
+  value: Uint8Array;
+}
+/**
+ * Supply represents a struct that passively keeps track of the total supply
+ * amounts in the network.
+ * This message is deprecated now that supply is indexed by denom.
+ */
+/** @deprecated */
+export interface SupplyAmino {
+  total?: CoinAmino[];
+}
+export interface SupplyAminoMsg {
+  type: "cosmos-sdk/Supply";
+  value: SupplyAmino;
+}
+/**
+ * Supply represents a struct that passively keeps track of the total supply
+ * amounts in the network.
+ * This message is deprecated now that supply is indexed by denom.
+ */
+/** @deprecated */
+export interface SupplySDKType {
+  total: CoinSDKType[];
+}
+/**
+ * DenomUnit represents a struct that describes a given
+ * denomination unit of the basic token.
+ */
+export interface DenomUnit {
+  /** denom represents the string name of the given denom unit (e.g uatom). */
+  denom: string;
+  /**
+   * exponent represents power of 10 exponent that one must
+   * raise the base_denom to in order to equal the given DenomUnit's denom
+   * 1 denom = 1^exponent base_denom
+   * (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
+   * exponent = 6, thus: 1 atom = 10^6 uatom).
+   */
+  exponent: number;
+  /** aliases is a list of string aliases for the given denom */
+  aliases: string[];
+}
+export interface DenomUnitProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.DenomUnit";
+  value: Uint8Array;
+}
+/**
+ * DenomUnit represents a struct that describes a given
+ * denomination unit of the basic token.
+ */
+export interface DenomUnitAmino {
+  /** denom represents the string name of the given denom unit (e.g uatom). */
+  denom?: string;
+  /**
+   * exponent represents power of 10 exponent that one must
+   * raise the base_denom to in order to equal the given DenomUnit's denom
+   * 1 denom = 1^exponent base_denom
+   * (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
+   * exponent = 6, thus: 1 atom = 10^6 uatom).
+   */
+  exponent?: number;
+  /** aliases is a list of string aliases for the given denom */
+  aliases?: string[];
+}
+export interface DenomUnitAminoMsg {
+  type: "cosmos-sdk/DenomUnit";
+  value: DenomUnitAmino;
+}
+/**
+ * DenomUnit represents a struct that describes a given
+ * denomination unit of the basic token.
+ */
+export interface DenomUnitSDKType {
+  denom: string;
+  exponent: number;
+  aliases: string[];
+}
+/**
+ * Metadata represents a struct that describes
+ * a basic token.
+ */
+export interface Metadata {
+  description: string;
+  /** denom_units represents the list of DenomUnit's for a given coin */
+  denomUnits: DenomUnit[];
+  /** base represents the base denom (should be the DenomUnit with exponent = 0). */
+  base: string;
+  /**
+   * display indicates the suggested denom that should be
+   * displayed in clients.
+   */
+  display: string;
+  /**
+   * name defines the name of the token (eg: Cosmos Atom)
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  name: string;
+  /**
+   * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can
+   * be the same as the display.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  symbol: string;
+}
+export interface MetadataProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Metadata";
+  value: Uint8Array;
+}
+/**
+ * Metadata represents a struct that describes
+ * a basic token.
+ */
+export interface MetadataAmino {
+  description?: string;
+  /** denom_units represents the list of DenomUnit's for a given coin */
+  denom_units?: DenomUnitAmino[];
+  /** base represents the base denom (should be the DenomUnit with exponent = 0). */
+  base?: string;
+  /**
+   * display indicates the suggested denom that should be
+   * displayed in clients.
+   */
+  display?: string;
+  /**
+   * name defines the name of the token (eg: Cosmos Atom)
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  name?: string;
+  /**
+   * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can
+   * be the same as the display.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  symbol?: string;
+}
+export interface MetadataAminoMsg {
+  type: "cosmos-sdk/Metadata";
+  value: MetadataAmino;
+}
+/**
+ * Metadata represents a struct that describes
+ * a basic token.
+ */
+export interface MetadataSDKType {
+  description: string;
+  denom_units: DenomUnitSDKType[];
+  base: string;
+  display: string;
+  name: string;
+  symbol: string;
+}
+function createBaseParams(): Params {
+  return {
+    sendEnabled: [],
+    defaultSendEnabled: false
+  };
+}
+export const Params = {
+  typeUrl: "/cosmos.bank.v1beta1.Params",
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.sendEnabled) {
+      SendEnabled.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.defaultSendEnabled === true) {
+      writer.uint32(16).bool(message.defaultSendEnabled);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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.sendEnabled.push(SendEnabled.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.defaultSendEnabled = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Params>): Params {
+    const message = createBaseParams();
+    message.sendEnabled = object.sendEnabled?.map(e => SendEnabled.fromPartial(e)) || [];
+    message.defaultSendEnabled = object.defaultSendEnabled ?? false;
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    message.sendEnabled = object.send_enabled?.map(e => SendEnabled.fromAmino(e)) || [];
+    if (object.default_send_enabled !== undefined && object.default_send_enabled !== null) {
+      message.defaultSendEnabled = object.default_send_enabled;
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    if (message.sendEnabled) {
+      obj.send_enabled = message.sendEnabled.map(e => e ? SendEnabled.toAmino(e) : undefined);
+    } else {
+      obj.send_enabled = message.sendEnabled;
+    }
+    obj.default_send_enabled = message.defaultSendEnabled === false ? undefined : message.defaultSendEnabled;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "cosmos-sdk/Params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};
+function createBaseSendEnabled(): SendEnabled {
+  return {
+    denom: "",
+    enabled: false
+  };
+}
+export const SendEnabled = {
+  typeUrl: "/cosmos.bank.v1beta1.SendEnabled",
+  encode(message: SendEnabled, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.enabled === true) {
+      writer.uint32(16).bool(message.enabled);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SendEnabled {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendEnabled();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.enabled = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SendEnabled>): SendEnabled {
+    const message = createBaseSendEnabled();
+    message.denom = object.denom ?? "";
+    message.enabled = object.enabled ?? false;
+    return message;
+  },
+  fromAmino(object: SendEnabledAmino): SendEnabled {
+    const message = createBaseSendEnabled();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.enabled !== undefined && object.enabled !== null) {
+      message.enabled = object.enabled;
+    }
+    return message;
+  },
+  toAmino(message: SendEnabled): SendEnabledAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.enabled = message.enabled === false ? undefined : message.enabled;
+    return obj;
+  },
+  fromAminoMsg(object: SendEnabledAminoMsg): SendEnabled {
+    return SendEnabled.fromAmino(object.value);
+  },
+  toAminoMsg(message: SendEnabled): SendEnabledAminoMsg {
+    return {
+      type: "cosmos-sdk/SendEnabled",
+      value: SendEnabled.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SendEnabledProtoMsg): SendEnabled {
+    return SendEnabled.decode(message.value);
+  },
+  toProto(message: SendEnabled): Uint8Array {
+    return SendEnabled.encode(message).finish();
+  },
+  toProtoMsg(message: SendEnabled): SendEnabledProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.SendEnabled",
+      value: SendEnabled.encode(message).finish()
+    };
+  }
+};
+function createBaseInput(): Input {
+  return {
+    address: "",
+    coins: []
+  };
+}
+export const Input = {
+  typeUrl: "/cosmos.bank.v1beta1.Input",
+  encode(message: Input, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    for (const v of message.coins) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Input {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.coins.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Input>): Input {
+    const message = createBaseInput();
+    message.address = object.address ?? "";
+    message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: InputAmino): Input {
+    const message = createBaseInput();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Input): InputAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    if (message.coins) {
+      obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.coins = message.coins;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: InputAminoMsg): Input {
+    return Input.fromAmino(object.value);
+  },
+  toAminoMsg(message: Input): InputAminoMsg {
+    return {
+      type: "cosmos-sdk/Input",
+      value: Input.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: InputProtoMsg): Input {
+    return Input.decode(message.value);
+  },
+  toProto(message: Input): Uint8Array {
+    return Input.encode(message).finish();
+  },
+  toProtoMsg(message: Input): InputProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Input",
+      value: Input.encode(message).finish()
+    };
+  }
+};
+function createBaseOutput(): Output {
+  return {
+    address: "",
+    coins: []
+  };
+}
+export const Output = {
+  typeUrl: "/cosmos.bank.v1beta1.Output",
+  encode(message: Output, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    for (const v of message.coins) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Output {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOutput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.coins.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Output>): Output {
+    const message = createBaseOutput();
+    message.address = object.address ?? "";
+    message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: OutputAmino): Output {
+    const message = createBaseOutput();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Output): OutputAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    if (message.coins) {
+      obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.coins = message.coins;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: OutputAminoMsg): Output {
+    return Output.fromAmino(object.value);
+  },
+  toAminoMsg(message: Output): OutputAminoMsg {
+    return {
+      type: "cosmos-sdk/Output",
+      value: Output.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: OutputProtoMsg): Output {
+    return Output.decode(message.value);
+  },
+  toProto(message: Output): Uint8Array {
+    return Output.encode(message).finish();
+  },
+  toProtoMsg(message: Output): OutputProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Output",
+      value: Output.encode(message).finish()
+    };
+  }
+};
+function createBaseSupply(): Supply {
+  return {
+    total: []
+  };
+}
+export const Supply = {
+  typeUrl: "/cosmos.bank.v1beta1.Supply",
+  encode(message: Supply, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.total) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Supply {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSupply();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.total.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Supply>): Supply {
+    const message = createBaseSupply();
+    message.total = object.total?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: SupplyAmino): Supply {
+    const message = createBaseSupply();
+    message.total = object.total?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Supply): SupplyAmino {
+    const obj: any = {};
+    if (message.total) {
+      obj.total = message.total.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.total = message.total;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SupplyAminoMsg): Supply {
+    return Supply.fromAmino(object.value);
+  },
+  toAminoMsg(message: Supply): SupplyAminoMsg {
+    return {
+      type: "cosmos-sdk/Supply",
+      value: Supply.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SupplyProtoMsg): Supply {
+    return Supply.decode(message.value);
+  },
+  toProto(message: Supply): Uint8Array {
+    return Supply.encode(message).finish();
+  },
+  toProtoMsg(message: Supply): SupplyProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Supply",
+      value: Supply.encode(message).finish()
+    };
+  }
+};
+function createBaseDenomUnit(): DenomUnit {
+  return {
+    denom: "",
+    exponent: 0,
+    aliases: []
+  };
+}
+export const DenomUnit = {
+  typeUrl: "/cosmos.bank.v1beta1.DenomUnit",
+  encode(message: DenomUnit, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.exponent !== 0) {
+      writer.uint32(16).uint32(message.exponent);
+    }
+    for (const v of message.aliases) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DenomUnit {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDenomUnit();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.exponent = reader.uint32();
+          break;
+        case 3:
+          message.aliases.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<DenomUnit>): DenomUnit {
+    const message = createBaseDenomUnit();
+    message.denom = object.denom ?? "";
+    message.exponent = object.exponent ?? 0;
+    message.aliases = object.aliases?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: DenomUnitAmino): DenomUnit {
+    const message = createBaseDenomUnit();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.exponent !== undefined && object.exponent !== null) {
+      message.exponent = object.exponent;
+    }
+    message.aliases = object.aliases?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: DenomUnit): DenomUnitAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.exponent = message.exponent === 0 ? undefined : message.exponent;
+    if (message.aliases) {
+      obj.aliases = message.aliases.map(e => e);
+    } else {
+      obj.aliases = message.aliases;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: DenomUnitAminoMsg): DenomUnit {
+    return DenomUnit.fromAmino(object.value);
+  },
+  toAminoMsg(message: DenomUnit): DenomUnitAminoMsg {
+    return {
+      type: "cosmos-sdk/DenomUnit",
+      value: DenomUnit.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DenomUnitProtoMsg): DenomUnit {
+    return DenomUnit.decode(message.value);
+  },
+  toProto(message: DenomUnit): Uint8Array {
+    return DenomUnit.encode(message).finish();
+  },
+  toProtoMsg(message: DenomUnit): DenomUnitProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.DenomUnit",
+      value: DenomUnit.encode(message).finish()
+    };
+  }
+};
+function createBaseMetadata(): Metadata {
+  return {
+    description: "",
+    denomUnits: [],
+    base: "",
+    display: "",
+    name: "",
+    symbol: ""
+  };
+}
+export const Metadata = {
+  typeUrl: "/cosmos.bank.v1beta1.Metadata",
+  encode(message: Metadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    for (const v of message.denomUnits) {
+      DenomUnit.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.base !== "") {
+      writer.uint32(26).string(message.base);
+    }
+    if (message.display !== "") {
+      writer.uint32(34).string(message.display);
+    }
+    if (message.name !== "") {
+      writer.uint32(42).string(message.name);
+    }
+    if (message.symbol !== "") {
+      writer.uint32(50).string(message.symbol);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Metadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.description = reader.string();
+          break;
+        case 2:
+          message.denomUnits.push(DenomUnit.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.base = reader.string();
+          break;
+        case 4:
+          message.display = reader.string();
+          break;
+        case 5:
+          message.name = reader.string();
+          break;
+        case 6:
+          message.symbol = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Metadata>): Metadata {
+    const message = createBaseMetadata();
+    message.description = object.description ?? "";
+    message.denomUnits = object.denomUnits?.map(e => DenomUnit.fromPartial(e)) || [];
+    message.base = object.base ?? "";
+    message.display = object.display ?? "";
+    message.name = object.name ?? "";
+    message.symbol = object.symbol ?? "";
+    return message;
+  },
+  fromAmino(object: MetadataAmino): Metadata {
+    const message = createBaseMetadata();
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    message.denomUnits = object.denom_units?.map(e => DenomUnit.fromAmino(e)) || [];
+    if (object.base !== undefined && object.base !== null) {
+      message.base = object.base;
+    }
+    if (object.display !== undefined && object.display !== null) {
+      message.display = object.display;
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.symbol !== undefined && object.symbol !== null) {
+      message.symbol = object.symbol;
+    }
+    return message;
+  },
+  toAmino(message: Metadata): MetadataAmino {
+    const obj: any = {};
+    obj.description = message.description === "" ? undefined : message.description;
+    if (message.denomUnits) {
+      obj.denom_units = message.denomUnits.map(e => e ? DenomUnit.toAmino(e) : undefined);
+    } else {
+      obj.denom_units = message.denomUnits;
+    }
+    obj.base = message.base === "" ? undefined : message.base;
+    obj.display = message.display === "" ? undefined : message.display;
+    obj.name = message.name === "" ? undefined : message.name;
+    obj.symbol = message.symbol === "" ? undefined : message.symbol;
+    return obj;
+  },
+  fromAminoMsg(object: MetadataAminoMsg): Metadata {
+    return Metadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: Metadata): MetadataAminoMsg {
+    return {
+      type: "cosmos-sdk/Metadata",
+      value: Metadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MetadataProtoMsg): Metadata {
+    return Metadata.decode(message.value);
+  },
+  toProto(message: Metadata): Uint8Array {
+    return Metadata.encode(message).finish();
+  },
+  toProtoMsg(message: Metadata): MetadataProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Metadata",
+      value: Metadata.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/bank/v1beta1/genesis.ts

@@ -0,0 +1,276 @@
+import { Params, ParamsAmino, ParamsSDKType, Metadata, MetadataAmino, MetadataSDKType } from "./bank";
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisState {
+  /** params defines all the paramaters of the module. */
+  params: Params;
+  /** balances is an array containing the balances of all the accounts. */
+  balances: Balance[];
+  /**
+   * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+   * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+   */
+  supply: Coin[];
+  /** denom_metadata defines the metadata of the differents coins. */
+  denomMetadata: Metadata[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisStateAmino {
+  /** params defines all the paramaters of the module. */
+  params?: ParamsAmino;
+  /** balances is an array containing the balances of all the accounts. */
+  balances?: BalanceAmino[];
+  /**
+   * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+   * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+   */
+  supply?: CoinAmino[];
+  /** denom_metadata defines the metadata of the differents coins. */
+  denom_metadata?: MetadataAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisStateSDKType {
+  params: ParamsSDKType;
+  balances: BalanceSDKType[];
+  supply: CoinSDKType[];
+  denom_metadata: MetadataSDKType[];
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface Balance {
+  /** address is the address of the balance holder. */
+  address: string;
+  /** coins defines the different coins this balance holds. */
+  coins: Coin[];
+}
+export interface BalanceProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Balance";
+  value: Uint8Array;
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface BalanceAmino {
+  /** address is the address of the balance holder. */
+  address?: string;
+  /** coins defines the different coins this balance holds. */
+  coins?: CoinAmino[];
+}
+export interface BalanceAminoMsg {
+  type: "cosmos-sdk/Balance";
+  value: BalanceAmino;
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface BalanceSDKType {
+  address: string;
+  coins: CoinSDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: Params.fromPartial({}),
+    balances: [],
+    supply: [],
+    denomMetadata: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.balances) {
+      Balance.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.supply) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.denomMetadata) {
+      Metadata.encode(v!, writer.uint32(34).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;
+        case 2:
+          message.balances.push(Balance.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.supply.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.denomMetadata.push(Metadata.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.balances = object.balances?.map(e => Balance.fromPartial(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromPartial(e)) || [];
+    message.denomMetadata = object.denomMetadata?.map(e => Metadata.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    message.balances = object.balances?.map(e => Balance.fromAmino(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromAmino(e)) || [];
+    message.denomMetadata = object.denom_metadata?.map(e => Metadata.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    if (message.balances) {
+      obj.balances = message.balances.map(e => e ? Balance.toAmino(e) : undefined);
+    } else {
+      obj.balances = message.balances;
+    }
+    if (message.supply) {
+      obj.supply = message.supply.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.supply = message.supply;
+    }
+    if (message.denomMetadata) {
+      obj.denom_metadata = message.denomMetadata.map(e => e ? Metadata.toAmino(e) : undefined);
+    } else {
+      obj.denom_metadata = message.denomMetadata;
+    }
+    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.bank.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+function createBaseBalance(): Balance {
+  return {
+    address: "",
+    coins: []
+  };
+}
+export const Balance = {
+  typeUrl: "/cosmos.bank.v1beta1.Balance",
+  encode(message: Balance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    for (const v of message.coins) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Balance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBalance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.coins.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Balance>): Balance {
+    const message = createBaseBalance();
+    message.address = object.address ?? "";
+    message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: BalanceAmino): Balance {
+    const message = createBaseBalance();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Balance): BalanceAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    if (message.coins) {
+      obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.coins = message.coins;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: BalanceAminoMsg): Balance {
+    return Balance.fromAmino(object.value);
+  },
+  toAminoMsg(message: Balance): BalanceAminoMsg {
+    return {
+      type: "cosmos-sdk/Balance",
+      value: Balance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BalanceProtoMsg): Balance {
+    return Balance.decode(message.value);
+  },
+  toProto(message: Balance): Uint8Array {
+    return Balance.encode(message).finish();
+  },
+  toProtoMsg(message: Balance): BalanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Balance",
+      value: Balance.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/bank/v1beta1/query.lcd.ts

@@ -0,0 +1,96 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryAllBalancesRequest, QueryAllBalancesResponseSDKType, QuerySpendableBalancesRequest, QuerySpendableBalancesResponseSDKType, QueryTotalSupplyRequest, QueryTotalSupplyResponseSDKType, QuerySupplyOfRequest, QuerySupplyOfResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomMetadataRequest, QueryDenomMetadataResponseSDKType, QueryDenomsMetadataRequest, QueryDenomsMetadataResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.balance = this.balance.bind(this);
+    this.allBalances = this.allBalances.bind(this);
+    this.spendableBalances = this.spendableBalances.bind(this);
+    this.totalSupply = this.totalSupply.bind(this);
+    this.supplyOf = this.supplyOf.bind(this);
+    this.params = this.params.bind(this);
+    this.denomMetadata = this.denomMetadata.bind(this);
+    this.denomsMetadata = this.denomsMetadata.bind(this);
+  }
+  /* Balance queries the balance of a single coin for a single account. */
+  async balance(params: QueryBalanceRequest): Promise<QueryBalanceResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}/by_denom`;
+    return await this.req.get<QueryBalanceResponseSDKType>(endpoint, options);
+  }
+  /* AllBalances queries the balance of all coins for a single account. */
+  async allBalances(params: QueryAllBalancesRequest): Promise<QueryAllBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}`;
+    return await this.req.get<QueryAllBalancesResponseSDKType>(endpoint, options);
+  }
+  /* SpendableBalances queries the spenable balance of all coins for a single
+   account. */
+  async spendableBalances(params: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}`;
+    return await this.req.get<QuerySpendableBalancesResponseSDKType>(endpoint, options);
+  }
+  /* TotalSupply queries the total supply of all coins. */
+  async totalSupply(params: QueryTotalSupplyRequest = {
+    pagination: undefined
+  }): Promise<QueryTotalSupplyResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/supply`;
+    return await this.req.get<QueryTotalSupplyResponseSDKType>(endpoint, options);
+  }
+  /* SupplyOf queries the supply of a single coin. */
+  async supplyOf(params: QuerySupplyOfRequest): Promise<QuerySupplyOfResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/supply/${params.denom}`;
+    return await this.req.get<QuerySupplyOfResponseSDKType>(endpoint);
+  }
+  /* Params queries the parameters of x/bank module. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* DenomsMetadata queries the client metadata of a given coin denomination. */
+  async denomMetadata(params: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata/${params.denom}`;
+    return await this.req.get<QueryDenomMetadataResponseSDKType>(endpoint);
+  }
+  /* DenomsMetadata queries the client metadata for all registered coin denominations. */
+  async denomsMetadata(params: QueryDenomsMetadataRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomsMetadataResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata`;
+    return await this.req.get<QueryDenomsMetadataResponseSDKType>(endpoint, options);
+  }
+}

src/codegen/cosmos/bank/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,114 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Balance queries the balance of a single coin for a single account. */
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+  /** AllBalances queries the balance of all coins for a single account. */
+  allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse>;
+  /**
+   * SpendableBalances queries the spenable balance of all coins for a single
+   * account.
+   */
+  spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse>;
+  /** TotalSupply queries the total supply of all coins. */
+  totalSupply(request?: QueryTotalSupplyRequest): Promise<QueryTotalSupplyResponse>;
+  /** SupplyOf queries the supply of a single coin. */
+  supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse>;
+  /** Params queries the parameters of x/bank module. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** DenomsMetadata queries the client metadata of a given coin denomination. */
+  denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse>;
+  /** DenomsMetadata queries the client metadata for all registered coin denominations. */
+  denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.balance = this.balance.bind(this);
+    this.allBalances = this.allBalances.bind(this);
+    this.spendableBalances = this.spendableBalances.bind(this);
+    this.totalSupply = this.totalSupply.bind(this);
+    this.supplyOf = this.supplyOf.bind(this);
+    this.params = this.params.bind(this);
+    this.denomMetadata = this.denomMetadata.bind(this);
+    this.denomsMetadata = this.denomsMetadata.bind(this);
+  }
+  balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+    const data = QueryBalanceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Balance", data);
+    return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(data)));
+  }
+  allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse> {
+    const data = QueryAllBalancesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "AllBalances", data);
+    return promise.then(data => QueryAllBalancesResponse.decode(new BinaryReader(data)));
+  }
+  spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse> {
+    const data = QuerySpendableBalancesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SpendableBalances", data);
+    return promise.then(data => QuerySpendableBalancesResponse.decode(new BinaryReader(data)));
+  }
+  totalSupply(request: QueryTotalSupplyRequest = {
+    pagination: undefined
+  }): Promise<QueryTotalSupplyResponse> {
+    const data = QueryTotalSupplyRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "TotalSupply", data);
+    return promise.then(data => QueryTotalSupplyResponse.decode(new BinaryReader(data)));
+  }
+  supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse> {
+    const data = QuerySupplyOfRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "SupplyOf", data);
+    return promise.then(data => QuerySupplyOfResponse.decode(new BinaryReader(data)));
+  }
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse> {
+    const data = QueryDenomMetadataRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomMetadata", data);
+    return promise.then(data => QueryDenomMetadataResponse.decode(new BinaryReader(data)));
+  }
+  denomsMetadata(request: QueryDenomsMetadataRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomsMetadataResponse> {
+    const data = QueryDenomsMetadataRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Query", "DenomsMetadata", data);
+    return promise.then(data => QueryDenomsMetadataResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+      return queryService.balance(request);
+    },
+    allBalances(request: QueryAllBalancesRequest): Promise<QueryAllBalancesResponse> {
+      return queryService.allBalances(request);
+    },
+    spendableBalances(request: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponse> {
+      return queryService.spendableBalances(request);
+    },
+    totalSupply(request?: QueryTotalSupplyRequest): Promise<QueryTotalSupplyResponse> {
+      return queryService.totalSupply(request);
+    },
+    supplyOf(request: QuerySupplyOfRequest): Promise<QuerySupplyOfResponse> {
+      return queryService.supplyOf(request);
+    },
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    denomMetadata(request: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponse> {
+      return queryService.denomMetadata(request);
+    },
+    denomsMetadata(request?: QueryDenomsMetadataRequest): Promise<QueryDenomsMetadataResponse> {
+      return queryService.denomsMetadata(request);
+    }
+  };
+};

src/codegen/cosmos/bank/v1beta1/tx.amino.ts

@@ -0,0 +1,13 @@
+import { MsgSend, MsgMultiSend } from "./tx";
+export const AminoConverter = {
+  "/cosmos.bank.v1beta1.MsgSend": {
+    aminoType: "cosmos-sdk/MsgSend",
+    toAmino: MsgSend.toAmino,
+    fromAmino: MsgSend.fromAmino
+  },
+  "/cosmos.bank.v1beta1.MsgMultiSend": {
+    aminoType: "cosmos-sdk/MsgMultiSend",
+    toAmino: MsgMultiSend.toAmino,
+    fromAmino: MsgMultiSend.fromAmino
+  }
+};

src/codegen/cosmos/bank/v1beta1/tx.registry.ts

@@ -0,0 +1,52 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSend, MsgMultiSend } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.bank.v1beta1.MsgSend", MsgSend], ["/cosmos.bank.v1beta1.MsgMultiSend", MsgMultiSend]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+        value: MsgSend.encode(value).finish()
+      };
+    },
+    multiSend(value: MsgMultiSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
+        value: MsgMultiSend.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+        value
+      };
+    },
+    multiSend(value: MsgMultiSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    send(value: MsgSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+        value: MsgSend.fromPartial(value)
+      };
+    },
+    multiSend(value: MsgMultiSend) {
+      return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
+        value: MsgMultiSend.fromPartial(value)
+      };
+    }
+  }
+};

src/codegen/cosmos/bank/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,28 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgSend, MsgSendResponse, MsgMultiSend, MsgMultiSendResponse } from "./tx";
+/** Msg defines the bank Msg service. */
+export interface Msg {
+  /** Send defines a method for sending coins from one account to another account. */
+  send(request: MsgSend): Promise<MsgSendResponse>;
+  /** MultiSend defines a method for sending coins from some accounts to other accounts. */
+  multiSend(request: MsgMultiSend): Promise<MsgMultiSendResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.send = this.send.bind(this);
+    this.multiSend = this.multiSend.bind(this);
+  }
+  send(request: MsgSend): Promise<MsgSendResponse> {
+    const data = MsgSend.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "Send", data);
+    return promise.then(data => MsgSendResponse.decode(new BinaryReader(data)));
+  }
+  multiSend(request: MsgMultiSend): Promise<MsgMultiSendResponse> {
+    const data = MsgMultiSend.encode(request).finish();
+    const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "MultiSend", data);
+    return promise.then(data => MsgMultiSendResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/bank/v1beta1/tx.ts

@@ -0,0 +1,372 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { Input, InputAmino, InputSDKType, Output, OutputAmino, OutputSDKType } from "./bank";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** MsgSend represents a message to send coins from one account to another. */
+export interface MsgSend {
+  fromAddress: string;
+  toAddress: string;
+  amount: Coin[];
+}
+export interface MsgSendProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.MsgSend";
+  value: Uint8Array;
+}
+/** MsgSend represents a message to send coins from one account to another. */
+export interface MsgSendAmino {
+  from_address?: string;
+  to_address?: string;
+  amount?: CoinAmino[];
+}
+export interface MsgSendAminoMsg {
+  type: "cosmos-sdk/MsgSend";
+  value: MsgSendAmino;
+}
+/** MsgSend represents a message to send coins from one account to another. */
+export interface MsgSendSDKType {
+  from_address: string;
+  to_address: string;
+  amount: CoinSDKType[];
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponse {}
+export interface MsgSendResponseProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse";
+  value: Uint8Array;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponseAmino {}
+export interface MsgSendResponseAminoMsg {
+  type: "cosmos-sdk/MsgSendResponse";
+  value: MsgSendResponseAmino;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponseSDKType {}
+/** MsgMultiSend represents an arbitrary multi-in, multi-out send message. */
+export interface MsgMultiSend {
+  inputs: Input[];
+  outputs: Output[];
+}
+export interface MsgMultiSendProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend";
+  value: Uint8Array;
+}
+/** MsgMultiSend represents an arbitrary multi-in, multi-out send message. */
+export interface MsgMultiSendAmino {
+  inputs?: InputAmino[];
+  outputs?: OutputAmino[];
+}
+export interface MsgMultiSendAminoMsg {
+  type: "cosmos-sdk/MsgMultiSend";
+  value: MsgMultiSendAmino;
+}
+/** MsgMultiSend represents an arbitrary multi-in, multi-out send message. */
+export interface MsgMultiSendSDKType {
+  inputs: InputSDKType[];
+  outputs: OutputSDKType[];
+}
+/** MsgMultiSendResponse defines the Msg/MultiSend response type. */
+export interface MsgMultiSendResponse {}
+export interface MsgMultiSendResponseProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.MsgMultiSendResponse";
+  value: Uint8Array;
+}
+/** MsgMultiSendResponse defines the Msg/MultiSend response type. */
+export interface MsgMultiSendResponseAmino {}
+export interface MsgMultiSendResponseAminoMsg {
+  type: "cosmos-sdk/MsgMultiSendResponse";
+  value: MsgMultiSendResponseAmino;
+}
+/** MsgMultiSendResponse defines the Msg/MultiSend response type. */
+export interface MsgMultiSendResponseSDKType {}
+function createBaseMsgSend(): MsgSend {
+  return {
+    fromAddress: "",
+    toAddress: "",
+    amount: []
+  };
+}
+export const MsgSend = {
+  typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+  encode(message: MsgSend, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.fromAddress !== "") {
+      writer.uint32(10).string(message.fromAddress);
+    }
+    if (message.toAddress !== "") {
+      writer.uint32(18).string(message.toAddress);
+    }
+    for (const v of message.amount) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSend {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSend();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.fromAddress = reader.string();
+          break;
+        case 2:
+          message.toAddress = reader.string();
+          break;
+        case 3:
+          message.amount.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSend>): MsgSend {
+    const message = createBaseMsgSend();
+    message.fromAddress = object.fromAddress ?? "";
+    message.toAddress = object.toAddress ?? "";
+    message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: MsgSendAmino): MsgSend {
+    const message = createBaseMsgSend();
+    if (object.from_address !== undefined && object.from_address !== null) {
+      message.fromAddress = object.from_address;
+    }
+    if (object.to_address !== undefined && object.to_address !== null) {
+      message.toAddress = object.to_address;
+    }
+    message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgSend): MsgSendAmino {
+    const obj: any = {};
+    obj.from_address = message.fromAddress === "" ? undefined : message.fromAddress;
+    obj.to_address = message.toAddress === "" ? undefined : message.toAddress;
+    if (message.amount) {
+      obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.amount = message.amount;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgSendAminoMsg): MsgSend {
+    return MsgSend.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSend): MsgSendAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSend",
+      value: MsgSend.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSendProtoMsg): MsgSend {
+    return MsgSend.decode(message.value);
+  },
+  toProto(message: MsgSend): Uint8Array {
+    return MsgSend.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSend): MsgSendProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+      value: MsgSend.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgSendResponse(): MsgSendResponse {
+  return {};
+}
+export const MsgSendResponse = {
+  typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse",
+  encode(_: MsgSendResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSendResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgSendResponse>): MsgSendResponse {
+    const message = createBaseMsgSendResponse();
+    return message;
+  },
+  fromAmino(_: MsgSendResponseAmino): MsgSendResponse {
+    const message = createBaseMsgSendResponse();
+    return message;
+  },
+  toAmino(_: MsgSendResponse): MsgSendResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgSendResponseAminoMsg): MsgSendResponse {
+    return MsgSendResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSendResponse): MsgSendResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSendResponse",
+      value: MsgSendResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSendResponseProtoMsg): MsgSendResponse {
+    return MsgSendResponse.decode(message.value);
+  },
+  toProto(message: MsgSendResponse): Uint8Array {
+    return MsgSendResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSendResponse): MsgSendResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.MsgSendResponse",
+      value: MsgSendResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgMultiSend(): MsgMultiSend {
+  return {
+    inputs: [],
+    outputs: []
+  };
+}
+export const MsgMultiSend = {
+  typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
+  encode(message: MsgMultiSend, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.inputs) {
+      Input.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.outputs) {
+      Output.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgMultiSend {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgMultiSend();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.inputs.push(Input.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.outputs.push(Output.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgMultiSend>): MsgMultiSend {
+    const message = createBaseMsgMultiSend();
+    message.inputs = object.inputs?.map(e => Input.fromPartial(e)) || [];
+    message.outputs = object.outputs?.map(e => Output.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: MsgMultiSendAmino): MsgMultiSend {
+    const message = createBaseMsgMultiSend();
+    message.inputs = object.inputs?.map(e => Input.fromAmino(e)) || [];
+    message.outputs = object.outputs?.map(e => Output.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgMultiSend): MsgMultiSendAmino {
+    const obj: any = {};
+    if (message.inputs) {
+      obj.inputs = message.inputs.map(e => e ? Input.toAmino(e) : undefined);
+    } else {
+      obj.inputs = message.inputs;
+    }
+    if (message.outputs) {
+      obj.outputs = message.outputs.map(e => e ? Output.toAmino(e) : undefined);
+    } else {
+      obj.outputs = message.outputs;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgMultiSendAminoMsg): MsgMultiSend {
+    return MsgMultiSend.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgMultiSend): MsgMultiSendAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgMultiSend",
+      value: MsgMultiSend.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgMultiSendProtoMsg): MsgMultiSend {
+    return MsgMultiSend.decode(message.value);
+  },
+  toProto(message: MsgMultiSend): Uint8Array {
+    return MsgMultiSend.encode(message).finish();
+  },
+  toProtoMsg(message: MsgMultiSend): MsgMultiSendProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.MsgMultiSend",
+      value: MsgMultiSend.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgMultiSendResponse(): MsgMultiSendResponse {
+  return {};
+}
+export const MsgMultiSendResponse = {
+  typeUrl: "/cosmos.bank.v1beta1.MsgMultiSendResponse",
+  encode(_: MsgMultiSendResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgMultiSendResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgMultiSendResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgMultiSendResponse>): MsgMultiSendResponse {
+    const message = createBaseMsgMultiSendResponse();
+    return message;
+  },
+  fromAmino(_: MsgMultiSendResponseAmino): MsgMultiSendResponse {
+    const message = createBaseMsgMultiSendResponse();
+    return message;
+  },
+  toAmino(_: MsgMultiSendResponse): MsgMultiSendResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgMultiSendResponseAminoMsg): MsgMultiSendResponse {
+    return MsgMultiSendResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgMultiSendResponse): MsgMultiSendResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgMultiSendResponse",
+      value: MsgMultiSendResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgMultiSendResponseProtoMsg): MsgMultiSendResponse {
+    return MsgMultiSendResponse.decode(message.value);
+  },
+  toProto(message: MsgMultiSendResponse): Uint8Array {
+    return MsgMultiSendResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgMultiSendResponse): MsgMultiSendResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.MsgMultiSendResponse",
+      value: MsgMultiSendResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/kv/v1beta1/kv.ts

@@ -0,0 +1,197 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/** Pairs defines a repeated slice of Pair objects. */
+export interface Pairs {
+  pairs: Pair[];
+}
+export interface PairsProtoMsg {
+  typeUrl: "/cosmos.base.kv.v1beta1.Pairs";
+  value: Uint8Array;
+}
+/** Pairs defines a repeated slice of Pair objects. */
+export interface PairsAmino {
+  pairs?: PairAmino[];
+}
+export interface PairsAminoMsg {
+  type: "cosmos-sdk/Pairs";
+  value: PairsAmino;
+}
+/** Pairs defines a repeated slice of Pair objects. */
+export interface PairsSDKType {
+  pairs: PairSDKType[];
+}
+/** Pair defines a key/value bytes tuple. */
+export interface Pair {
+  key: Uint8Array;
+  value: Uint8Array;
+}
+export interface PairProtoMsg {
+  typeUrl: "/cosmos.base.kv.v1beta1.Pair";
+  value: Uint8Array;
+}
+/** Pair defines a key/value bytes tuple. */
+export interface PairAmino {
+  key?: string;
+  value?: string;
+}
+export interface PairAminoMsg {
+  type: "cosmos-sdk/Pair";
+  value: PairAmino;
+}
+/** Pair defines a key/value bytes tuple. */
+export interface PairSDKType {
+  key: Uint8Array;
+  value: Uint8Array;
+}
+function createBasePairs(): Pairs {
+  return {
+    pairs: []
+  };
+}
+export const Pairs = {
+  typeUrl: "/cosmos.base.kv.v1beta1.Pairs",
+  encode(message: Pairs, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.pairs) {
+      Pair.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Pairs {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePairs();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.pairs.push(Pair.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Pairs>): Pairs {
+    const message = createBasePairs();
+    message.pairs = object.pairs?.map(e => Pair.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: PairsAmino): Pairs {
+    const message = createBasePairs();
+    message.pairs = object.pairs?.map(e => Pair.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Pairs): PairsAmino {
+    const obj: any = {};
+    if (message.pairs) {
+      obj.pairs = message.pairs.map(e => e ? Pair.toAmino(e) : undefined);
+    } else {
+      obj.pairs = message.pairs;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: PairsAminoMsg): Pairs {
+    return Pairs.fromAmino(object.value);
+  },
+  toAminoMsg(message: Pairs): PairsAminoMsg {
+    return {
+      type: "cosmos-sdk/Pairs",
+      value: Pairs.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PairsProtoMsg): Pairs {
+    return Pairs.decode(message.value);
+  },
+  toProto(message: Pairs): Uint8Array {
+    return Pairs.encode(message).finish();
+  },
+  toProtoMsg(message: Pairs): PairsProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.kv.v1beta1.Pairs",
+      value: Pairs.encode(message).finish()
+    };
+  }
+};
+function createBasePair(): Pair {
+  return {
+    key: new Uint8Array(),
+    value: new Uint8Array()
+  };
+}
+export const Pair = {
+  typeUrl: "/cosmos.base.kv.v1beta1.Pair",
+  encode(message: Pair, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Pair {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePair();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        case 2:
+          message.value = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Pair>): Pair {
+    const message = createBasePair();
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PairAmino): Pair {
+    const message = createBasePair();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = bytesFromBase64(object.value);
+    }
+    return message;
+  },
+  toAmino(message: Pair): PairAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.value = message.value ? base64FromBytes(message.value) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PairAminoMsg): Pair {
+    return Pair.fromAmino(object.value);
+  },
+  toAminoMsg(message: Pair): PairAminoMsg {
+    return {
+      type: "cosmos-sdk/Pair",
+      value: Pair.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PairProtoMsg): Pair {
+    return Pair.decode(message.value);
+  },
+  toProto(message: Pair): Uint8Array {
+    return Pair.encode(message).finish();
+  },
+  toProtoMsg(message: Pair): PairProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.kv.v1beta1.Pair",
+      value: Pair.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/node/v1beta1/query.lcd.ts

@@ -0,0 +1,18 @@
+import { LCDClient } from "@cosmology/lcd";
+import { ConfigRequest, ConfigResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.config = this.config.bind(this);
+  }
+  /* Config queries for the operator configuration. */
+  async config(_params: ConfigRequest = {}): Promise<ConfigResponseSDKType> {
+    const endpoint = `cosmos/base/node/v1beta1/config`;
+    return await this.req.get<ConfigResponseSDKType>(endpoint);
+  }
+}

src/codegen/cosmos/base/node/v1beta1/query.rpc.Service.ts

@@ -0,0 +1,30 @@
+import { Rpc } from "../../../../helpers";
+import { BinaryReader } from "../../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { ConfigRequest, ConfigResponse } from "./query";
+/** Service defines the gRPC querier service for node related queries. */
+export interface Service {
+  /** Config queries for the operator configuration. */
+  config(request?: ConfigRequest): Promise<ConfigResponse>;
+}
+export class ServiceClientImpl implements Service {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.config = this.config.bind(this);
+  }
+  config(request: ConfigRequest = {}): Promise<ConfigResponse> {
+    const data = ConfigRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.node.v1beta1.Service", "Config", data);
+    return promise.then(data => ConfigResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new ServiceClientImpl(rpc);
+  return {
+    config(request?: ConfigRequest): Promise<ConfigResponse> {
+      return queryService.config(request);
+    }
+  };
+};

src/codegen/cosmos/base/node/v1beta1/query.ts

@@ -0,0 +1,160 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** ConfigRequest defines the request structure for the Config gRPC query. */
+export interface ConfigRequest {}
+export interface ConfigRequestProtoMsg {
+  typeUrl: "/cosmos.base.node.v1beta1.ConfigRequest";
+  value: Uint8Array;
+}
+/** ConfigRequest defines the request structure for the Config gRPC query. */
+export interface ConfigRequestAmino {}
+export interface ConfigRequestAminoMsg {
+  type: "cosmos-sdk/ConfigRequest";
+  value: ConfigRequestAmino;
+}
+/** ConfigRequest defines the request structure for the Config gRPC query. */
+export interface ConfigRequestSDKType {}
+/** ConfigResponse defines the response structure for the Config gRPC query. */
+export interface ConfigResponse {
+  minimumGasPrice: string;
+}
+export interface ConfigResponseProtoMsg {
+  typeUrl: "/cosmos.base.node.v1beta1.ConfigResponse";
+  value: Uint8Array;
+}
+/** ConfigResponse defines the response structure for the Config gRPC query. */
+export interface ConfigResponseAmino {
+  minimum_gas_price?: string;
+}
+export interface ConfigResponseAminoMsg {
+  type: "cosmos-sdk/ConfigResponse";
+  value: ConfigResponseAmino;
+}
+/** ConfigResponse defines the response structure for the Config gRPC query. */
+export interface ConfigResponseSDKType {
+  minimum_gas_price: string;
+}
+function createBaseConfigRequest(): ConfigRequest {
+  return {};
+}
+export const ConfigRequest = {
+  typeUrl: "/cosmos.base.node.v1beta1.ConfigRequest",
+  encode(_: ConfigRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfigRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<ConfigRequest>): ConfigRequest {
+    const message = createBaseConfigRequest();
+    return message;
+  },
+  fromAmino(_: ConfigRequestAmino): ConfigRequest {
+    const message = createBaseConfigRequest();
+    return message;
+  },
+  toAmino(_: ConfigRequest): ConfigRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: ConfigRequestAminoMsg): ConfigRequest {
+    return ConfigRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: ConfigRequest): ConfigRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/ConfigRequest",
+      value: ConfigRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ConfigRequestProtoMsg): ConfigRequest {
+    return ConfigRequest.decode(message.value);
+  },
+  toProto(message: ConfigRequest): Uint8Array {
+    return ConfigRequest.encode(message).finish();
+  },
+  toProtoMsg(message: ConfigRequest): ConfigRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.node.v1beta1.ConfigRequest",
+      value: ConfigRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseConfigResponse(): ConfigResponse {
+  return {
+    minimumGasPrice: ""
+  };
+}
+export const ConfigResponse = {
+  typeUrl: "/cosmos.base.node.v1beta1.ConfigResponse",
+  encode(message: ConfigResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.minimumGasPrice !== "") {
+      writer.uint32(10).string(message.minimumGasPrice);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfigResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.minimumGasPrice = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ConfigResponse>): ConfigResponse {
+    const message = createBaseConfigResponse();
+    message.minimumGasPrice = object.minimumGasPrice ?? "";
+    return message;
+  },
+  fromAmino(object: ConfigResponseAmino): ConfigResponse {
+    const message = createBaseConfigResponse();
+    if (object.minimum_gas_price !== undefined && object.minimum_gas_price !== null) {
+      message.minimumGasPrice = object.minimum_gas_price;
+    }
+    return message;
+  },
+  toAmino(message: ConfigResponse): ConfigResponseAmino {
+    const obj: any = {};
+    obj.minimum_gas_price = message.minimumGasPrice === "" ? undefined : message.minimumGasPrice;
+    return obj;
+  },
+  fromAminoMsg(object: ConfigResponseAminoMsg): ConfigResponse {
+    return ConfigResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: ConfigResponse): ConfigResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/ConfigResponse",
+      value: ConfigResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ConfigResponseProtoMsg): ConfigResponse {
+    return ConfigResponse.decode(message.value);
+  },
+  toProto(message: ConfigResponse): Uint8Array {
+    return ConfigResponse.encode(message).finish();
+  },
+  toProtoMsg(message: ConfigResponse): ConfigResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.node.v1beta1.ConfigResponse",
+      value: ConfigResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/query/v1beta1/pagination.ts

@@ -0,0 +1,369 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ * 
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+export interface PageRequest {
+  /**
+   * key is a value returned in PageResponse.next_key to begin
+   * querying the next page most efficiently. Only one of offset or key
+   * should be set.
+   */
+  key: Uint8Array;
+  /**
+   * offset is a numeric offset that can be used when key is unavailable.
+   * It is less efficient than using key. Only one of offset or key should
+   * be set.
+   */
+  offset: bigint;
+  /**
+   * limit is the total number of results to be returned in the result page.
+   * If left empty it will default to a value to be set by each app.
+   */
+  limit: bigint;
+  /**
+   * count_total is set to true  to indicate that the result set should include
+   * a count of the total number of items available for pagination in UIs.
+   * count_total is only respected when offset is used. It is ignored when key
+   * is set.
+   */
+  countTotal: boolean;
+  /**
+   * reverse is set to true if results are to be returned in the descending order.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  reverse: boolean;
+}
+export interface PageRequestProtoMsg {
+  typeUrl: "/cosmos.base.query.v1beta1.PageRequest";
+  value: Uint8Array;
+}
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ * 
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+export interface PageRequestAmino {
+  /**
+   * key is a value returned in PageResponse.next_key to begin
+   * querying the next page most efficiently. Only one of offset or key
+   * should be set.
+   */
+  key?: string;
+  /**
+   * offset is a numeric offset that can be used when key is unavailable.
+   * It is less efficient than using key. Only one of offset or key should
+   * be set.
+   */
+  offset?: string;
+  /**
+   * limit is the total number of results to be returned in the result page.
+   * If left empty it will default to a value to be set by each app.
+   */
+  limit?: string;
+  /**
+   * count_total is set to true  to indicate that the result set should include
+   * a count of the total number of items available for pagination in UIs.
+   * count_total is only respected when offset is used. It is ignored when key
+   * is set.
+   */
+  count_total?: boolean;
+  /**
+   * reverse is set to true if results are to be returned in the descending order.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  reverse?: boolean;
+}
+export interface PageRequestAminoMsg {
+  type: "cosmos-sdk/PageRequest";
+  value: PageRequestAmino;
+}
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ * 
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+export interface PageRequestSDKType {
+  key: Uint8Array;
+  offset: bigint;
+  limit: bigint;
+  count_total: boolean;
+  reverse: boolean;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ * 
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+export interface PageResponse {
+  /**
+   * next_key is the key to be passed to PageRequest.key to
+   * query the next page most efficiently
+   */
+  nextKey: Uint8Array;
+  /**
+   * total is total number of results available if PageRequest.count_total
+   * was set, its value is undefined otherwise
+   */
+  total: bigint;
+}
+export interface PageResponseProtoMsg {
+  typeUrl: "/cosmos.base.query.v1beta1.PageResponse";
+  value: Uint8Array;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ * 
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+export interface PageResponseAmino {
+  /**
+   * next_key is the key to be passed to PageRequest.key to
+   * query the next page most efficiently
+   */
+  next_key?: string;
+  /**
+   * total is total number of results available if PageRequest.count_total
+   * was set, its value is undefined otherwise
+   */
+  total?: string;
+}
+export interface PageResponseAminoMsg {
+  type: "cosmos-sdk/PageResponse";
+  value: PageResponseAmino;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ * 
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+export interface PageResponseSDKType {
+  next_key: Uint8Array;
+  total: bigint;
+}
+function createBasePageRequest(): PageRequest {
+  return {
+    key: new Uint8Array(),
+    offset: BigInt(0),
+    limit: BigInt(0),
+    countTotal: false,
+    reverse: false
+  };
+}
+export const PageRequest = {
+  typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+  encode(message: PageRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.offset !== BigInt(0)) {
+      writer.uint32(16).uint64(message.offset);
+    }
+    if (message.limit !== BigInt(0)) {
+      writer.uint32(24).uint64(message.limit);
+    }
+    if (message.countTotal === true) {
+      writer.uint32(32).bool(message.countTotal);
+    }
+    if (message.reverse === true) {
+      writer.uint32(40).bool(message.reverse);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PageRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePageRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        case 2:
+          message.offset = reader.uint64();
+          break;
+        case 3:
+          message.limit = reader.uint64();
+          break;
+        case 4:
+          message.countTotal = reader.bool();
+          break;
+        case 5:
+          message.reverse = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PageRequest>): PageRequest {
+    const message = createBasePageRequest();
+    message.key = object.key ?? new Uint8Array();
+    message.offset = object.offset !== undefined && object.offset !== null ? BigInt(object.offset.toString()) : BigInt(0);
+    message.limit = object.limit !== undefined && object.limit !== null ? BigInt(object.limit.toString()) : BigInt(0);
+    message.countTotal = object.countTotal ?? false;
+    message.reverse = object.reverse ?? false;
+    return message;
+  },
+  fromAmino(object: PageRequestAmino): PageRequest {
+    const message = createBasePageRequest();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.offset !== undefined && object.offset !== null) {
+      message.offset = BigInt(object.offset);
+    }
+    if (object.limit !== undefined && object.limit !== null) {
+      message.limit = BigInt(object.limit);
+    }
+    if (object.count_total !== undefined && object.count_total !== null) {
+      message.countTotal = object.count_total;
+    }
+    if (object.reverse !== undefined && object.reverse !== null) {
+      message.reverse = object.reverse;
+    }
+    return message;
+  },
+  toAmino(message: PageRequest): PageRequestAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.offset = message.offset !== BigInt(0) ? message.offset.toString() : undefined;
+    obj.limit = message.limit !== BigInt(0) ? message.limit.toString() : undefined;
+    obj.count_total = message.countTotal === false ? undefined : message.countTotal;
+    obj.reverse = message.reverse === false ? undefined : message.reverse;
+    return obj;
+  },
+  fromAminoMsg(object: PageRequestAminoMsg): PageRequest {
+    return PageRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: PageRequest): PageRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/PageRequest",
+      value: PageRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PageRequestProtoMsg): PageRequest {
+    return PageRequest.decode(message.value);
+  },
+  toProto(message: PageRequest): Uint8Array {
+    return PageRequest.encode(message).finish();
+  },
+  toProtoMsg(message: PageRequest): PageRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.query.v1beta1.PageRequest",
+      value: PageRequest.encode(message).finish()
+    };
+  }
+};
+function createBasePageResponse(): PageResponse {
+  return {
+    nextKey: new Uint8Array(),
+    total: BigInt(0)
+  };
+}
+export const PageResponse = {
+  typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+  encode(message: PageResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.nextKey.length !== 0) {
+      writer.uint32(10).bytes(message.nextKey);
+    }
+    if (message.total !== BigInt(0)) {
+      writer.uint32(16).uint64(message.total);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PageResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.nextKey = reader.bytes();
+          break;
+        case 2:
+          message.total = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PageResponse>): PageResponse {
+    const message = createBasePageResponse();
+    message.nextKey = object.nextKey ?? new Uint8Array();
+    message.total = object.total !== undefined && object.total !== null ? BigInt(object.total.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: PageResponseAmino): PageResponse {
+    const message = createBasePageResponse();
+    if (object.next_key !== undefined && object.next_key !== null) {
+      message.nextKey = bytesFromBase64(object.next_key);
+    }
+    if (object.total !== undefined && object.total !== null) {
+      message.total = BigInt(object.total);
+    }
+    return message;
+  },
+  toAmino(message: PageResponse): PageResponseAmino {
+    const obj: any = {};
+    obj.next_key = message.nextKey ? base64FromBytes(message.nextKey) : undefined;
+    obj.total = message.total !== BigInt(0) ? message.total.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PageResponseAminoMsg): PageResponse {
+    return PageResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: PageResponse): PageResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/PageResponse",
+      value: PageResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PageResponseProtoMsg): PageResponse {
+    return PageResponse.decode(message.value);
+  },
+  toProto(message: PageResponse): Uint8Array {
+    return PageResponse.encode(message).finish();
+  },
+  toProtoMsg(message: PageResponse): PageResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.query.v1beta1.PageResponse",
+      value: PageResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/reflection/v1beta1/reflection.ts

@@ -0,0 +1,364 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesRequest {}
+export interface ListAllInterfacesRequestProtoMsg {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesRequest";
+  value: Uint8Array;
+}
+/** ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesRequestAmino {}
+export interface ListAllInterfacesRequestAminoMsg {
+  type: "cosmos-sdk/ListAllInterfacesRequest";
+  value: ListAllInterfacesRequestAmino;
+}
+/** ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesRequestSDKType {}
+/** ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesResponse {
+  /** interface_names is an array of all the registered interfaces. */
+  interfaceNames: string[];
+}
+export interface ListAllInterfacesResponseProtoMsg {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesResponse";
+  value: Uint8Array;
+}
+/** ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesResponseAmino {
+  /** interface_names is an array of all the registered interfaces. */
+  interface_names?: string[];
+}
+export interface ListAllInterfacesResponseAminoMsg {
+  type: "cosmos-sdk/ListAllInterfacesResponse";
+  value: ListAllInterfacesResponseAmino;
+}
+/** ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC. */
+export interface ListAllInterfacesResponseSDKType {
+  interface_names: string[];
+}
+/**
+ * ListImplementationsRequest is the request type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsRequest {
+  /** interface_name defines the interface to query the implementations for. */
+  interfaceName: string;
+}
+export interface ListImplementationsRequestProtoMsg {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsRequest";
+  value: Uint8Array;
+}
+/**
+ * ListImplementationsRequest is the request type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsRequestAmino {
+  /** interface_name defines the interface to query the implementations for. */
+  interface_name?: string;
+}
+export interface ListImplementationsRequestAminoMsg {
+  type: "cosmos-sdk/ListImplementationsRequest";
+  value: ListImplementationsRequestAmino;
+}
+/**
+ * ListImplementationsRequest is the request type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsRequestSDKType {
+  interface_name: string;
+}
+/**
+ * ListImplementationsResponse is the response type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsResponse {
+  implementationMessageNames: string[];
+}
+export interface ListImplementationsResponseProtoMsg {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsResponse";
+  value: Uint8Array;
+}
+/**
+ * ListImplementationsResponse is the response type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsResponseAmino {
+  implementation_message_names?: string[];
+}
+export interface ListImplementationsResponseAminoMsg {
+  type: "cosmos-sdk/ListImplementationsResponse";
+  value: ListImplementationsResponseAmino;
+}
+/**
+ * ListImplementationsResponse is the response type of the ListImplementations
+ * RPC.
+ */
+export interface ListImplementationsResponseSDKType {
+  implementation_message_names: string[];
+}
+function createBaseListAllInterfacesRequest(): ListAllInterfacesRequest {
+  return {};
+}
+export const ListAllInterfacesRequest = {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesRequest",
+  encode(_: ListAllInterfacesRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ListAllInterfacesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListAllInterfacesRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<ListAllInterfacesRequest>): ListAllInterfacesRequest {
+    const message = createBaseListAllInterfacesRequest();
+    return message;
+  },
+  fromAmino(_: ListAllInterfacesRequestAmino): ListAllInterfacesRequest {
+    const message = createBaseListAllInterfacesRequest();
+    return message;
+  },
+  toAmino(_: ListAllInterfacesRequest): ListAllInterfacesRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: ListAllInterfacesRequestAminoMsg): ListAllInterfacesRequest {
+    return ListAllInterfacesRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: ListAllInterfacesRequest): ListAllInterfacesRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/ListAllInterfacesRequest",
+      value: ListAllInterfacesRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ListAllInterfacesRequestProtoMsg): ListAllInterfacesRequest {
+    return ListAllInterfacesRequest.decode(message.value);
+  },
+  toProto(message: ListAllInterfacesRequest): Uint8Array {
+    return ListAllInterfacesRequest.encode(message).finish();
+  },
+  toProtoMsg(message: ListAllInterfacesRequest): ListAllInterfacesRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesRequest",
+      value: ListAllInterfacesRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseListAllInterfacesResponse(): ListAllInterfacesResponse {
+  return {
+    interfaceNames: []
+  };
+}
+export const ListAllInterfacesResponse = {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesResponse",
+  encode(message: ListAllInterfacesResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.interfaceNames) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ListAllInterfacesResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListAllInterfacesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.interfaceNames.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ListAllInterfacesResponse>): ListAllInterfacesResponse {
+    const message = createBaseListAllInterfacesResponse();
+    message.interfaceNames = object.interfaceNames?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ListAllInterfacesResponseAmino): ListAllInterfacesResponse {
+    const message = createBaseListAllInterfacesResponse();
+    message.interfaceNames = object.interface_names?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: ListAllInterfacesResponse): ListAllInterfacesResponseAmino {
+    const obj: any = {};
+    if (message.interfaceNames) {
+      obj.interface_names = message.interfaceNames.map(e => e);
+    } else {
+      obj.interface_names = message.interfaceNames;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ListAllInterfacesResponseAminoMsg): ListAllInterfacesResponse {
+    return ListAllInterfacesResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: ListAllInterfacesResponse): ListAllInterfacesResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/ListAllInterfacesResponse",
+      value: ListAllInterfacesResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ListAllInterfacesResponseProtoMsg): ListAllInterfacesResponse {
+    return ListAllInterfacesResponse.decode(message.value);
+  },
+  toProto(message: ListAllInterfacesResponse): Uint8Array {
+    return ListAllInterfacesResponse.encode(message).finish();
+  },
+  toProtoMsg(message: ListAllInterfacesResponse): ListAllInterfacesResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.reflection.v1beta1.ListAllInterfacesResponse",
+      value: ListAllInterfacesResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseListImplementationsRequest(): ListImplementationsRequest {
+  return {
+    interfaceName: ""
+  };
+}
+export const ListImplementationsRequest = {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsRequest",
+  encode(message: ListImplementationsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.interfaceName !== "") {
+      writer.uint32(10).string(message.interfaceName);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ListImplementationsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListImplementationsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.interfaceName = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ListImplementationsRequest>): ListImplementationsRequest {
+    const message = createBaseListImplementationsRequest();
+    message.interfaceName = object.interfaceName ?? "";
+    return message;
+  },
+  fromAmino(object: ListImplementationsRequestAmino): ListImplementationsRequest {
+    const message = createBaseListImplementationsRequest();
+    if (object.interface_name !== undefined && object.interface_name !== null) {
+      message.interfaceName = object.interface_name;
+    }
+    return message;
+  },
+  toAmino(message: ListImplementationsRequest): ListImplementationsRequestAmino {
+    const obj: any = {};
+    obj.interface_name = message.interfaceName === "" ? undefined : message.interfaceName;
+    return obj;
+  },
+  fromAminoMsg(object: ListImplementationsRequestAminoMsg): ListImplementationsRequest {
+    return ListImplementationsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: ListImplementationsRequest): ListImplementationsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/ListImplementationsRequest",
+      value: ListImplementationsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ListImplementationsRequestProtoMsg): ListImplementationsRequest {
+    return ListImplementationsRequest.decode(message.value);
+  },
+  toProto(message: ListImplementationsRequest): Uint8Array {
+    return ListImplementationsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: ListImplementationsRequest): ListImplementationsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsRequest",
+      value: ListImplementationsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseListImplementationsResponse(): ListImplementationsResponse {
+  return {
+    implementationMessageNames: []
+  };
+}
+export const ListImplementationsResponse = {
+  typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsResponse",
+  encode(message: ListImplementationsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.implementationMessageNames) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ListImplementationsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListImplementationsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.implementationMessageNames.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ListImplementationsResponse>): ListImplementationsResponse {
+    const message = createBaseListImplementationsResponse();
+    message.implementationMessageNames = object.implementationMessageNames?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ListImplementationsResponseAmino): ListImplementationsResponse {
+    const message = createBaseListImplementationsResponse();
+    message.implementationMessageNames = object.implementation_message_names?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: ListImplementationsResponse): ListImplementationsResponseAmino {
+    const obj: any = {};
+    if (message.implementationMessageNames) {
+      obj.implementation_message_names = message.implementationMessageNames.map(e => e);
+    } else {
+      obj.implementation_message_names = message.implementationMessageNames;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ListImplementationsResponseAminoMsg): ListImplementationsResponse {
+    return ListImplementationsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: ListImplementationsResponse): ListImplementationsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/ListImplementationsResponse",
+      value: ListImplementationsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ListImplementationsResponseProtoMsg): ListImplementationsResponse {
+    return ListImplementationsResponse.decode(message.value);
+  },
+  toProto(message: ListImplementationsResponse): Uint8Array {
+    return ListImplementationsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: ListImplementationsResponse): ListImplementationsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.reflection.v1beta1.ListImplementationsResponse",
+      value: ListImplementationsResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/snapshots/v1beta1/snapshot.ts

@@ -0,0 +1,798 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/** Snapshot contains Tendermint state sync snapshot info. */
+export interface Snapshot {
+  height: bigint;
+  format: number;
+  chunks: number;
+  hash: Uint8Array;
+  metadata: Metadata;
+}
+export interface SnapshotProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.Snapshot";
+  value: Uint8Array;
+}
+/** Snapshot contains Tendermint state sync snapshot info. */
+export interface SnapshotAmino {
+  height?: string;
+  format?: number;
+  chunks?: number;
+  hash?: string;
+  metadata?: MetadataAmino;
+}
+export interface SnapshotAminoMsg {
+  type: "cosmos-sdk/Snapshot";
+  value: SnapshotAmino;
+}
+/** Snapshot contains Tendermint state sync snapshot info. */
+export interface SnapshotSDKType {
+  height: bigint;
+  format: number;
+  chunks: number;
+  hash: Uint8Array;
+  metadata: MetadataSDKType;
+}
+/** Metadata contains SDK-specific snapshot metadata. */
+export interface Metadata {
+  /** SHA-256 chunk hashes */
+  chunkHashes: Uint8Array[];
+}
+export interface MetadataProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.Metadata";
+  value: Uint8Array;
+}
+/** Metadata contains SDK-specific snapshot metadata. */
+export interface MetadataAmino {
+  /** SHA-256 chunk hashes */
+  chunk_hashes?: string[];
+}
+export interface MetadataAminoMsg {
+  type: "cosmos-sdk/Metadata";
+  value: MetadataAmino;
+}
+/** Metadata contains SDK-specific snapshot metadata. */
+export interface MetadataSDKType {
+  chunk_hashes: Uint8Array[];
+}
+/** SnapshotItem is an item contained in a rootmulti.Store snapshot. */
+export interface SnapshotItem {
+  store?: SnapshotStoreItem;
+  iavl?: SnapshotIAVLItem;
+  extension?: SnapshotExtensionMeta;
+  extensionPayload?: SnapshotExtensionPayload;
+}
+export interface SnapshotItemProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotItem";
+  value: Uint8Array;
+}
+/** SnapshotItem is an item contained in a rootmulti.Store snapshot. */
+export interface SnapshotItemAmino {
+  store?: SnapshotStoreItemAmino;
+  iavl?: SnapshotIAVLItemAmino;
+  extension?: SnapshotExtensionMetaAmino;
+  extension_payload?: SnapshotExtensionPayloadAmino;
+}
+export interface SnapshotItemAminoMsg {
+  type: "cosmos-sdk/SnapshotItem";
+  value: SnapshotItemAmino;
+}
+/** SnapshotItem is an item contained in a rootmulti.Store snapshot. */
+export interface SnapshotItemSDKType {
+  store?: SnapshotStoreItemSDKType;
+  iavl?: SnapshotIAVLItemSDKType;
+  extension?: SnapshotExtensionMetaSDKType;
+  extension_payload?: SnapshotExtensionPayloadSDKType;
+}
+/** SnapshotStoreItem contains metadata about a snapshotted store. */
+export interface SnapshotStoreItem {
+  name: string;
+}
+export interface SnapshotStoreItemProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotStoreItem";
+  value: Uint8Array;
+}
+/** SnapshotStoreItem contains metadata about a snapshotted store. */
+export interface SnapshotStoreItemAmino {
+  name?: string;
+}
+export interface SnapshotStoreItemAminoMsg {
+  type: "cosmos-sdk/SnapshotStoreItem";
+  value: SnapshotStoreItemAmino;
+}
+/** SnapshotStoreItem contains metadata about a snapshotted store. */
+export interface SnapshotStoreItemSDKType {
+  name: string;
+}
+/** SnapshotIAVLItem is an exported IAVL node. */
+export interface SnapshotIAVLItem {
+  key: Uint8Array;
+  value: Uint8Array;
+  /** version is block height */
+  version: bigint;
+  /** height is depth of the tree. */
+  height: number;
+}
+export interface SnapshotIAVLItemProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotIAVLItem";
+  value: Uint8Array;
+}
+/** SnapshotIAVLItem is an exported IAVL node. */
+export interface SnapshotIAVLItemAmino {
+  key?: string;
+  value?: string;
+  /** version is block height */
+  version?: string;
+  /** height is depth of the tree. */
+  height?: number;
+}
+export interface SnapshotIAVLItemAminoMsg {
+  type: "cosmos-sdk/SnapshotIAVLItem";
+  value: SnapshotIAVLItemAmino;
+}
+/** SnapshotIAVLItem is an exported IAVL node. */
+export interface SnapshotIAVLItemSDKType {
+  key: Uint8Array;
+  value: Uint8Array;
+  version: bigint;
+  height: number;
+}
+/** SnapshotExtensionMeta contains metadata about an external snapshotter. */
+export interface SnapshotExtensionMeta {
+  name: string;
+  format: number;
+}
+export interface SnapshotExtensionMetaProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta";
+  value: Uint8Array;
+}
+/** SnapshotExtensionMeta contains metadata about an external snapshotter. */
+export interface SnapshotExtensionMetaAmino {
+  name?: string;
+  format?: number;
+}
+export interface SnapshotExtensionMetaAminoMsg {
+  type: "cosmos-sdk/SnapshotExtensionMeta";
+  value: SnapshotExtensionMetaAmino;
+}
+/** SnapshotExtensionMeta contains metadata about an external snapshotter. */
+export interface SnapshotExtensionMetaSDKType {
+  name: string;
+  format: number;
+}
+/** SnapshotExtensionPayload contains payloads of an external snapshotter. */
+export interface SnapshotExtensionPayload {
+  payload: Uint8Array;
+}
+export interface SnapshotExtensionPayloadProtoMsg {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload";
+  value: Uint8Array;
+}
+/** SnapshotExtensionPayload contains payloads of an external snapshotter. */
+export interface SnapshotExtensionPayloadAmino {
+  payload?: string;
+}
+export interface SnapshotExtensionPayloadAminoMsg {
+  type: "cosmos-sdk/SnapshotExtensionPayload";
+  value: SnapshotExtensionPayloadAmino;
+}
+/** SnapshotExtensionPayload contains payloads of an external snapshotter. */
+export interface SnapshotExtensionPayloadSDKType {
+  payload: Uint8Array;
+}
+function createBaseSnapshot(): Snapshot {
+  return {
+    height: BigInt(0),
+    format: 0,
+    chunks: 0,
+    hash: new Uint8Array(),
+    metadata: Metadata.fromPartial({})
+  };
+}
+export const Snapshot = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.Snapshot",
+  encode(message: Snapshot, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.height !== BigInt(0)) {
+      writer.uint32(8).uint64(message.height);
+    }
+    if (message.format !== 0) {
+      writer.uint32(16).uint32(message.format);
+    }
+    if (message.chunks !== 0) {
+      writer.uint32(24).uint32(message.chunks);
+    }
+    if (message.hash.length !== 0) {
+      writer.uint32(34).bytes(message.hash);
+    }
+    if (message.metadata !== undefined) {
+      Metadata.encode(message.metadata, writer.uint32(42).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Snapshot {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshot();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.uint64();
+          break;
+        case 2:
+          message.format = reader.uint32();
+          break;
+        case 3:
+          message.chunks = reader.uint32();
+          break;
+        case 4:
+          message.hash = reader.bytes();
+          break;
+        case 5:
+          message.metadata = Metadata.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Snapshot>): Snapshot {
+    const message = createBaseSnapshot();
+    message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+    message.format = object.format ?? 0;
+    message.chunks = object.chunks ?? 0;
+    message.hash = object.hash ?? new Uint8Array();
+    message.metadata = object.metadata !== undefined && object.metadata !== null ? Metadata.fromPartial(object.metadata) : undefined;
+    return message;
+  },
+  fromAmino(object: SnapshotAmino): Snapshot {
+    const message = createBaseSnapshot();
+    if (object.height !== undefined && object.height !== null) {
+      message.height = BigInt(object.height);
+    }
+    if (object.format !== undefined && object.format !== null) {
+      message.format = object.format;
+    }
+    if (object.chunks !== undefined && object.chunks !== null) {
+      message.chunks = object.chunks;
+    }
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = bytesFromBase64(object.hash);
+    }
+    if (object.metadata !== undefined && object.metadata !== null) {
+      message.metadata = Metadata.fromAmino(object.metadata);
+    }
+    return message;
+  },
+  toAmino(message: Snapshot): SnapshotAmino {
+    const obj: any = {};
+    obj.height = message.height !== BigInt(0) ? message.height.toString() : undefined;
+    obj.format = message.format === 0 ? undefined : message.format;
+    obj.chunks = message.chunks === 0 ? undefined : message.chunks;
+    obj.hash = message.hash ? base64FromBytes(message.hash) : undefined;
+    obj.metadata = message.metadata ? Metadata.toAmino(message.metadata) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotAminoMsg): Snapshot {
+    return Snapshot.fromAmino(object.value);
+  },
+  toAminoMsg(message: Snapshot): SnapshotAminoMsg {
+    return {
+      type: "cosmos-sdk/Snapshot",
+      value: Snapshot.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotProtoMsg): Snapshot {
+    return Snapshot.decode(message.value);
+  },
+  toProto(message: Snapshot): Uint8Array {
+    return Snapshot.encode(message).finish();
+  },
+  toProtoMsg(message: Snapshot): SnapshotProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.Snapshot",
+      value: Snapshot.encode(message).finish()
+    };
+  }
+};
+function createBaseMetadata(): Metadata {
+  return {
+    chunkHashes: []
+  };
+}
+export const Metadata = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.Metadata",
+  encode(message: Metadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.chunkHashes) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Metadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.chunkHashes.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Metadata>): Metadata {
+    const message = createBaseMetadata();
+    message.chunkHashes = object.chunkHashes?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: MetadataAmino): Metadata {
+    const message = createBaseMetadata();
+    message.chunkHashes = object.chunk_hashes?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: Metadata): MetadataAmino {
+    const obj: any = {};
+    if (message.chunkHashes) {
+      obj.chunk_hashes = message.chunkHashes.map(e => base64FromBytes(e));
+    } else {
+      obj.chunk_hashes = message.chunkHashes;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MetadataAminoMsg): Metadata {
+    return Metadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: Metadata): MetadataAminoMsg {
+    return {
+      type: "cosmos-sdk/Metadata",
+      value: Metadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MetadataProtoMsg): Metadata {
+    return Metadata.decode(message.value);
+  },
+  toProto(message: Metadata): Uint8Array {
+    return Metadata.encode(message).finish();
+  },
+  toProtoMsg(message: Metadata): MetadataProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.Metadata",
+      value: Metadata.encode(message).finish()
+    };
+  }
+};
+function createBaseSnapshotItem(): SnapshotItem {
+  return {
+    store: undefined,
+    iavl: undefined,
+    extension: undefined,
+    extensionPayload: undefined
+  };
+}
+export const SnapshotItem = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotItem",
+  encode(message: SnapshotItem, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.store !== undefined) {
+      SnapshotStoreItem.encode(message.store, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.iavl !== undefined) {
+      SnapshotIAVLItem.encode(message.iavl, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.extension !== undefined) {
+      SnapshotExtensionMeta.encode(message.extension, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.extensionPayload !== undefined) {
+      SnapshotExtensionPayload.encode(message.extensionPayload, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SnapshotItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshotItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.store = SnapshotStoreItem.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.iavl = SnapshotIAVLItem.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.extension = SnapshotExtensionMeta.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.extensionPayload = SnapshotExtensionPayload.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SnapshotItem>): SnapshotItem {
+    const message = createBaseSnapshotItem();
+    message.store = object.store !== undefined && object.store !== null ? SnapshotStoreItem.fromPartial(object.store) : undefined;
+    message.iavl = object.iavl !== undefined && object.iavl !== null ? SnapshotIAVLItem.fromPartial(object.iavl) : undefined;
+    message.extension = object.extension !== undefined && object.extension !== null ? SnapshotExtensionMeta.fromPartial(object.extension) : undefined;
+    message.extensionPayload = object.extensionPayload !== undefined && object.extensionPayload !== null ? SnapshotExtensionPayload.fromPartial(object.extensionPayload) : undefined;
+    return message;
+  },
+  fromAmino(object: SnapshotItemAmino): SnapshotItem {
+    const message = createBaseSnapshotItem();
+    if (object.store !== undefined && object.store !== null) {
+      message.store = SnapshotStoreItem.fromAmino(object.store);
+    }
+    if (object.iavl !== undefined && object.iavl !== null) {
+      message.iavl = SnapshotIAVLItem.fromAmino(object.iavl);
+    }
+    if (object.extension !== undefined && object.extension !== null) {
+      message.extension = SnapshotExtensionMeta.fromAmino(object.extension);
+    }
+    if (object.extension_payload !== undefined && object.extension_payload !== null) {
+      message.extensionPayload = SnapshotExtensionPayload.fromAmino(object.extension_payload);
+    }
+    return message;
+  },
+  toAmino(message: SnapshotItem): SnapshotItemAmino {
+    const obj: any = {};
+    obj.store = message.store ? SnapshotStoreItem.toAmino(message.store) : undefined;
+    obj.iavl = message.iavl ? SnapshotIAVLItem.toAmino(message.iavl) : undefined;
+    obj.extension = message.extension ? SnapshotExtensionMeta.toAmino(message.extension) : undefined;
+    obj.extension_payload = message.extensionPayload ? SnapshotExtensionPayload.toAmino(message.extensionPayload) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotItemAminoMsg): SnapshotItem {
+    return SnapshotItem.fromAmino(object.value);
+  },
+  toAminoMsg(message: SnapshotItem): SnapshotItemAminoMsg {
+    return {
+      type: "cosmos-sdk/SnapshotItem",
+      value: SnapshotItem.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotItemProtoMsg): SnapshotItem {
+    return SnapshotItem.decode(message.value);
+  },
+  toProto(message: SnapshotItem): Uint8Array {
+    return SnapshotItem.encode(message).finish();
+  },
+  toProtoMsg(message: SnapshotItem): SnapshotItemProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotItem",
+      value: SnapshotItem.encode(message).finish()
+    };
+  }
+};
+function createBaseSnapshotStoreItem(): SnapshotStoreItem {
+  return {
+    name: ""
+  };
+}
+export const SnapshotStoreItem = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotStoreItem",
+  encode(message: SnapshotStoreItem, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SnapshotStoreItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshotStoreItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SnapshotStoreItem>): SnapshotStoreItem {
+    const message = createBaseSnapshotStoreItem();
+    message.name = object.name ?? "";
+    return message;
+  },
+  fromAmino(object: SnapshotStoreItemAmino): SnapshotStoreItem {
+    const message = createBaseSnapshotStoreItem();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    return message;
+  },
+  toAmino(message: SnapshotStoreItem): SnapshotStoreItemAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotStoreItemAminoMsg): SnapshotStoreItem {
+    return SnapshotStoreItem.fromAmino(object.value);
+  },
+  toAminoMsg(message: SnapshotStoreItem): SnapshotStoreItemAminoMsg {
+    return {
+      type: "cosmos-sdk/SnapshotStoreItem",
+      value: SnapshotStoreItem.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotStoreItemProtoMsg): SnapshotStoreItem {
+    return SnapshotStoreItem.decode(message.value);
+  },
+  toProto(message: SnapshotStoreItem): Uint8Array {
+    return SnapshotStoreItem.encode(message).finish();
+  },
+  toProtoMsg(message: SnapshotStoreItem): SnapshotStoreItemProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotStoreItem",
+      value: SnapshotStoreItem.encode(message).finish()
+    };
+  }
+};
+function createBaseSnapshotIAVLItem(): SnapshotIAVLItem {
+  return {
+    key: new Uint8Array(),
+    value: new Uint8Array(),
+    version: BigInt(0),
+    height: 0
+  };
+}
+export const SnapshotIAVLItem = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotIAVLItem",
+  encode(message: SnapshotIAVLItem, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    if (message.version !== BigInt(0)) {
+      writer.uint32(24).int64(message.version);
+    }
+    if (message.height !== 0) {
+      writer.uint32(32).int32(message.height);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SnapshotIAVLItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshotIAVLItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        case 2:
+          message.value = reader.bytes();
+          break;
+        case 3:
+          message.version = reader.int64();
+          break;
+        case 4:
+          message.height = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SnapshotIAVLItem>): SnapshotIAVLItem {
+    const message = createBaseSnapshotIAVLItem();
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    message.version = object.version !== undefined && object.version !== null ? BigInt(object.version.toString()) : BigInt(0);
+    message.height = object.height ?? 0;
+    return message;
+  },
+  fromAmino(object: SnapshotIAVLItemAmino): SnapshotIAVLItem {
+    const message = createBaseSnapshotIAVLItem();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = bytesFromBase64(object.value);
+    }
+    if (object.version !== undefined && object.version !== null) {
+      message.version = BigInt(object.version);
+    }
+    if (object.height !== undefined && object.height !== null) {
+      message.height = object.height;
+    }
+    return message;
+  },
+  toAmino(message: SnapshotIAVLItem): SnapshotIAVLItemAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.value = message.value ? base64FromBytes(message.value) : undefined;
+    obj.version = message.version !== BigInt(0) ? message.version.toString() : undefined;
+    obj.height = message.height === 0 ? undefined : message.height;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotIAVLItemAminoMsg): SnapshotIAVLItem {
+    return SnapshotIAVLItem.fromAmino(object.value);
+  },
+  toAminoMsg(message: SnapshotIAVLItem): SnapshotIAVLItemAminoMsg {
+    return {
+      type: "cosmos-sdk/SnapshotIAVLItem",
+      value: SnapshotIAVLItem.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotIAVLItemProtoMsg): SnapshotIAVLItem {
+    return SnapshotIAVLItem.decode(message.value);
+  },
+  toProto(message: SnapshotIAVLItem): Uint8Array {
+    return SnapshotIAVLItem.encode(message).finish();
+  },
+  toProtoMsg(message: SnapshotIAVLItem): SnapshotIAVLItemProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotIAVLItem",
+      value: SnapshotIAVLItem.encode(message).finish()
+    };
+  }
+};
+function createBaseSnapshotExtensionMeta(): SnapshotExtensionMeta {
+  return {
+    name: "",
+    format: 0
+  };
+}
+export const SnapshotExtensionMeta = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta",
+  encode(message: SnapshotExtensionMeta, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.format !== 0) {
+      writer.uint32(16).uint32(message.format);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SnapshotExtensionMeta {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshotExtensionMeta();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        case 2:
+          message.format = reader.uint32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SnapshotExtensionMeta>): SnapshotExtensionMeta {
+    const message = createBaseSnapshotExtensionMeta();
+    message.name = object.name ?? "";
+    message.format = object.format ?? 0;
+    return message;
+  },
+  fromAmino(object: SnapshotExtensionMetaAmino): SnapshotExtensionMeta {
+    const message = createBaseSnapshotExtensionMeta();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.format !== undefined && object.format !== null) {
+      message.format = object.format;
+    }
+    return message;
+  },
+  toAmino(message: SnapshotExtensionMeta): SnapshotExtensionMetaAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    obj.format = message.format === 0 ? undefined : message.format;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotExtensionMetaAminoMsg): SnapshotExtensionMeta {
+    return SnapshotExtensionMeta.fromAmino(object.value);
+  },
+  toAminoMsg(message: SnapshotExtensionMeta): SnapshotExtensionMetaAminoMsg {
+    return {
+      type: "cosmos-sdk/SnapshotExtensionMeta",
+      value: SnapshotExtensionMeta.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotExtensionMetaProtoMsg): SnapshotExtensionMeta {
+    return SnapshotExtensionMeta.decode(message.value);
+  },
+  toProto(message: SnapshotExtensionMeta): Uint8Array {
+    return SnapshotExtensionMeta.encode(message).finish();
+  },
+  toProtoMsg(message: SnapshotExtensionMeta): SnapshotExtensionMetaProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta",
+      value: SnapshotExtensionMeta.encode(message).finish()
+    };
+  }
+};
+function createBaseSnapshotExtensionPayload(): SnapshotExtensionPayload {
+  return {
+    payload: new Uint8Array()
+  };
+}
+export const SnapshotExtensionPayload = {
+  typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload",
+  encode(message: SnapshotExtensionPayload, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.payload.length !== 0) {
+      writer.uint32(10).bytes(message.payload);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SnapshotExtensionPayload {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshotExtensionPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.payload = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<SnapshotExtensionPayload>): SnapshotExtensionPayload {
+    const message = createBaseSnapshotExtensionPayload();
+    message.payload = object.payload ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: SnapshotExtensionPayloadAmino): SnapshotExtensionPayload {
+    const message = createBaseSnapshotExtensionPayload();
+    if (object.payload !== undefined && object.payload !== null) {
+      message.payload = bytesFromBase64(object.payload);
+    }
+    return message;
+  },
+  toAmino(message: SnapshotExtensionPayload): SnapshotExtensionPayloadAmino {
+    const obj: any = {};
+    obj.payload = message.payload ? base64FromBytes(message.payload) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: SnapshotExtensionPayloadAminoMsg): SnapshotExtensionPayload {
+    return SnapshotExtensionPayload.fromAmino(object.value);
+  },
+  toAminoMsg(message: SnapshotExtensionPayload): SnapshotExtensionPayloadAminoMsg {
+    return {
+      type: "cosmos-sdk/SnapshotExtensionPayload",
+      value: SnapshotExtensionPayload.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SnapshotExtensionPayloadProtoMsg): SnapshotExtensionPayload {
+    return SnapshotExtensionPayload.decode(message.value);
+  },
+  toProto(message: SnapshotExtensionPayload): Uint8Array {
+    return SnapshotExtensionPayload.encode(message).finish();
+  },
+  toProtoMsg(message: SnapshotExtensionPayload): SnapshotExtensionPayloadProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload",
+      value: SnapshotExtensionPayload.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/store/v1beta1/commit_info.ts

@@ -0,0 +1,343 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/**
+ * CommitInfo defines commit information used by the multi-store when committing
+ * a version/height.
+ */
+export interface CommitInfo {
+  version: bigint;
+  storeInfos: StoreInfo[];
+}
+export interface CommitInfoProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.CommitInfo";
+  value: Uint8Array;
+}
+/**
+ * CommitInfo defines commit information used by the multi-store when committing
+ * a version/height.
+ */
+export interface CommitInfoAmino {
+  version?: string;
+  store_infos?: StoreInfoAmino[];
+}
+export interface CommitInfoAminoMsg {
+  type: "cosmos-sdk/CommitInfo";
+  value: CommitInfoAmino;
+}
+/**
+ * CommitInfo defines commit information used by the multi-store when committing
+ * a version/height.
+ */
+export interface CommitInfoSDKType {
+  version: bigint;
+  store_infos: StoreInfoSDKType[];
+}
+/**
+ * StoreInfo defines store-specific commit information. It contains a reference
+ * between a store name and the commit ID.
+ */
+export interface StoreInfo {
+  name: string;
+  commitId: CommitID;
+}
+export interface StoreInfoProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.StoreInfo";
+  value: Uint8Array;
+}
+/**
+ * StoreInfo defines store-specific commit information. It contains a reference
+ * between a store name and the commit ID.
+ */
+export interface StoreInfoAmino {
+  name?: string;
+  commit_id?: CommitIDAmino;
+}
+export interface StoreInfoAminoMsg {
+  type: "cosmos-sdk/StoreInfo";
+  value: StoreInfoAmino;
+}
+/**
+ * StoreInfo defines store-specific commit information. It contains a reference
+ * between a store name and the commit ID.
+ */
+export interface StoreInfoSDKType {
+  name: string;
+  commit_id: CommitIDSDKType;
+}
+/**
+ * CommitID defines the committment information when a specific store is
+ * committed.
+ */
+export interface CommitID {
+  version: bigint;
+  hash: Uint8Array;
+}
+export interface CommitIDProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.CommitID";
+  value: Uint8Array;
+}
+/**
+ * CommitID defines the committment information when a specific store is
+ * committed.
+ */
+export interface CommitIDAmino {
+  version?: string;
+  hash?: string;
+}
+export interface CommitIDAminoMsg {
+  type: "cosmos-sdk/CommitID";
+  value: CommitIDAmino;
+}
+/**
+ * CommitID defines the committment information when a specific store is
+ * committed.
+ */
+export interface CommitIDSDKType {
+  version: bigint;
+  hash: Uint8Array;
+}
+function createBaseCommitInfo(): CommitInfo {
+  return {
+    version: BigInt(0),
+    storeInfos: []
+  };
+}
+export const CommitInfo = {
+  typeUrl: "/cosmos.base.store.v1beta1.CommitInfo",
+  encode(message: CommitInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.version !== BigInt(0)) {
+      writer.uint32(8).int64(message.version);
+    }
+    for (const v of message.storeInfos) {
+      StoreInfo.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CommitInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommitInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.version = reader.int64();
+          break;
+        case 2:
+          message.storeInfos.push(StoreInfo.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CommitInfo>): CommitInfo {
+    const message = createBaseCommitInfo();
+    message.version = object.version !== undefined && object.version !== null ? BigInt(object.version.toString()) : BigInt(0);
+    message.storeInfos = object.storeInfos?.map(e => StoreInfo.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: CommitInfoAmino): CommitInfo {
+    const message = createBaseCommitInfo();
+    if (object.version !== undefined && object.version !== null) {
+      message.version = BigInt(object.version);
+    }
+    message.storeInfos = object.store_infos?.map(e => StoreInfo.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: CommitInfo): CommitInfoAmino {
+    const obj: any = {};
+    obj.version = message.version !== BigInt(0) ? message.version.toString() : undefined;
+    if (message.storeInfos) {
+      obj.store_infos = message.storeInfos.map(e => e ? StoreInfo.toAmino(e) : undefined);
+    } else {
+      obj.store_infos = message.storeInfos;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: CommitInfoAminoMsg): CommitInfo {
+    return CommitInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message: CommitInfo): CommitInfoAminoMsg {
+    return {
+      type: "cosmos-sdk/CommitInfo",
+      value: CommitInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CommitInfoProtoMsg): CommitInfo {
+    return CommitInfo.decode(message.value);
+  },
+  toProto(message: CommitInfo): Uint8Array {
+    return CommitInfo.encode(message).finish();
+  },
+  toProtoMsg(message: CommitInfo): CommitInfoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.CommitInfo",
+      value: CommitInfo.encode(message).finish()
+    };
+  }
+};
+function createBaseStoreInfo(): StoreInfo {
+  return {
+    name: "",
+    commitId: CommitID.fromPartial({})
+  };
+}
+export const StoreInfo = {
+  typeUrl: "/cosmos.base.store.v1beta1.StoreInfo",
+  encode(message: StoreInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.commitId !== undefined) {
+      CommitID.encode(message.commitId, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): StoreInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStoreInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+        case 2:
+          message.commitId = CommitID.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<StoreInfo>): StoreInfo {
+    const message = createBaseStoreInfo();
+    message.name = object.name ?? "";
+    message.commitId = object.commitId !== undefined && object.commitId !== null ? CommitID.fromPartial(object.commitId) : undefined;
+    return message;
+  },
+  fromAmino(object: StoreInfoAmino): StoreInfo {
+    const message = createBaseStoreInfo();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.commit_id !== undefined && object.commit_id !== null) {
+      message.commitId = CommitID.fromAmino(object.commit_id);
+    }
+    return message;
+  },
+  toAmino(message: StoreInfo): StoreInfoAmino {
+    const obj: any = {};
+    obj.name = message.name === "" ? undefined : message.name;
+    obj.commit_id = message.commitId ? CommitID.toAmino(message.commitId) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: StoreInfoAminoMsg): StoreInfo {
+    return StoreInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message: StoreInfo): StoreInfoAminoMsg {
+    return {
+      type: "cosmos-sdk/StoreInfo",
+      value: StoreInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: StoreInfoProtoMsg): StoreInfo {
+    return StoreInfo.decode(message.value);
+  },
+  toProto(message: StoreInfo): Uint8Array {
+    return StoreInfo.encode(message).finish();
+  },
+  toProtoMsg(message: StoreInfo): StoreInfoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.StoreInfo",
+      value: StoreInfo.encode(message).finish()
+    };
+  }
+};
+function createBaseCommitID(): CommitID {
+  return {
+    version: BigInt(0),
+    hash: new Uint8Array()
+  };
+}
+export const CommitID = {
+  typeUrl: "/cosmos.base.store.v1beta1.CommitID",
+  encode(message: CommitID, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.version !== BigInt(0)) {
+      writer.uint32(8).int64(message.version);
+    }
+    if (message.hash.length !== 0) {
+      writer.uint32(18).bytes(message.hash);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CommitID {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommitID();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.version = reader.int64();
+          break;
+        case 2:
+          message.hash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CommitID>): CommitID {
+    const message = createBaseCommitID();
+    message.version = object.version !== undefined && object.version !== null ? BigInt(object.version.toString()) : BigInt(0);
+    message.hash = object.hash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: CommitIDAmino): CommitID {
+    const message = createBaseCommitID();
+    if (object.version !== undefined && object.version !== null) {
+      message.version = BigInt(object.version);
+    }
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = bytesFromBase64(object.hash);
+    }
+    return message;
+  },
+  toAmino(message: CommitID): CommitIDAmino {
+    const obj: any = {};
+    obj.version = message.version !== BigInt(0) ? message.version.toString() : undefined;
+    obj.hash = message.hash ? base64FromBytes(message.hash) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: CommitIDAminoMsg): CommitID {
+    return CommitID.fromAmino(object.value);
+  },
+  toAminoMsg(message: CommitID): CommitIDAminoMsg {
+    return {
+      type: "cosmos-sdk/CommitID",
+      value: CommitID.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CommitIDProtoMsg): CommitID {
+    return CommitID.decode(message.value);
+  },
+  toProto(message: CommitID): Uint8Array {
+    return CommitID.encode(message).finish();
+  },
+  toProtoMsg(message: CommitID): CommitIDProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.CommitID",
+      value: CommitID.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/store/v1beta1/listening.ts

@@ -0,0 +1,438 @@
+import { RequestDeliverTx, RequestDeliverTxAmino, RequestDeliverTxSDKType, ResponseDeliverTx, ResponseDeliverTxAmino, ResponseDeliverTxSDKType, RequestBeginBlock, RequestBeginBlockAmino, RequestBeginBlockSDKType, ResponseBeginBlock, ResponseBeginBlockAmino, ResponseBeginBlockSDKType, RequestEndBlock, RequestEndBlockAmino, RequestEndBlockSDKType, ResponseEndBlock, ResponseEndBlockAmino, ResponseEndBlockSDKType, ResponseCommit, ResponseCommitAmino, ResponseCommitSDKType } from "../../../../tendermint/abci/types";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/**
+ * StoreKVPair is a KVStore KVPair used for listening to state changes (Sets and Deletes)
+ * It optionally includes the StoreKey for the originating KVStore and a Boolean flag to distinguish between Sets and
+ * Deletes
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface StoreKVPair {
+  /** the store key for the KVStore this pair originates from */
+  storeKey: string;
+  /** true indicates a delete operation, false indicates a set operation */
+  delete: boolean;
+  key: Uint8Array;
+  value: Uint8Array;
+}
+export interface StoreKVPairProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.StoreKVPair";
+  value: Uint8Array;
+}
+/**
+ * StoreKVPair is a KVStore KVPair used for listening to state changes (Sets and Deletes)
+ * It optionally includes the StoreKey for the originating KVStore and a Boolean flag to distinguish between Sets and
+ * Deletes
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface StoreKVPairAmino {
+  /** the store key for the KVStore this pair originates from */
+  store_key?: string;
+  /** true indicates a delete operation, false indicates a set operation */
+  delete?: boolean;
+  key?: string;
+  value?: string;
+}
+export interface StoreKVPairAminoMsg {
+  type: "cosmos-sdk/StoreKVPair";
+  value: StoreKVPairAmino;
+}
+/**
+ * StoreKVPair is a KVStore KVPair used for listening to state changes (Sets and Deletes)
+ * It optionally includes the StoreKey for the originating KVStore and a Boolean flag to distinguish between Sets and
+ * Deletes
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface StoreKVPairSDKType {
+  store_key: string;
+  delete: boolean;
+  key: Uint8Array;
+  value: Uint8Array;
+}
+/**
+ * BlockMetadata contains all the abci event data of a block
+ * the file streamer dump them into files together with the state changes.
+ */
+export interface BlockMetadata {
+  requestBeginBlock?: RequestBeginBlock;
+  responseBeginBlock?: ResponseBeginBlock;
+  deliverTxs: BlockMetadata_DeliverTx[];
+  requestEndBlock?: RequestEndBlock;
+  responseEndBlock?: ResponseEndBlock;
+  responseCommit?: ResponseCommit;
+}
+export interface BlockMetadataProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.BlockMetadata";
+  value: Uint8Array;
+}
+/**
+ * BlockMetadata contains all the abci event data of a block
+ * the file streamer dump them into files together with the state changes.
+ */
+export interface BlockMetadataAmino {
+  request_begin_block?: RequestBeginBlockAmino;
+  response_begin_block?: ResponseBeginBlockAmino;
+  deliver_txs?: BlockMetadata_DeliverTxAmino[];
+  request_end_block?: RequestEndBlockAmino;
+  response_end_block?: ResponseEndBlockAmino;
+  response_commit?: ResponseCommitAmino;
+}
+export interface BlockMetadataAminoMsg {
+  type: "cosmos-sdk/BlockMetadata";
+  value: BlockMetadataAmino;
+}
+/**
+ * BlockMetadata contains all the abci event data of a block
+ * the file streamer dump them into files together with the state changes.
+ */
+export interface BlockMetadataSDKType {
+  request_begin_block?: RequestBeginBlockSDKType;
+  response_begin_block?: ResponseBeginBlockSDKType;
+  deliver_txs: BlockMetadata_DeliverTxSDKType[];
+  request_end_block?: RequestEndBlockSDKType;
+  response_end_block?: ResponseEndBlockSDKType;
+  response_commit?: ResponseCommitSDKType;
+}
+/** DeliverTx encapulate deliver tx request and response. */
+export interface BlockMetadata_DeliverTx {
+  request?: RequestDeliverTx;
+  response?: ResponseDeliverTx;
+}
+export interface BlockMetadata_DeliverTxProtoMsg {
+  typeUrl: "/cosmos.base.store.v1beta1.DeliverTx";
+  value: Uint8Array;
+}
+/** DeliverTx encapulate deliver tx request and response. */
+export interface BlockMetadata_DeliverTxAmino {
+  request?: RequestDeliverTxAmino;
+  response?: ResponseDeliverTxAmino;
+}
+export interface BlockMetadata_DeliverTxAminoMsg {
+  type: "cosmos-sdk/DeliverTx";
+  value: BlockMetadata_DeliverTxAmino;
+}
+/** DeliverTx encapulate deliver tx request and response. */
+export interface BlockMetadata_DeliverTxSDKType {
+  request?: RequestDeliverTxSDKType;
+  response?: ResponseDeliverTxSDKType;
+}
+function createBaseStoreKVPair(): StoreKVPair {
+  return {
+    storeKey: "",
+    delete: false,
+    key: new Uint8Array(),
+    value: new Uint8Array()
+  };
+}
+export const StoreKVPair = {
+  typeUrl: "/cosmos.base.store.v1beta1.StoreKVPair",
+  encode(message: StoreKVPair, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.storeKey !== "") {
+      writer.uint32(10).string(message.storeKey);
+    }
+    if (message.delete === true) {
+      writer.uint32(16).bool(message.delete);
+    }
+    if (message.key.length !== 0) {
+      writer.uint32(26).bytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(34).bytes(message.value);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): StoreKVPair {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStoreKVPair();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.storeKey = reader.string();
+          break;
+        case 2:
+          message.delete = reader.bool();
+          break;
+        case 3:
+          message.key = reader.bytes();
+          break;
+        case 4:
+          message.value = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<StoreKVPair>): StoreKVPair {
+    const message = createBaseStoreKVPair();
+    message.storeKey = object.storeKey ?? "";
+    message.delete = object.delete ?? false;
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: StoreKVPairAmino): StoreKVPair {
+    const message = createBaseStoreKVPair();
+    if (object.store_key !== undefined && object.store_key !== null) {
+      message.storeKey = object.store_key;
+    }
+    if (object.delete !== undefined && object.delete !== null) {
+      message.delete = object.delete;
+    }
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = bytesFromBase64(object.value);
+    }
+    return message;
+  },
+  toAmino(message: StoreKVPair): StoreKVPairAmino {
+    const obj: any = {};
+    obj.store_key = message.storeKey === "" ? undefined : message.storeKey;
+    obj.delete = message.delete === false ? undefined : message.delete;
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    obj.value = message.value ? base64FromBytes(message.value) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: StoreKVPairAminoMsg): StoreKVPair {
+    return StoreKVPair.fromAmino(object.value);
+  },
+  toAminoMsg(message: StoreKVPair): StoreKVPairAminoMsg {
+    return {
+      type: "cosmos-sdk/StoreKVPair",
+      value: StoreKVPair.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: StoreKVPairProtoMsg): StoreKVPair {
+    return StoreKVPair.decode(message.value);
+  },
+  toProto(message: StoreKVPair): Uint8Array {
+    return StoreKVPair.encode(message).finish();
+  },
+  toProtoMsg(message: StoreKVPair): StoreKVPairProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.StoreKVPair",
+      value: StoreKVPair.encode(message).finish()
+    };
+  }
+};
+function createBaseBlockMetadata(): BlockMetadata {
+  return {
+    requestBeginBlock: undefined,
+    responseBeginBlock: undefined,
+    deliverTxs: [],
+    requestEndBlock: undefined,
+    responseEndBlock: undefined,
+    responseCommit: undefined
+  };
+}
+export const BlockMetadata = {
+  typeUrl: "/cosmos.base.store.v1beta1.BlockMetadata",
+  encode(message: BlockMetadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.requestBeginBlock !== undefined) {
+      RequestBeginBlock.encode(message.requestBeginBlock, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.responseBeginBlock !== undefined) {
+      ResponseBeginBlock.encode(message.responseBeginBlock, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.deliverTxs) {
+      BlockMetadata_DeliverTx.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.requestEndBlock !== undefined) {
+      RequestEndBlock.encode(message.requestEndBlock, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.responseEndBlock !== undefined) {
+      ResponseEndBlock.encode(message.responseEndBlock, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.responseCommit !== undefined) {
+      ResponseCommit.encode(message.responseCommit, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): BlockMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.requestBeginBlock = RequestBeginBlock.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.responseBeginBlock = ResponseBeginBlock.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.deliverTxs.push(BlockMetadata_DeliverTx.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.requestEndBlock = RequestEndBlock.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.responseEndBlock = ResponseEndBlock.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.responseCommit = ResponseCommit.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<BlockMetadata>): BlockMetadata {
+    const message = createBaseBlockMetadata();
+    message.requestBeginBlock = object.requestBeginBlock !== undefined && object.requestBeginBlock !== null ? RequestBeginBlock.fromPartial(object.requestBeginBlock) : undefined;
+    message.responseBeginBlock = object.responseBeginBlock !== undefined && object.responseBeginBlock !== null ? ResponseBeginBlock.fromPartial(object.responseBeginBlock) : undefined;
+    message.deliverTxs = object.deliverTxs?.map(e => BlockMetadata_DeliverTx.fromPartial(e)) || [];
+    message.requestEndBlock = object.requestEndBlock !== undefined && object.requestEndBlock !== null ? RequestEndBlock.fromPartial(object.requestEndBlock) : undefined;
+    message.responseEndBlock = object.responseEndBlock !== undefined && object.responseEndBlock !== null ? ResponseEndBlock.fromPartial(object.responseEndBlock) : undefined;
+    message.responseCommit = object.responseCommit !== undefined && object.responseCommit !== null ? ResponseCommit.fromPartial(object.responseCommit) : undefined;
+    return message;
+  },
+  fromAmino(object: BlockMetadataAmino): BlockMetadata {
+    const message = createBaseBlockMetadata();
+    if (object.request_begin_block !== undefined && object.request_begin_block !== null) {
+      message.requestBeginBlock = RequestBeginBlock.fromAmino(object.request_begin_block);
+    }
+    if (object.response_begin_block !== undefined && object.response_begin_block !== null) {
+      message.responseBeginBlock = ResponseBeginBlock.fromAmino(object.response_begin_block);
+    }
+    message.deliverTxs = object.deliver_txs?.map(e => BlockMetadata_DeliverTx.fromAmino(e)) || [];
+    if (object.request_end_block !== undefined && object.request_end_block !== null) {
+      message.requestEndBlock = RequestEndBlock.fromAmino(object.request_end_block);
+    }
+    if (object.response_end_block !== undefined && object.response_end_block !== null) {
+      message.responseEndBlock = ResponseEndBlock.fromAmino(object.response_end_block);
+    }
+    if (object.response_commit !== undefined && object.response_commit !== null) {
+      message.responseCommit = ResponseCommit.fromAmino(object.response_commit);
+    }
+    return message;
+  },
+  toAmino(message: BlockMetadata): BlockMetadataAmino {
+    const obj: any = {};
+    obj.request_begin_block = message.requestBeginBlock ? RequestBeginBlock.toAmino(message.requestBeginBlock) : undefined;
+    obj.response_begin_block = message.responseBeginBlock ? ResponseBeginBlock.toAmino(message.responseBeginBlock) : undefined;
+    if (message.deliverTxs) {
+      obj.deliver_txs = message.deliverTxs.map(e => e ? BlockMetadata_DeliverTx.toAmino(e) : undefined);
+    } else {
+      obj.deliver_txs = message.deliverTxs;
+    }
+    obj.request_end_block = message.requestEndBlock ? RequestEndBlock.toAmino(message.requestEndBlock) : undefined;
+    obj.response_end_block = message.responseEndBlock ? ResponseEndBlock.toAmino(message.responseEndBlock) : undefined;
+    obj.response_commit = message.responseCommit ? ResponseCommit.toAmino(message.responseCommit) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: BlockMetadataAminoMsg): BlockMetadata {
+    return BlockMetadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: BlockMetadata): BlockMetadataAminoMsg {
+    return {
+      type: "cosmos-sdk/BlockMetadata",
+      value: BlockMetadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BlockMetadataProtoMsg): BlockMetadata {
+    return BlockMetadata.decode(message.value);
+  },
+  toProto(message: BlockMetadata): Uint8Array {
+    return BlockMetadata.encode(message).finish();
+  },
+  toProtoMsg(message: BlockMetadata): BlockMetadataProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.BlockMetadata",
+      value: BlockMetadata.encode(message).finish()
+    };
+  }
+};
+function createBaseBlockMetadata_DeliverTx(): BlockMetadata_DeliverTx {
+  return {
+    request: undefined,
+    response: undefined
+  };
+}
+export const BlockMetadata_DeliverTx = {
+  typeUrl: "/cosmos.base.store.v1beta1.DeliverTx",
+  encode(message: BlockMetadata_DeliverTx, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.request !== undefined) {
+      RequestDeliverTx.encode(message.request, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.response !== undefined) {
+      ResponseDeliverTx.encode(message.response, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): BlockMetadata_DeliverTx {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockMetadata_DeliverTx();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.request = RequestDeliverTx.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.response = ResponseDeliverTx.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<BlockMetadata_DeliverTx>): BlockMetadata_DeliverTx {
+    const message = createBaseBlockMetadata_DeliverTx();
+    message.request = object.request !== undefined && object.request !== null ? RequestDeliverTx.fromPartial(object.request) : undefined;
+    message.response = object.response !== undefined && object.response !== null ? ResponseDeliverTx.fromPartial(object.response) : undefined;
+    return message;
+  },
+  fromAmino(object: BlockMetadata_DeliverTxAmino): BlockMetadata_DeliverTx {
+    const message = createBaseBlockMetadata_DeliverTx();
+    if (object.request !== undefined && object.request !== null) {
+      message.request = RequestDeliverTx.fromAmino(object.request);
+    }
+    if (object.response !== undefined && object.response !== null) {
+      message.response = ResponseDeliverTx.fromAmino(object.response);
+    }
+    return message;
+  },
+  toAmino(message: BlockMetadata_DeliverTx): BlockMetadata_DeliverTxAmino {
+    const obj: any = {};
+    obj.request = message.request ? RequestDeliverTx.toAmino(message.request) : undefined;
+    obj.response = message.response ? ResponseDeliverTx.toAmino(message.response) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: BlockMetadata_DeliverTxAminoMsg): BlockMetadata_DeliverTx {
+    return BlockMetadata_DeliverTx.fromAmino(object.value);
+  },
+  toAminoMsg(message: BlockMetadata_DeliverTx): BlockMetadata_DeliverTxAminoMsg {
+    return {
+      type: "cosmos-sdk/DeliverTx",
+      value: BlockMetadata_DeliverTx.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BlockMetadata_DeliverTxProtoMsg): BlockMetadata_DeliverTx {
+    return BlockMetadata_DeliverTx.decode(message.value);
+  },
+  toProto(message: BlockMetadata_DeliverTx): Uint8Array {
+    return BlockMetadata_DeliverTx.encode(message).finish();
+  },
+  toProtoMsg(message: BlockMetadata_DeliverTx): BlockMetadata_DeliverTxProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.store.v1beta1.DeliverTx",
+      value: BlockMetadata_DeliverTx.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/base/tendermint/v1beta1/query.lcd.ts

@@ -0,0 +1,63 @@
+import { setPaginationParams } from "../../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { GetNodeInfoRequest, GetNodeInfoResponseSDKType, GetSyncingRequest, GetSyncingResponseSDKType, GetLatestBlockRequest, GetLatestBlockResponseSDKType, GetBlockByHeightRequest, GetBlockByHeightResponseSDKType, GetLatestValidatorSetRequest, GetLatestValidatorSetResponseSDKType, GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.getNodeInfo = this.getNodeInfo.bind(this);
+    this.getSyncing = this.getSyncing.bind(this);
+    this.getLatestBlock = this.getLatestBlock.bind(this);
+    this.getBlockByHeight = this.getBlockByHeight.bind(this);
+    this.getLatestValidatorSet = this.getLatestValidatorSet.bind(this);
+    this.getValidatorSetByHeight = this.getValidatorSetByHeight.bind(this);
+  }
+  /* GetNodeInfo queries the current node info. */
+  async getNodeInfo(_params: GetNodeInfoRequest = {}): Promise<GetNodeInfoResponseSDKType> {
+    const endpoint = `cosmos/base/tendermint/v1beta1/node_info`;
+    return await this.req.get<GetNodeInfoResponseSDKType>(endpoint);
+  }
+  /* GetSyncing queries node syncing. */
+  async getSyncing(_params: GetSyncingRequest = {}): Promise<GetSyncingResponseSDKType> {
+    const endpoint = `cosmos/base/tendermint/v1beta1/syncing`;
+    return await this.req.get<GetSyncingResponseSDKType>(endpoint);
+  }
+  /* GetLatestBlock returns the latest block. */
+  async getLatestBlock(_params: GetLatestBlockRequest = {}): Promise<GetLatestBlockResponseSDKType> {
+    const endpoint = `cosmos/base/tendermint/v1beta1/blocks/latest`;
+    return await this.req.get<GetLatestBlockResponseSDKType>(endpoint);
+  }
+  /* GetBlockByHeight queries block for given height. */
+  async getBlockByHeight(params: GetBlockByHeightRequest): Promise<GetBlockByHeightResponseSDKType> {
+    const endpoint = `cosmos/base/tendermint/v1beta1/blocks/${params.height}`;
+    return await this.req.get<GetBlockByHeightResponseSDKType>(endpoint);
+  }
+  /* GetLatestValidatorSet queries latest validator-set. */
+  async getLatestValidatorSet(params: GetLatestValidatorSetRequest = {
+    pagination: undefined
+  }): Promise<GetLatestValidatorSetResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/base/tendermint/v1beta1/validatorsets/latest`;
+    return await this.req.get<GetLatestValidatorSetResponseSDKType>(endpoint, options);
+  }
+  /* GetValidatorSetByHeight queries validator-set at a given height. */
+  async getValidatorSetByHeight(params: GetValidatorSetByHeightRequest): Promise<GetValidatorSetByHeightResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/base/tendermint/v1beta1/validatorsets/${params.height}`;
+    return await this.req.get<GetValidatorSetByHeightResponseSDKType>(endpoint, options);
+  }
+}

src/codegen/cosmos/base/tendermint/v1beta1/query.rpc.Service.ts

@@ -0,0 +1,87 @@
+import { Rpc } from "../../../../helpers";
+import { BinaryReader } from "../../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { GetNodeInfoRequest, GetNodeInfoResponse, GetSyncingRequest, GetSyncingResponse, GetLatestBlockRequest, GetLatestBlockResponse, GetBlockByHeightRequest, GetBlockByHeightResponse, GetLatestValidatorSetRequest, GetLatestValidatorSetResponse, GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponse } from "./query";
+/** Service defines the gRPC querier service for tendermint queries. */
+export interface Service {
+  /** GetNodeInfo queries the current node info. */
+  getNodeInfo(request?: GetNodeInfoRequest): Promise<GetNodeInfoResponse>;
+  /** GetSyncing queries node syncing. */
+  getSyncing(request?: GetSyncingRequest): Promise<GetSyncingResponse>;
+  /** GetLatestBlock returns the latest block. */
+  getLatestBlock(request?: GetLatestBlockRequest): Promise<GetLatestBlockResponse>;
+  /** GetBlockByHeight queries block for given height. */
+  getBlockByHeight(request: GetBlockByHeightRequest): Promise<GetBlockByHeightResponse>;
+  /** GetLatestValidatorSet queries latest validator-set. */
+  getLatestValidatorSet(request?: GetLatestValidatorSetRequest): Promise<GetLatestValidatorSetResponse>;
+  /** GetValidatorSetByHeight queries validator-set at a given height. */
+  getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise<GetValidatorSetByHeightResponse>;
+}
+export class ServiceClientImpl implements Service {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.getNodeInfo = this.getNodeInfo.bind(this);
+    this.getSyncing = this.getSyncing.bind(this);
+    this.getLatestBlock = this.getLatestBlock.bind(this);
+    this.getBlockByHeight = this.getBlockByHeight.bind(this);
+    this.getLatestValidatorSet = this.getLatestValidatorSet.bind(this);
+    this.getValidatorSetByHeight = this.getValidatorSetByHeight.bind(this);
+  }
+  getNodeInfo(request: GetNodeInfoRequest = {}): Promise<GetNodeInfoResponse> {
+    const data = GetNodeInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetNodeInfo", data);
+    return promise.then(data => GetNodeInfoResponse.decode(new BinaryReader(data)));
+  }
+  getSyncing(request: GetSyncingRequest = {}): Promise<GetSyncingResponse> {
+    const data = GetSyncingRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetSyncing", data);
+    return promise.then(data => GetSyncingResponse.decode(new BinaryReader(data)));
+  }
+  getLatestBlock(request: GetLatestBlockRequest = {}): Promise<GetLatestBlockResponse> {
+    const data = GetLatestBlockRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestBlock", data);
+    return promise.then(data => GetLatestBlockResponse.decode(new BinaryReader(data)));
+  }
+  getBlockByHeight(request: GetBlockByHeightRequest): Promise<GetBlockByHeightResponse> {
+    const data = GetBlockByHeightRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetBlockByHeight", data);
+    return promise.then(data => GetBlockByHeightResponse.decode(new BinaryReader(data)));
+  }
+  getLatestValidatorSet(request: GetLatestValidatorSetRequest = {
+    pagination: undefined
+  }): Promise<GetLatestValidatorSetResponse> {
+    const data = GetLatestValidatorSetRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestValidatorSet", data);
+    return promise.then(data => GetLatestValidatorSetResponse.decode(new BinaryReader(data)));
+  }
+  getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise<GetValidatorSetByHeightResponse> {
+    const data = GetValidatorSetByHeightRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetValidatorSetByHeight", data);
+    return promise.then(data => GetValidatorSetByHeightResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new ServiceClientImpl(rpc);
+  return {
+    getNodeInfo(request?: GetNodeInfoRequest): Promise<GetNodeInfoResponse> {
+      return queryService.getNodeInfo(request);
+    },
+    getSyncing(request?: GetSyncingRequest): Promise<GetSyncingResponse> {
+      return queryService.getSyncing(request);
+    },
+    getLatestBlock(request?: GetLatestBlockRequest): Promise<GetLatestBlockResponse> {
+      return queryService.getLatestBlock(request);
+    },
+    getBlockByHeight(request: GetBlockByHeightRequest): Promise<GetBlockByHeightResponse> {
+      return queryService.getBlockByHeight(request);
+    },
+    getLatestValidatorSet(request?: GetLatestValidatorSetRequest): Promise<GetLatestValidatorSetResponse> {
+      return queryService.getLatestValidatorSet(request);
+    },
+    getValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise<GetValidatorSetByHeightResponse> {
+      return queryService.getValidatorSetByHeight(request);
+    }
+  };
+};

src/codegen/cosmos/base/v1beta1/coin.ts

@@ -0,0 +1,417 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * Coin defines a token with a denomination and an amount.
+ * 
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface Coin {
+  denom: string;
+  amount: string;
+}
+export interface CoinProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.Coin";
+  value: Uint8Array;
+}
+/**
+ * Coin defines a token with a denomination and an amount.
+ * 
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface CoinAmino {
+  denom?: string;
+  amount?: string;
+}
+export interface CoinAminoMsg {
+  type: "cosmos-sdk/Coin";
+  value: CoinAmino;
+}
+/**
+ * Coin defines a token with a denomination and an amount.
+ * 
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface CoinSDKType {
+  denom: string;
+  amount: string;
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ * 
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoin {
+  denom: string;
+  amount: string;
+}
+export interface DecCoinProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.DecCoin";
+  value: Uint8Array;
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ * 
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoinAmino {
+  denom?: string;
+  amount?: string;
+}
+export interface DecCoinAminoMsg {
+  type: "cosmos-sdk/DecCoin";
+  value: DecCoinAmino;
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ * 
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoinSDKType {
+  denom: string;
+  amount: string;
+}
+/** IntProto defines a Protobuf wrapper around an Int object. */
+export interface IntProto {
+  int: string;
+}
+export interface IntProtoProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.IntProto";
+  value: Uint8Array;
+}
+/** IntProto defines a Protobuf wrapper around an Int object. */
+export interface IntProtoAmino {
+  int?: string;
+}
+export interface IntProtoAminoMsg {
+  type: "cosmos-sdk/IntProto";
+  value: IntProtoAmino;
+}
+/** IntProto defines a Protobuf wrapper around an Int object. */
+export interface IntProtoSDKType {
+  int: string;
+}
+/** DecProto defines a Protobuf wrapper around a Dec object. */
+export interface DecProto {
+  dec: string;
+}
+export interface DecProtoProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.DecProto";
+  value: Uint8Array;
+}
+/** DecProto defines a Protobuf wrapper around a Dec object. */
+export interface DecProtoAmino {
+  dec?: string;
+}
+export interface DecProtoAminoMsg {
+  type: "cosmos-sdk/DecProto";
+  value: DecProtoAmino;
+}
+/** DecProto defines a Protobuf wrapper around a Dec object. */
+export interface DecProtoSDKType {
+  dec: string;
+}
+function createBaseCoin(): Coin {
+  return {
+    denom: "",
+    amount: ""
+  };
+}
+export const Coin = {
+  typeUrl: "/cosmos.base.v1beta1.Coin",
+  encode(message: Coin, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Coin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.amount = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Coin>): Coin {
+    const message = createBaseCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+  fromAmino(object: CoinAmino): Coin {
+    const message = createBaseCoin();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.amount !== undefined && object.amount !== null) {
+      message.amount = object.amount;
+    }
+    return message;
+  },
+  toAmino(message: Coin): CoinAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.amount = message.amount === "" ? undefined : message.amount;
+    return obj;
+  },
+  fromAminoMsg(object: CoinAminoMsg): Coin {
+    return Coin.fromAmino(object.value);
+  },
+  toAminoMsg(message: Coin): CoinAminoMsg {
+    return {
+      type: "cosmos-sdk/Coin",
+      value: Coin.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CoinProtoMsg): Coin {
+    return Coin.decode(message.value);
+  },
+  toProto(message: Coin): Uint8Array {
+    return Coin.encode(message).finish();
+  },
+  toProtoMsg(message: Coin): CoinProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.Coin",
+      value: Coin.encode(message).finish()
+    };
+  }
+};
+function createBaseDecCoin(): DecCoin {
+  return {
+    denom: "",
+    amount: ""
+  };
+}
+export const DecCoin = {
+  typeUrl: "/cosmos.base.v1beta1.DecCoin",
+  encode(message: DecCoin, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DecCoin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.amount = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<DecCoin>): DecCoin {
+    const message = createBaseDecCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+  fromAmino(object: DecCoinAmino): DecCoin {
+    const message = createBaseDecCoin();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.amount !== undefined && object.amount !== null) {
+      message.amount = object.amount;
+    }
+    return message;
+  },
+  toAmino(message: DecCoin): DecCoinAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.amount = message.amount === "" ? undefined : message.amount;
+    return obj;
+  },
+  fromAminoMsg(object: DecCoinAminoMsg): DecCoin {
+    return DecCoin.fromAmino(object.value);
+  },
+  toAminoMsg(message: DecCoin): DecCoinAminoMsg {
+    return {
+      type: "cosmos-sdk/DecCoin",
+      value: DecCoin.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DecCoinProtoMsg): DecCoin {
+    return DecCoin.decode(message.value);
+  },
+  toProto(message: DecCoin): Uint8Array {
+    return DecCoin.encode(message).finish();
+  },
+  toProtoMsg(message: DecCoin): DecCoinProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.DecCoin",
+      value: DecCoin.encode(message).finish()
+    };
+  }
+};
+function createBaseIntProto(): IntProto {
+  return {
+    int: ""
+  };
+}
+export const IntProto = {
+  typeUrl: "/cosmos.base.v1beta1.IntProto",
+  encode(message: IntProto, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.int !== "") {
+      writer.uint32(10).string(message.int);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): IntProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIntProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.int = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<IntProto>): IntProto {
+    const message = createBaseIntProto();
+    message.int = object.int ?? "";
+    return message;
+  },
+  fromAmino(object: IntProtoAmino): IntProto {
+    const message = createBaseIntProto();
+    if (object.int !== undefined && object.int !== null) {
+      message.int = object.int;
+    }
+    return message;
+  },
+  toAmino(message: IntProto): IntProtoAmino {
+    const obj: any = {};
+    obj.int = message.int === "" ? undefined : message.int;
+    return obj;
+  },
+  fromAminoMsg(object: IntProtoAminoMsg): IntProto {
+    return IntProto.fromAmino(object.value);
+  },
+  toAminoMsg(message: IntProto): IntProtoAminoMsg {
+    return {
+      type: "cosmos-sdk/IntProto",
+      value: IntProto.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: IntProtoProtoMsg): IntProto {
+    return IntProto.decode(message.value);
+  },
+  toProto(message: IntProto): Uint8Array {
+    return IntProto.encode(message).finish();
+  },
+  toProtoMsg(message: IntProto): IntProtoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.IntProto",
+      value: IntProto.encode(message).finish()
+    };
+  }
+};
+function createBaseDecProto(): DecProto {
+  return {
+    dec: ""
+  };
+}
+export const DecProto = {
+  typeUrl: "/cosmos.base.v1beta1.DecProto",
+  encode(message: DecProto, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.dec !== "") {
+      writer.uint32(10).string(message.dec);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DecProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.dec = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<DecProto>): DecProto {
+    const message = createBaseDecProto();
+    message.dec = object.dec ?? "";
+    return message;
+  },
+  fromAmino(object: DecProtoAmino): DecProto {
+    const message = createBaseDecProto();
+    if (object.dec !== undefined && object.dec !== null) {
+      message.dec = object.dec;
+    }
+    return message;
+  },
+  toAmino(message: DecProto): DecProtoAmino {
+    const obj: any = {};
+    obj.dec = message.dec === "" ? undefined : message.dec;
+    return obj;
+  },
+  fromAminoMsg(object: DecProtoAminoMsg): DecProto {
+    return DecProto.fromAmino(object.value);
+  },
+  toAminoMsg(message: DecProto): DecProtoAminoMsg {
+    return {
+      type: "cosmos-sdk/DecProto",
+      value: DecProto.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DecProtoProtoMsg): DecProto {
+    return DecProto.decode(message.value);
+  },
+  toProto(message: DecProto): Uint8Array {
+    return DecProto.encode(message).finish();
+  },
+  toProtoMsg(message: DecProto): DecProtoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.DecProto",
+      value: DecProto.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/bundle.ts

@@ -0,0 +1,390 @@
+import * as _3 from "./auth/v1beta1/auth";
+import * as _4 from "./auth/v1beta1/genesis";
+import * as _5 from "./auth/v1beta1/query";
+import * as _6 from "./authz/v1beta1/authz";
+import * as _7 from "./authz/v1beta1/event";
+import * as _8 from "./authz/v1beta1/genesis";
+import * as _9 from "./authz/v1beta1/query";
+import * as _10 from "./authz/v1beta1/tx";
+import * as _11 from "./bank/v1beta1/authz";
+import * as _12 from "./bank/v1beta1/bank";
+import * as _13 from "./bank/v1beta1/genesis";
+import * as _14 from "./bank/v1beta1/query";
+import * as _15 from "./bank/v1beta1/tx";
+import * as _16 from "./base/abci/v1beta1/abci";
+import * as _17 from "./base/kv/v1beta1/kv";
+import * as _18 from "./base/node/v1beta1/query";
+import * as _19 from "./base/query/v1beta1/pagination";
+import * as _20 from "./base/reflection/v1beta1/reflection";
+import * as _21 from "./base/reflection/v2alpha1/reflection";
+import * as _22 from "./base/snapshots/v1beta1/snapshot";
+import * as _23 from "./base/store/v1beta1/commit_info";
+import * as _24 from "./base/store/v1beta1/listening";
+import * as _25 from "./base/tendermint/v1beta1/query";
+import * as _26 from "./base/v1beta1/coin";
+import * as _27 from "./capability/v1beta1/capability";
+import * as _28 from "./capability/v1beta1/genesis";
+import * as _29 from "./crisis/v1beta1/genesis";
+import * as _30 from "./crisis/v1beta1/tx";
+import * as _31 from "./crypto/ed25519/keys";
+import * as _32 from "./crypto/multisig/keys";
+import * as _33 from "./crypto/secp256k1/keys";
+import * as _34 from "./crypto/secp256r1/keys";
+import * as _35 from "./distribution/v1beta1/distribution";
+import * as _36 from "./distribution/v1beta1/genesis";
+import * as _37 from "./distribution/v1beta1/query";
+import * as _38 from "./distribution/v1beta1/tx";
+import * as _39 from "./evidence/v1beta1/evidence";
+import * as _40 from "./evidence/v1beta1/genesis";
+import * as _41 from "./evidence/v1beta1/query";
+import * as _42 from "./evidence/v1beta1/tx";
+import * as _43 from "./feegrant/v1beta1/feegrant";
+import * as _44 from "./feegrant/v1beta1/genesis";
+import * as _45 from "./feegrant/v1beta1/query";
+import * as _46 from "./feegrant/v1beta1/tx";
+import * as _47 from "./genutil/v1beta1/genesis";
+import * as _48 from "./gov/v1beta1/genesis";
+import * as _49 from "./gov/v1beta1/gov";
+import * as _50 from "./gov/v1beta1/query";
+import * as _51 from "./gov/v1beta1/tx";
+import * as _52 from "./mint/v1beta1/genesis";
+import * as _53 from "./mint/v1beta1/mint";
+import * as _54 from "./mint/v1beta1/query";
+import * as _55 from "./params/v1beta1/params";
+import * as _56 from "./params/v1beta1/query";
+import * as _57 from "./slashing/v1beta1/genesis";
+import * as _58 from "./slashing/v1beta1/query";
+import * as _59 from "./slashing/v1beta1/slashing";
+import * as _60 from "./slashing/v1beta1/tx";
+import * as _61 from "./staking/v1beta1/authz";
+import * as _62 from "./staking/v1beta1/genesis";
+import * as _63 from "./staking/v1beta1/query";
+import * as _64 from "./staking/v1beta1/staking";
+import * as _65 from "./staking/v1beta1/tx";
+import * as _66 from "./tx/signing/v1beta1/signing";
+import * as _67 from "./tx/v1beta1/service";
+import * as _68 from "./tx/v1beta1/tx";
+import * as _69 from "./upgrade/v1beta1/query";
+import * as _70 from "./upgrade/v1beta1/upgrade";
+import * as _71 from "./vesting/v1beta1/tx";
+import * as _72 from "./vesting/v1beta1/vesting";
+import * as _137 from "./authz/v1beta1/tx.amino";
+import * as _138 from "./bank/v1beta1/tx.amino";
+import * as _139 from "./crisis/v1beta1/tx.amino";
+import * as _140 from "./distribution/v1beta1/tx.amino";
+import * as _141 from "./evidence/v1beta1/tx.amino";
+import * as _142 from "./feegrant/v1beta1/tx.amino";
+import * as _143 from "./gov/v1beta1/tx.amino";
+import * as _144 from "./slashing/v1beta1/tx.amino";
+import * as _145 from "./staking/v1beta1/tx.amino";
+import * as _146 from "./vesting/v1beta1/tx.amino";
+import * as _147 from "./authz/v1beta1/tx.registry";
+import * as _148 from "./bank/v1beta1/tx.registry";
+import * as _149 from "./crisis/v1beta1/tx.registry";
+import * as _150 from "./distribution/v1beta1/tx.registry";
+import * as _151 from "./evidence/v1beta1/tx.registry";
+import * as _152 from "./feegrant/v1beta1/tx.registry";
+import * as _153 from "./gov/v1beta1/tx.registry";
+import * as _154 from "./slashing/v1beta1/tx.registry";
+import * as _155 from "./staking/v1beta1/tx.registry";
+import * as _156 from "./vesting/v1beta1/tx.registry";
+import * as _157 from "./auth/v1beta1/query.lcd";
+import * as _158 from "./authz/v1beta1/query.lcd";
+import * as _159 from "./bank/v1beta1/query.lcd";
+import * as _160 from "./base/node/v1beta1/query.lcd";
+import * as _161 from "./base/tendermint/v1beta1/query.lcd";
+import * as _162 from "./distribution/v1beta1/query.lcd";
+import * as _163 from "./evidence/v1beta1/query.lcd";
+import * as _164 from "./feegrant/v1beta1/query.lcd";
+import * as _165 from "./gov/v1beta1/query.lcd";
+import * as _166 from "./mint/v1beta1/query.lcd";
+import * as _167 from "./params/v1beta1/query.lcd";
+import * as _168 from "./slashing/v1beta1/query.lcd";
+import * as _169 from "./staking/v1beta1/query.lcd";
+import * as _170 from "./tx/v1beta1/service.lcd";
+import * as _171 from "./upgrade/v1beta1/query.lcd";
+import * as _172 from "./auth/v1beta1/query.rpc.Query";
+import * as _173 from "./authz/v1beta1/query.rpc.Query";
+import * as _174 from "./bank/v1beta1/query.rpc.Query";
+import * as _175 from "./base/node/v1beta1/query.rpc.Service";
+import * as _176 from "./base/tendermint/v1beta1/query.rpc.Service";
+import * as _177 from "./distribution/v1beta1/query.rpc.Query";
+import * as _178 from "./evidence/v1beta1/query.rpc.Query";
+import * as _179 from "./feegrant/v1beta1/query.rpc.Query";
+import * as _180 from "./gov/v1beta1/query.rpc.Query";
+import * as _181 from "./mint/v1beta1/query.rpc.Query";
+import * as _182 from "./params/v1beta1/query.rpc.Query";
+import * as _183 from "./slashing/v1beta1/query.rpc.Query";
+import * as _184 from "./staking/v1beta1/query.rpc.Query";
+import * as _185 from "./tx/v1beta1/service.rpc.Service";
+import * as _186 from "./upgrade/v1beta1/query.rpc.Query";
+import * as _187 from "./authz/v1beta1/tx.rpc.msg";
+import * as _188 from "./bank/v1beta1/tx.rpc.msg";
+import * as _189 from "./crisis/v1beta1/tx.rpc.msg";
+import * as _190 from "./distribution/v1beta1/tx.rpc.msg";
+import * as _191 from "./evidence/v1beta1/tx.rpc.msg";
+import * as _192 from "./feegrant/v1beta1/tx.rpc.msg";
+import * as _193 from "./gov/v1beta1/tx.rpc.msg";
+import * as _194 from "./slashing/v1beta1/tx.rpc.msg";
+import * as _195 from "./staking/v1beta1/tx.rpc.msg";
+import * as _196 from "./vesting/v1beta1/tx.rpc.msg";
+import * as _231 from "./lcd";
+import * as _232 from "./rpc.query";
+import * as _233 from "./rpc.tx";
+export namespace cosmos {
+  export namespace auth {
+    export const v1beta1 = {
+      ..._3,
+      ..._4,
+      ..._5,
+      ..._157,
+      ..._172
+    };
+  }
+  export namespace authz {
+    export const v1beta1 = {
+      ..._6,
+      ..._7,
+      ..._8,
+      ..._9,
+      ..._10,
+      ..._137,
+      ..._147,
+      ..._158,
+      ..._173,
+      ..._187
+    };
+  }
+  export namespace bank {
+    export const v1beta1 = {
+      ..._11,
+      ..._12,
+      ..._13,
+      ..._14,
+      ..._15,
+      ..._138,
+      ..._148,
+      ..._159,
+      ..._174,
+      ..._188
+    };
+  }
+  export namespace base {
+    export namespace abci {
+      export const v1beta1 = {
+        ..._16
+      };
+    }
+    export namespace kv {
+      export const v1beta1 = {
+        ..._17
+      };
+    }
+    export namespace node {
+      export const v1beta1 = {
+        ..._18,
+        ..._160,
+        ..._175
+      };
+    }
+    export namespace query {
+      export const v1beta1 = {
+        ..._19
+      };
+    }
+    export namespace reflection {
+      export const v1beta1 = {
+        ..._20
+      };
+      export const v2alpha1 = {
+        ..._21
+      };
+    }
+    export namespace snapshots {
+      export const v1beta1 = {
+        ..._22
+      };
+    }
+    export namespace store {
+      export const v1beta1 = {
+        ..._23,
+        ..._24
+      };
+    }
+    export namespace tendermint {
+      export const v1beta1 = {
+        ..._25,
+        ..._161,
+        ..._176
+      };
+    }
+    export const v1beta1 = {
+      ..._26
+    };
+  }
+  export namespace capability {
+    export const v1beta1 = {
+      ..._27,
+      ..._28
+    };
+  }
+  export namespace crisis {
+    export const v1beta1 = {
+      ..._29,
+      ..._30,
+      ..._139,
+      ..._149,
+      ..._189
+    };
+  }
+  export namespace crypto {
+    export const ed25519 = {
+      ..._31
+    };
+    export const multisig = {
+      ..._32
+    };
+    export const secp256k1 = {
+      ..._33
+    };
+    export const secp256r1 = {
+      ..._34
+    };
+  }
+  export namespace distribution {
+    export const v1beta1 = {
+      ..._35,
+      ..._36,
+      ..._37,
+      ..._38,
+      ..._140,
+      ..._150,
+      ..._162,
+      ..._177,
+      ..._190
+    };
+  }
+  export namespace evidence {
+    export const v1beta1 = {
+      ..._39,
+      ..._40,
+      ..._41,
+      ..._42,
+      ..._141,
+      ..._151,
+      ..._163,
+      ..._178,
+      ..._191
+    };
+  }
+  export namespace feegrant {
+    export const v1beta1 = {
+      ..._43,
+      ..._44,
+      ..._45,
+      ..._46,
+      ..._142,
+      ..._152,
+      ..._164,
+      ..._179,
+      ..._192
+    };
+  }
+  export namespace genutil {
+    export const v1beta1 = {
+      ..._47
+    };
+  }
+  export namespace gov {
+    export const v1beta1 = {
+      ..._48,
+      ..._49,
+      ..._50,
+      ..._51,
+      ..._143,
+      ..._153,
+      ..._165,
+      ..._180,
+      ..._193
+    };
+  }
+  export namespace mint {
+    export const v1beta1 = {
+      ..._52,
+      ..._53,
+      ..._54,
+      ..._166,
+      ..._181
+    };
+  }
+  export namespace params {
+    export const v1beta1 = {
+      ..._55,
+      ..._56,
+      ..._167,
+      ..._182
+    };
+  }
+  export namespace slashing {
+    export const v1beta1 = {
+      ..._57,
+      ..._58,
+      ..._59,
+      ..._60,
+      ..._144,
+      ..._154,
+      ..._168,
+      ..._183,
+      ..._194
+    };
+  }
+  export namespace staking {
+    export const v1beta1 = {
+      ..._61,
+      ..._62,
+      ..._63,
+      ..._64,
+      ..._65,
+      ..._145,
+      ..._155,
+      ..._169,
+      ..._184,
+      ..._195
+    };
+  }
+  export namespace tx {
+    export namespace signing {
+      export const v1beta1 = {
+        ..._66
+      };
+    }
+    export const v1beta1 = {
+      ..._67,
+      ..._68,
+      ..._170,
+      ..._185
+    };
+  }
+  export namespace upgrade {
+    export const v1beta1 = {
+      ..._69,
+      ..._70,
+      ..._171,
+      ..._186
+    };
+  }
+  export namespace vesting {
+    export const v1beta1 = {
+      ..._71,
+      ..._72,
+      ..._146,
+      ..._156,
+      ..._196
+    };
+  }
+  export const ClientFactory = {
+    ..._231,
+    ..._232,
+    ..._233
+  };
+}

src/codegen/cosmos/capability/v1beta1/capability.ts

@@ -0,0 +1,312 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface Capability {
+  index: bigint;
+}
+export interface CapabilityProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.Capability";
+  value: Uint8Array;
+}
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface CapabilityAmino {
+  index?: string;
+}
+export interface CapabilityAminoMsg {
+  type: "cosmos-sdk/Capability";
+  value: CapabilityAmino;
+}
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface CapabilitySDKType {
+  index: bigint;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface Owner {
+  module: string;
+  name: string;
+}
+export interface OwnerProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.Owner";
+  value: Uint8Array;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface OwnerAmino {
+  module?: string;
+  name?: string;
+}
+export interface OwnerAminoMsg {
+  type: "cosmos-sdk/Owner";
+  value: OwnerAmino;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface OwnerSDKType {
+  module: string;
+  name: string;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwners {
+  owners: Owner[];
+}
+export interface CapabilityOwnersProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners";
+  value: Uint8Array;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwnersAmino {
+  owners?: OwnerAmino[];
+}
+export interface CapabilityOwnersAminoMsg {
+  type: "cosmos-sdk/CapabilityOwners";
+  value: CapabilityOwnersAmino;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwnersSDKType {
+  owners: OwnerSDKType[];
+}
+function createBaseCapability(): Capability {
+  return {
+    index: BigInt(0)
+  };
+}
+export const Capability = {
+  typeUrl: "/cosmos.capability.v1beta1.Capability",
+  encode(message: Capability, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Capability {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapability();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Capability>): Capability {
+    const message = createBaseCapability();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: CapabilityAmino): Capability {
+    const message = createBaseCapability();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    return message;
+  },
+  toAmino(message: Capability): CapabilityAmino {
+    const obj: any = {};
+    obj.index = message.index !== BigInt(0) ? message.index.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: CapabilityAminoMsg): Capability {
+    return Capability.fromAmino(object.value);
+  },
+  toAminoMsg(message: Capability): CapabilityAminoMsg {
+    return {
+      type: "cosmos-sdk/Capability",
+      value: Capability.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CapabilityProtoMsg): Capability {
+    return Capability.decode(message.value);
+  },
+  toProto(message: Capability): Uint8Array {
+    return Capability.encode(message).finish();
+  },
+  toProtoMsg(message: Capability): CapabilityProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.Capability",
+      value: Capability.encode(message).finish()
+    };
+  }
+};
+function createBaseOwner(): Owner {
+  return {
+    module: "",
+    name: ""
+  };
+}
+export const Owner = {
+  typeUrl: "/cosmos.capability.v1beta1.Owner",
+  encode(message: Owner, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.module !== "") {
+      writer.uint32(10).string(message.module);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Owner {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOwner();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.module = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Owner>): Owner {
+    const message = createBaseOwner();
+    message.module = object.module ?? "";
+    message.name = object.name ?? "";
+    return message;
+  },
+  fromAmino(object: OwnerAmino): Owner {
+    const message = createBaseOwner();
+    if (object.module !== undefined && object.module !== null) {
+      message.module = object.module;
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    return message;
+  },
+  toAmino(message: Owner): OwnerAmino {
+    const obj: any = {};
+    obj.module = message.module === "" ? undefined : message.module;
+    obj.name = message.name === "" ? undefined : message.name;
+    return obj;
+  },
+  fromAminoMsg(object: OwnerAminoMsg): Owner {
+    return Owner.fromAmino(object.value);
+  },
+  toAminoMsg(message: Owner): OwnerAminoMsg {
+    return {
+      type: "cosmos-sdk/Owner",
+      value: Owner.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: OwnerProtoMsg): Owner {
+    return Owner.decode(message.value);
+  },
+  toProto(message: Owner): Uint8Array {
+    return Owner.encode(message).finish();
+  },
+  toProtoMsg(message: Owner): OwnerProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.Owner",
+      value: Owner.encode(message).finish()
+    };
+  }
+};
+function createBaseCapabilityOwners(): CapabilityOwners {
+  return {
+    owners: []
+  };
+}
+export const CapabilityOwners = {
+  typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners",
+  encode(message: CapabilityOwners, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.owners) {
+      Owner.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CapabilityOwners {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapabilityOwners();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.owners.push(Owner.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CapabilityOwners>): CapabilityOwners {
+    const message = createBaseCapabilityOwners();
+    message.owners = object.owners?.map(e => Owner.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: CapabilityOwnersAmino): CapabilityOwners {
+    const message = createBaseCapabilityOwners();
+    message.owners = object.owners?.map(e => Owner.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: CapabilityOwners): CapabilityOwnersAmino {
+    const obj: any = {};
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? Owner.toAmino(e) : undefined);
+    } else {
+      obj.owners = message.owners;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: CapabilityOwnersAminoMsg): CapabilityOwners {
+    return CapabilityOwners.fromAmino(object.value);
+  },
+  toAminoMsg(message: CapabilityOwners): CapabilityOwnersAminoMsg {
+    return {
+      type: "cosmos-sdk/CapabilityOwners",
+      value: CapabilityOwners.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CapabilityOwnersProtoMsg): CapabilityOwners {
+    return CapabilityOwners.decode(message.value);
+  },
+  toProto(message: CapabilityOwners): Uint8Array {
+    return CapabilityOwners.encode(message).finish();
+  },
+  toProtoMsg(message: CapabilityOwners): CapabilityOwnersProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners",
+      value: CapabilityOwners.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/capability/v1beta1/genesis.ts

@@ -0,0 +1,226 @@
+import { CapabilityOwners, CapabilityOwnersAmino, CapabilityOwnersSDKType } from "./capability";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwners {
+  /** index is the index of the capability owner. */
+  index: bigint;
+  /** index_owners are the owners at the given index. */
+  indexOwners: CapabilityOwners;
+}
+export interface GenesisOwnersProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisOwners";
+  value: Uint8Array;
+}
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwnersAmino {
+  /** index is the index of the capability owner. */
+  index?: string;
+  /** index_owners are the owners at the given index. */
+  index_owners?: CapabilityOwnersAmino;
+}
+export interface GenesisOwnersAminoMsg {
+  type: "cosmos-sdk/GenesisOwners";
+  value: GenesisOwnersAmino;
+}
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwnersSDKType {
+  index: bigint;
+  index_owners: CapabilityOwnersSDKType;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisState {
+  /** index is the capability global index. */
+  index: bigint;
+  /**
+   * owners represents a map from index to owners of the capability index
+   * index key is string to allow amino marshalling.
+   */
+  owners: GenesisOwners[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisStateAmino {
+  /** index is the capability global index. */
+  index?: string;
+  /**
+   * owners represents a map from index to owners of the capability index
+   * index key is string to allow amino marshalling.
+   */
+  owners?: GenesisOwnersAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisStateSDKType {
+  index: bigint;
+  owners: GenesisOwnersSDKType[];
+}
+function createBaseGenesisOwners(): GenesisOwners {
+  return {
+    index: BigInt(0),
+    indexOwners: CapabilityOwners.fromPartial({})
+  };
+}
+export const GenesisOwners = {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisOwners",
+  encode(message: GenesisOwners, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    if (message.indexOwners !== undefined) {
+      CapabilityOwners.encode(message.indexOwners, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisOwners {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisOwners();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+        case 2:
+          message.indexOwners = CapabilityOwners.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisOwners>): GenesisOwners {
+    const message = createBaseGenesisOwners();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    message.indexOwners = object.indexOwners !== undefined && object.indexOwners !== null ? CapabilityOwners.fromPartial(object.indexOwners) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisOwnersAmino): GenesisOwners {
+    const message = createBaseGenesisOwners();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    if (object.index_owners !== undefined && object.index_owners !== null) {
+      message.indexOwners = CapabilityOwners.fromAmino(object.index_owners);
+    }
+    return message;
+  },
+  toAmino(message: GenesisOwners): GenesisOwnersAmino {
+    const obj: any = {};
+    obj.index = message.index !== BigInt(0) ? message.index.toString() : undefined;
+    obj.index_owners = message.indexOwners ? CapabilityOwners.toAmino(message.indexOwners) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisOwnersAminoMsg): GenesisOwners {
+    return GenesisOwners.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisOwners): GenesisOwnersAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisOwners",
+      value: GenesisOwners.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisOwnersProtoMsg): GenesisOwners {
+    return GenesisOwners.decode(message.value);
+  },
+  toProto(message: GenesisOwners): Uint8Array {
+    return GenesisOwners.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisOwners): GenesisOwnersProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.GenesisOwners",
+      value: GenesisOwners.encode(message).finish()
+    };
+  }
+};
+function createBaseGenesisState(): GenesisState {
+  return {
+    index: BigInt(0),
+    owners: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    for (const v of message.owners) {
+      GenesisOwners.encode(v!, writer.uint32(18).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.index = reader.uint64();
+          break;
+        case 2:
+          message.owners.push(GenesisOwners.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    message.owners = object.owners?.map(e => GenesisOwners.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    message.owners = object.owners?.map(e => GenesisOwners.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.index = message.index !== BigInt(0) ? message.index.toString() : undefined;
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? GenesisOwners.toAmino(e) : undefined);
+    } else {
+      obj.owners = message.owners;
+    }
+    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.capability.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/client.ts

@@ -0,0 +1,66 @@
+import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import * as cosmosAuthzV1beta1TxRegistry from "./authz/v1beta1/tx.registry";
+import * as cosmosBankV1beta1TxRegistry from "./bank/v1beta1/tx.registry";
+import * as cosmosCrisisV1beta1TxRegistry from "./crisis/v1beta1/tx.registry";
+import * as cosmosDistributionV1beta1TxRegistry from "./distribution/v1beta1/tx.registry";
+import * as cosmosEvidenceV1beta1TxRegistry from "./evidence/v1beta1/tx.registry";
+import * as cosmosFeegrantV1beta1TxRegistry from "./feegrant/v1beta1/tx.registry";
+import * as cosmosGovV1beta1TxRegistry from "./gov/v1beta1/tx.registry";
+import * as cosmosSlashingV1beta1TxRegistry from "./slashing/v1beta1/tx.registry";
+import * as cosmosStakingV1beta1TxRegistry from "./staking/v1beta1/tx.registry";
+import * as cosmosVestingV1beta1TxRegistry from "./vesting/v1beta1/tx.registry";
+import * as cosmosAuthzV1beta1TxAmino from "./authz/v1beta1/tx.amino";
+import * as cosmosBankV1beta1TxAmino from "./bank/v1beta1/tx.amino";
+import * as cosmosCrisisV1beta1TxAmino from "./crisis/v1beta1/tx.amino";
+import * as cosmosDistributionV1beta1TxAmino from "./distribution/v1beta1/tx.amino";
+import * as cosmosEvidenceV1beta1TxAmino from "./evidence/v1beta1/tx.amino";
+import * as cosmosFeegrantV1beta1TxAmino from "./feegrant/v1beta1/tx.amino";
+import * as cosmosGovV1beta1TxAmino from "./gov/v1beta1/tx.amino";
+import * as cosmosSlashingV1beta1TxAmino from "./slashing/v1beta1/tx.amino";
+import * as cosmosStakingV1beta1TxAmino from "./staking/v1beta1/tx.amino";
+import * as cosmosVestingV1beta1TxAmino from "./vesting/v1beta1/tx.amino";
+export const cosmosAminoConverters = {
+  ...cosmosAuthzV1beta1TxAmino.AminoConverter,
+  ...cosmosBankV1beta1TxAmino.AminoConverter,
+  ...cosmosCrisisV1beta1TxAmino.AminoConverter,
+  ...cosmosDistributionV1beta1TxAmino.AminoConverter,
+  ...cosmosEvidenceV1beta1TxAmino.AminoConverter,
+  ...cosmosFeegrantV1beta1TxAmino.AminoConverter,
+  ...cosmosGovV1beta1TxAmino.AminoConverter,
+  ...cosmosSlashingV1beta1TxAmino.AminoConverter,
+  ...cosmosStakingV1beta1TxAmino.AminoConverter,
+  ...cosmosVestingV1beta1TxAmino.AminoConverter
+};
+export const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmosAuthzV1beta1TxRegistry.registry, ...cosmosBankV1beta1TxRegistry.registry, ...cosmosCrisisV1beta1TxRegistry.registry, ...cosmosDistributionV1beta1TxRegistry.registry, ...cosmosEvidenceV1beta1TxRegistry.registry, ...cosmosFeegrantV1beta1TxRegistry.registry, ...cosmosGovV1beta1TxRegistry.registry, ...cosmosSlashingV1beta1TxRegistry.registry, ...cosmosStakingV1beta1TxRegistry.registry, ...cosmosVestingV1beta1TxRegistry.registry];
+export const getSigningCosmosClientOptions = (): {
+  registry: Registry;
+  aminoTypes: AminoTypes;
+} => {
+  const registry = new Registry([...cosmosProtoRegistry]);
+  const aminoTypes = new AminoTypes({
+    ...cosmosAminoConverters
+  });
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningCosmosClient = async ({
+  rpcEndpoint,
+  signer
+}: {
+  rpcEndpoint: string | HttpEndpoint;
+  signer: OfflineSigner;
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningCosmosClientOptions();
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry: (registry as any),
+    aminoTypes
+  });
+  return client;
+};

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

@@ -0,0 +1,99 @@
+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. */
+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) : undefined;
+    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()
+    };
+  }
+};

src/codegen/cosmos/crisis/v1beta1/tx.amino.ts

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

src/codegen/cosmos/crisis/v1beta1/tx.registry.ts

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

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

@@ -0,0 +1,20 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgVerifyInvariant, MsgVerifyInvariantResponse } from "./tx";
+/** Msg defines the bank Msg service. */
+export interface Msg {
+  /** VerifyInvariant defines a method to verify a particular invariance. */
+  verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.verifyInvariant = this.verifyInvariant.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 BinaryReader(data)));
+  }
+}

src/codegen/cosmos/crisis/v1beta1/tx.ts

@@ -0,0 +1,190 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+export interface MsgVerifyInvariant {
+  sender: string;
+  invariantModuleName: string;
+  invariantRoute: string;
+}
+export interface MsgVerifyInvariantProtoMsg {
+  typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant";
+  value: Uint8Array;
+}
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+export interface MsgVerifyInvariantAmino {
+  sender?: string;
+  invariant_module_name?: string;
+  invariant_route?: string;
+}
+export interface MsgVerifyInvariantAminoMsg {
+  type: "cosmos-sdk/MsgVerifyInvariant";
+  value: MsgVerifyInvariantAmino;
+}
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+export interface MsgVerifyInvariantSDKType {
+  sender: string;
+  invariant_module_name: string;
+  invariant_route: string;
+}
+/** MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. */
+export interface MsgVerifyInvariantResponse {}
+export interface MsgVerifyInvariantResponseProtoMsg {
+  typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariantResponse";
+  value: Uint8Array;
+}
+/** MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. */
+export interface MsgVerifyInvariantResponseAmino {}
+export interface MsgVerifyInvariantResponseAminoMsg {
+  type: "cosmos-sdk/MsgVerifyInvariantResponse";
+  value: MsgVerifyInvariantResponseAmino;
+}
+/** MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. */
+export interface MsgVerifyInvariantResponseSDKType {}
+function createBaseMsgVerifyInvariant(): MsgVerifyInvariant {
+  return {
+    sender: "",
+    invariantModuleName: "",
+    invariantRoute: ""
+  };
+}
+export const MsgVerifyInvariant = {
+  typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+  encode(message: MsgVerifyInvariant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+    if (message.invariantModuleName !== "") {
+      writer.uint32(18).string(message.invariantModuleName);
+    }
+    if (message.invariantRoute !== "") {
+      writer.uint32(26).string(message.invariantRoute);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVerifyInvariant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVerifyInvariant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+        case 2:
+          message.invariantModuleName = reader.string();
+          break;
+        case 3:
+          message.invariantRoute = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgVerifyInvariant>): MsgVerifyInvariant {
+    const message = createBaseMsgVerifyInvariant();
+    message.sender = object.sender ?? "";
+    message.invariantModuleName = object.invariantModuleName ?? "";
+    message.invariantRoute = object.invariantRoute ?? "";
+    return message;
+  },
+  fromAmino(object: MsgVerifyInvariantAmino): MsgVerifyInvariant {
+    const message = createBaseMsgVerifyInvariant();
+    if (object.sender !== undefined && object.sender !== null) {
+      message.sender = object.sender;
+    }
+    if (object.invariant_module_name !== undefined && object.invariant_module_name !== null) {
+      message.invariantModuleName = object.invariant_module_name;
+    }
+    if (object.invariant_route !== undefined && object.invariant_route !== null) {
+      message.invariantRoute = object.invariant_route;
+    }
+    return message;
+  },
+  toAmino(message: MsgVerifyInvariant): MsgVerifyInvariantAmino {
+    const obj: any = {};
+    obj.sender = message.sender === "" ? undefined : message.sender;
+    obj.invariant_module_name = message.invariantModuleName === "" ? undefined : message.invariantModuleName;
+    obj.invariant_route = message.invariantRoute === "" ? undefined : message.invariantRoute;
+    return obj;
+  },
+  fromAminoMsg(object: MsgVerifyInvariantAminoMsg): MsgVerifyInvariant {
+    return MsgVerifyInvariant.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVerifyInvariant): MsgVerifyInvariantAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVerifyInvariant",
+      value: MsgVerifyInvariant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVerifyInvariantProtoMsg): MsgVerifyInvariant {
+    return MsgVerifyInvariant.decode(message.value);
+  },
+  toProto(message: MsgVerifyInvariant): Uint8Array {
+    return MsgVerifyInvariant.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVerifyInvariant): MsgVerifyInvariantProtoMsg {
+    return {
+      typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+      value: MsgVerifyInvariant.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgVerifyInvariantResponse(): MsgVerifyInvariantResponse {
+  return {};
+}
+export const MsgVerifyInvariantResponse = {
+  typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariantResponse",
+  encode(_: MsgVerifyInvariantResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVerifyInvariantResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVerifyInvariantResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgVerifyInvariantResponse>): MsgVerifyInvariantResponse {
+    const message = createBaseMsgVerifyInvariantResponse();
+    return message;
+  },
+  fromAmino(_: MsgVerifyInvariantResponseAmino): MsgVerifyInvariantResponse {
+    const message = createBaseMsgVerifyInvariantResponse();
+    return message;
+  },
+  toAmino(_: MsgVerifyInvariantResponse): MsgVerifyInvariantResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgVerifyInvariantResponseAminoMsg): MsgVerifyInvariantResponse {
+    return MsgVerifyInvariantResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVerifyInvariantResponse): MsgVerifyInvariantResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVerifyInvariantResponse",
+      value: MsgVerifyInvariantResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVerifyInvariantResponseProtoMsg): MsgVerifyInvariantResponse {
+    return MsgVerifyInvariantResponse.decode(message.value);
+  },
+  toProto(message: MsgVerifyInvariantResponse): Uint8Array {
+    return MsgVerifyInvariantResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVerifyInvariantResponse): MsgVerifyInvariantResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariantResponse",
+      value: MsgVerifyInvariantResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/crypto/ed25519/keys.ts

@@ -0,0 +1,207 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/**
+ * PubKey is an ed25519 public key for handling Tendermint keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use ed25519 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ */
+export interface PubKey {
+  key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.ed25519.PubKey";
+  value: Uint8Array;
+}
+/**
+ * PubKey is an ed25519 public key for handling Tendermint keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use ed25519 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ */
+export interface PubKeyAmino {
+  key?: string;
+}
+export interface PubKeyAminoMsg {
+  type: "cosmos-sdk/PubKey";
+  value: PubKeyAmino;
+}
+/**
+ * PubKey is an ed25519 public key for handling Tendermint keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use ed25519 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ */
+export interface PubKeySDKType {
+  key: Uint8Array;
+}
+/**
+ * Deprecated: PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+export interface PrivKey {
+  key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.ed25519.PrivKey";
+  value: Uint8Array;
+}
+/**
+ * Deprecated: PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+export interface PrivKeyAmino {
+  key?: string;
+}
+export interface PrivKeyAminoMsg {
+  type: "cosmos-sdk/PrivKey";
+  value: PrivKeyAmino;
+}
+/**
+ * Deprecated: PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+export interface PrivKeySDKType {
+  key: Uint8Array;
+}
+function createBasePubKey(): PubKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PubKey = {
+  typeUrl: "/cosmos.crypto.ed25519.PubKey",
+  encode(message: PubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PubKey>): PubKey {
+    const message = createBasePubKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PubKeyAmino): PubKey {
+    const message = createBasePubKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PubKey): PubKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PubKeyAminoMsg): PubKey {
+    return PubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PubKey): PubKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PubKey",
+      value: PubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PubKeyProtoMsg): PubKey {
+    return PubKey.decode(message.value);
+  },
+  toProto(message: PubKey): Uint8Array {
+    return PubKey.encode(message).finish();
+  },
+  toProtoMsg(message: PubKey): PubKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.ed25519.PubKey",
+      value: PubKey.encode(message).finish()
+    };
+  }
+};
+function createBasePrivKey(): PrivKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PrivKey = {
+  typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+  encode(message: PrivKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PrivKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrivKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PrivKey>): PrivKey {
+    const message = createBasePrivKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PrivKeyAmino): PrivKey {
+    const message = createBasePrivKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PrivKey): PrivKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PrivKeyAminoMsg): PrivKey {
+    return PrivKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PrivKey): PrivKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PrivKey",
+      value: PrivKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PrivKeyProtoMsg): PrivKey {
+    return PrivKey.decode(message.value);
+  },
+  toProto(message: PrivKey): Uint8Array {
+    return PrivKey.encode(message).finish();
+  },
+  toProtoMsg(message: PrivKey): PrivKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.ed25519.PrivKey",
+      value: PrivKey.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/crypto/multisig/keys.ts

@@ -0,0 +1,120 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * LegacyAminoPubKey specifies a public key type
+ * which nests multiple public keys and a threshold,
+ * it uses legacy amino address rules.
+ */
+export interface LegacyAminoPubKey {
+  threshold: number;
+  publicKeys: Any[];
+}
+export interface LegacyAminoPubKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey";
+  value: Uint8Array;
+}
+/**
+ * LegacyAminoPubKey specifies a public key type
+ * which nests multiple public keys and a threshold,
+ * it uses legacy amino address rules.
+ */
+export interface LegacyAminoPubKeyAmino {
+  threshold?: number;
+  public_keys?: AnyAmino[];
+}
+export interface LegacyAminoPubKeyAminoMsg {
+  type: "cosmos-sdk/LegacyAminoPubKey";
+  value: LegacyAminoPubKeyAmino;
+}
+/**
+ * LegacyAminoPubKey specifies a public key type
+ * which nests multiple public keys and a threshold,
+ * it uses legacy amino address rules.
+ */
+export interface LegacyAminoPubKeySDKType {
+  threshold: number;
+  public_keys: AnySDKType[];
+}
+function createBaseLegacyAminoPubKey(): LegacyAminoPubKey {
+  return {
+    threshold: 0,
+    publicKeys: []
+  };
+}
+export const LegacyAminoPubKey = {
+  typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey",
+  encode(message: LegacyAminoPubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.threshold !== 0) {
+      writer.uint32(8).uint32(message.threshold);
+    }
+    for (const v of message.publicKeys) {
+      Any.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): LegacyAminoPubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLegacyAminoPubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.threshold = reader.uint32();
+          break;
+        case 2:
+          message.publicKeys.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<LegacyAminoPubKey>): LegacyAminoPubKey {
+    const message = createBaseLegacyAminoPubKey();
+    message.threshold = object.threshold ?? 0;
+    message.publicKeys = object.publicKeys?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: LegacyAminoPubKeyAmino): LegacyAminoPubKey {
+    const message = createBaseLegacyAminoPubKey();
+    if (object.threshold !== undefined && object.threshold !== null) {
+      message.threshold = object.threshold;
+    }
+    message.publicKeys = object.public_keys?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: LegacyAminoPubKey): LegacyAminoPubKeyAmino {
+    const obj: any = {};
+    obj.threshold = message.threshold === 0 ? undefined : message.threshold;
+    if (message.publicKeys) {
+      obj.public_keys = message.publicKeys.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.public_keys = message.publicKeys;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: LegacyAminoPubKeyAminoMsg): LegacyAminoPubKey {
+    return LegacyAminoPubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: LegacyAminoPubKey): LegacyAminoPubKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/LegacyAminoPubKey",
+      value: LegacyAminoPubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: LegacyAminoPubKeyProtoMsg): LegacyAminoPubKey {
+    return LegacyAminoPubKey.decode(message.value);
+  },
+  toProto(message: LegacyAminoPubKey): Uint8Array {
+    return LegacyAminoPubKey.encode(message).finish();
+  },
+  toProtoMsg(message: LegacyAminoPubKey): LegacyAminoPubKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey",
+      value: LegacyAminoPubKey.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/crypto/multisig/v1beta1/multisig.ts

@@ -0,0 +1,224 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/**
+ * MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey.
+ * See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers
+ * signed and with which modes.
+ */
+export interface MultiSignature {
+  signatures: Uint8Array[];
+}
+export interface MultiSignatureProtoMsg {
+  typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature";
+  value: Uint8Array;
+}
+/**
+ * MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey.
+ * See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers
+ * signed and with which modes.
+ */
+export interface MultiSignatureAmino {
+  signatures?: string[];
+}
+export interface MultiSignatureAminoMsg {
+  type: "cosmos-sdk/MultiSignature";
+  value: MultiSignatureAmino;
+}
+/**
+ * MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey.
+ * See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers
+ * signed and with which modes.
+ */
+export interface MultiSignatureSDKType {
+  signatures: Uint8Array[];
+}
+/**
+ * CompactBitArray is an implementation of a space efficient bit array.
+ * This is used to ensure that the encoded data takes up a minimal amount of
+ * space after proto encoding.
+ * This is not thread safe, and is not intended for concurrent usage.
+ */
+export interface CompactBitArray {
+  extraBitsStored: number;
+  elems: Uint8Array;
+}
+export interface CompactBitArrayProtoMsg {
+  typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray";
+  value: Uint8Array;
+}
+/**
+ * CompactBitArray is an implementation of a space efficient bit array.
+ * This is used to ensure that the encoded data takes up a minimal amount of
+ * space after proto encoding.
+ * This is not thread safe, and is not intended for concurrent usage.
+ */
+export interface CompactBitArrayAmino {
+  extra_bits_stored?: number;
+  elems?: string;
+}
+export interface CompactBitArrayAminoMsg {
+  type: "cosmos-sdk/CompactBitArray";
+  value: CompactBitArrayAmino;
+}
+/**
+ * CompactBitArray is an implementation of a space efficient bit array.
+ * This is used to ensure that the encoded data takes up a minimal amount of
+ * space after proto encoding.
+ * This is not thread safe, and is not intended for concurrent usage.
+ */
+export interface CompactBitArraySDKType {
+  extra_bits_stored: number;
+  elems: Uint8Array;
+}
+function createBaseMultiSignature(): MultiSignature {
+  return {
+    signatures: []
+  };
+}
+export const MultiSignature = {
+  typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+  encode(message: MultiSignature, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.signatures) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MultiSignature {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMultiSignature();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.signatures.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MultiSignature>): MultiSignature {
+    const message = createBaseMultiSignature();
+    message.signatures = object.signatures?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: MultiSignatureAmino): MultiSignature {
+    const message = createBaseMultiSignature();
+    message.signatures = object.signatures?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: MultiSignature): MultiSignatureAmino {
+    const obj: any = {};
+    if (message.signatures) {
+      obj.signatures = message.signatures.map(e => base64FromBytes(e));
+    } else {
+      obj.signatures = message.signatures;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MultiSignatureAminoMsg): MultiSignature {
+    return MultiSignature.fromAmino(object.value);
+  },
+  toAminoMsg(message: MultiSignature): MultiSignatureAminoMsg {
+    return {
+      type: "cosmos-sdk/MultiSignature",
+      value: MultiSignature.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MultiSignatureProtoMsg): MultiSignature {
+    return MultiSignature.decode(message.value);
+  },
+  toProto(message: MultiSignature): Uint8Array {
+    return MultiSignature.encode(message).finish();
+  },
+  toProtoMsg(message: MultiSignature): MultiSignatureProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+      value: MultiSignature.encode(message).finish()
+    };
+  }
+};
+function createBaseCompactBitArray(): CompactBitArray {
+  return {
+    extraBitsStored: 0,
+    elems: new Uint8Array()
+  };
+}
+export const CompactBitArray = {
+  typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+  encode(message: CompactBitArray, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.extraBitsStored !== 0) {
+      writer.uint32(8).uint32(message.extraBitsStored);
+    }
+    if (message.elems.length !== 0) {
+      writer.uint32(18).bytes(message.elems);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CompactBitArray {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompactBitArray();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.extraBitsStored = reader.uint32();
+          break;
+        case 2:
+          message.elems = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CompactBitArray>): CompactBitArray {
+    const message = createBaseCompactBitArray();
+    message.extraBitsStored = object.extraBitsStored ?? 0;
+    message.elems = object.elems ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: CompactBitArrayAmino): CompactBitArray {
+    const message = createBaseCompactBitArray();
+    if (object.extra_bits_stored !== undefined && object.extra_bits_stored !== null) {
+      message.extraBitsStored = object.extra_bits_stored;
+    }
+    if (object.elems !== undefined && object.elems !== null) {
+      message.elems = bytesFromBase64(object.elems);
+    }
+    return message;
+  },
+  toAmino(message: CompactBitArray): CompactBitArrayAmino {
+    const obj: any = {};
+    obj.extra_bits_stored = message.extraBitsStored === 0 ? undefined : message.extraBitsStored;
+    obj.elems = message.elems ? base64FromBytes(message.elems) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: CompactBitArrayAminoMsg): CompactBitArray {
+    return CompactBitArray.fromAmino(object.value);
+  },
+  toAminoMsg(message: CompactBitArray): CompactBitArrayAminoMsg {
+    return {
+      type: "cosmos-sdk/CompactBitArray",
+      value: CompactBitArray.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CompactBitArrayProtoMsg): CompactBitArray {
+    return CompactBitArray.decode(message.value);
+  },
+  toProto(message: CompactBitArray): Uint8Array {
+    return CompactBitArray.encode(message).finish();
+  },
+  toProtoMsg(message: CompactBitArray): CompactBitArrayProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+      value: CompactBitArray.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/crypto/secp256k1/keys.ts

@@ -0,0 +1,198 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/**
+ * PubKey defines a secp256k1 public key
+ * Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte
+ * if the y-coordinate is the lexicographically largest of the two associated with
+ * the x-coordinate. Otherwise the first byte is a 0x03.
+ * This prefix is followed with the x-coordinate.
+ */
+export interface PubKey {
+  key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.secp256k1.PubKey";
+  value: Uint8Array;
+}
+/**
+ * PubKey defines a secp256k1 public key
+ * Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte
+ * if the y-coordinate is the lexicographically largest of the two associated with
+ * the x-coordinate. Otherwise the first byte is a 0x03.
+ * This prefix is followed with the x-coordinate.
+ */
+export interface PubKeyAmino {
+  key?: string;
+}
+export interface PubKeyAminoMsg {
+  type: "cosmos-sdk/PubKey";
+  value: PubKeyAmino;
+}
+/**
+ * PubKey defines a secp256k1 public key
+ * Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte
+ * if the y-coordinate is the lexicographically largest of the two associated with
+ * the x-coordinate. Otherwise the first byte is a 0x03.
+ * This prefix is followed with the x-coordinate.
+ */
+export interface PubKeySDKType {
+  key: Uint8Array;
+}
+/** PrivKey defines a secp256k1 private key. */
+export interface PrivKey {
+  key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.secp256k1.PrivKey";
+  value: Uint8Array;
+}
+/** PrivKey defines a secp256k1 private key. */
+export interface PrivKeyAmino {
+  key?: string;
+}
+export interface PrivKeyAminoMsg {
+  type: "cosmos-sdk/PrivKey";
+  value: PrivKeyAmino;
+}
+/** PrivKey defines a secp256k1 private key. */
+export interface PrivKeySDKType {
+  key: Uint8Array;
+}
+function createBasePubKey(): PubKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PubKey = {
+  typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+  encode(message: PubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PubKey>): PubKey {
+    const message = createBasePubKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PubKeyAmino): PubKey {
+    const message = createBasePubKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PubKey): PubKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PubKeyAminoMsg): PubKey {
+    return PubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PubKey): PubKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PubKey",
+      value: PubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PubKeyProtoMsg): PubKey {
+    return PubKey.decode(message.value);
+  },
+  toProto(message: PubKey): Uint8Array {
+    return PubKey.encode(message).finish();
+  },
+  toProtoMsg(message: PubKey): PubKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+      value: PubKey.encode(message).finish()
+    };
+  }
+};
+function createBasePrivKey(): PrivKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PrivKey = {
+  typeUrl: "/cosmos.crypto.secp256k1.PrivKey",
+  encode(message: PrivKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PrivKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrivKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PrivKey>): PrivKey {
+    const message = createBasePrivKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PrivKeyAmino): PrivKey {
+    const message = createBasePrivKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PrivKey): PrivKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PrivKeyAminoMsg): PrivKey {
+    return PrivKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PrivKey): PrivKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PrivKey",
+      value: PrivKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PrivKeyProtoMsg): PrivKey {
+    return PrivKey.decode(message.value);
+  },
+  toProto(message: PrivKey): Uint8Array {
+    return PrivKey.encode(message).finish();
+  },
+  toProtoMsg(message: PrivKey): PrivKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.secp256k1.PrivKey",
+      value: PrivKey.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/crypto/secp256r1/keys.ts

@@ -0,0 +1,190 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/** PubKey defines a secp256r1 ECDSA public key. */
+export interface PubKey {
+  /**
+   * Point on secp256r1 curve in a compressed representation as specified in section
+   * 4.3.6 of ANSI X9.62: https://webstore.ansi.org/standards/ascx9/ansix9621998
+   */
+  key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.secp256r1.PubKey";
+  value: Uint8Array;
+}
+/** PubKey defines a secp256r1 ECDSA public key. */
+export interface PubKeyAmino {
+  /**
+   * Point on secp256r1 curve in a compressed representation as specified in section
+   * 4.3.6 of ANSI X9.62: https://webstore.ansi.org/standards/ascx9/ansix9621998
+   */
+  key?: string;
+}
+export interface PubKeyAminoMsg {
+  type: "cosmos-sdk/PubKey";
+  value: PubKeyAmino;
+}
+/** PubKey defines a secp256r1 ECDSA public key. */
+export interface PubKeySDKType {
+  key: Uint8Array;
+}
+/** PrivKey defines a secp256r1 ECDSA private key. */
+export interface PrivKey {
+  /** secret number serialized using big-endian encoding */
+  secret: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+  typeUrl: "/cosmos.crypto.secp256r1.PrivKey";
+  value: Uint8Array;
+}
+/** PrivKey defines a secp256r1 ECDSA private key. */
+export interface PrivKeyAmino {
+  /** secret number serialized using big-endian encoding */
+  secret?: string;
+}
+export interface PrivKeyAminoMsg {
+  type: "cosmos-sdk/PrivKey";
+  value: PrivKeyAmino;
+}
+/** PrivKey defines a secp256r1 ECDSA private key. */
+export interface PrivKeySDKType {
+  secret: Uint8Array;
+}
+function createBasePubKey(): PubKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+export const PubKey = {
+  typeUrl: "/cosmos.crypto.secp256r1.PubKey",
+  encode(message: PubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PubKey>): PubKey {
+    const message = createBasePubKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PubKeyAmino): PubKey {
+    const message = createBasePubKey();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = bytesFromBase64(object.key);
+    }
+    return message;
+  },
+  toAmino(message: PubKey): PubKeyAmino {
+    const obj: any = {};
+    obj.key = message.key ? base64FromBytes(message.key) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PubKeyAminoMsg): PubKey {
+    return PubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PubKey): PubKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PubKey",
+      value: PubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PubKeyProtoMsg): PubKey {
+    return PubKey.decode(message.value);
+  },
+  toProto(message: PubKey): Uint8Array {
+    return PubKey.encode(message).finish();
+  },
+  toProtoMsg(message: PubKey): PubKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.secp256r1.PubKey",
+      value: PubKey.encode(message).finish()
+    };
+  }
+};
+function createBasePrivKey(): PrivKey {
+  return {
+    secret: new Uint8Array()
+  };
+}
+export const PrivKey = {
+  typeUrl: "/cosmos.crypto.secp256r1.PrivKey",
+  encode(message: PrivKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.secret.length !== 0) {
+      writer.uint32(10).bytes(message.secret);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PrivKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrivKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.secret = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PrivKey>): PrivKey {
+    const message = createBasePrivKey();
+    message.secret = object.secret ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: PrivKeyAmino): PrivKey {
+    const message = createBasePrivKey();
+    if (object.secret !== undefined && object.secret !== null) {
+      message.secret = bytesFromBase64(object.secret);
+    }
+    return message;
+  },
+  toAmino(message: PrivKey): PrivKeyAmino {
+    const obj: any = {};
+    obj.secret = message.secret ? base64FromBytes(message.secret) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PrivKeyAminoMsg): PrivKey {
+    return PrivKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: PrivKey): PrivKeyAminoMsg {
+    return {
+      type: "cosmos-sdk/PrivKey",
+      value: PrivKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PrivKeyProtoMsg): PrivKey {
+    return PrivKey.decode(message.value);
+  },
+  toProto(message: PrivKey): Uint8Array {
+    return PrivKey.encode(message).finish();
+  },
+  toProtoMsg(message: PrivKey): PrivKeyProtoMsg {
+    return {
+      typeUrl: "/cosmos.crypto.secp256r1.PrivKey",
+      value: PrivKey.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/distribution/v1beta1/query.lcd.ts

@@ -0,0 +1,80 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponseSDKType, QueryValidatorCommissionRequest, QueryValidatorCommissionResponseSDKType, QueryValidatorSlashesRequest, QueryValidatorSlashesResponseSDKType, QueryDelegationRewardsRequest, QueryDelegationRewardsResponseSDKType, QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponseSDKType, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponseSDKType, QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponseSDKType, QueryCommunityPoolRequest, QueryCommunityPoolResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.validatorOutstandingRewards = this.validatorOutstandingRewards.bind(this);
+    this.validatorCommission = this.validatorCommission.bind(this);
+    this.validatorSlashes = this.validatorSlashes.bind(this);
+    this.delegationRewards = this.delegationRewards.bind(this);
+    this.delegationTotalRewards = this.delegationTotalRewards.bind(this);
+    this.delegatorValidators = this.delegatorValidators.bind(this);
+    this.delegatorWithdrawAddress = this.delegatorWithdrawAddress.bind(this);
+    this.communityPool = this.communityPool.bind(this);
+  }
+  /* Params queries params of the distribution module. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* ValidatorOutstandingRewards queries rewards of a validator address. */
+  async validatorOutstandingRewards(params: QueryValidatorOutstandingRewardsRequest): Promise<QueryValidatorOutstandingRewardsResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/validators/${params.validatorAddress}/outstanding_rewards`;
+    return await this.req.get<QueryValidatorOutstandingRewardsResponseSDKType>(endpoint);
+  }
+  /* ValidatorCommission queries accumulated commission for a validator. */
+  async validatorCommission(params: QueryValidatorCommissionRequest): Promise<QueryValidatorCommissionResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/validators/${params.validatorAddress}/commission`;
+    return await this.req.get<QueryValidatorCommissionResponseSDKType>(endpoint);
+  }
+  /* ValidatorSlashes queries slash events of a validator. */
+  async validatorSlashes(params: QueryValidatorSlashesRequest): Promise<QueryValidatorSlashesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.startingHeight !== "undefined") {
+      options.params.starting_height = params.startingHeight;
+    }
+    if (typeof params?.endingHeight !== "undefined") {
+      options.params.ending_height = params.endingHeight;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/distribution/v1beta1/validators/${params.validatorAddress}/slashes`;
+    return await this.req.get<QueryValidatorSlashesResponseSDKType>(endpoint, options);
+  }
+  /* DelegationRewards queries the total rewards accrued by a delegation. */
+  async delegationRewards(params: QueryDelegationRewardsRequest): Promise<QueryDelegationRewardsResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/delegators/${params.delegatorAddress}/rewards/${params.validatorAddress}`;
+    return await this.req.get<QueryDelegationRewardsResponseSDKType>(endpoint);
+  }
+  /* DelegationTotalRewards queries the total rewards accrued by a each
+   validator. */
+  async delegationTotalRewards(params: QueryDelegationTotalRewardsRequest): Promise<QueryDelegationTotalRewardsResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/delegators/${params.delegatorAddress}/rewards`;
+    return await this.req.get<QueryDelegationTotalRewardsResponseSDKType>(endpoint);
+  }
+  /* DelegatorValidators queries the validators of a delegator. */
+  async delegatorValidators(params: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/delegators/${params.delegatorAddress}/validators`;
+    return await this.req.get<QueryDelegatorValidatorsResponseSDKType>(endpoint);
+  }
+  /* DelegatorWithdrawAddress queries withdraw address of a delegator. */
+  async delegatorWithdrawAddress(params: QueryDelegatorWithdrawAddressRequest): Promise<QueryDelegatorWithdrawAddressResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/delegators/${params.delegatorAddress}/withdraw_address`;
+    return await this.req.get<QueryDelegatorWithdrawAddressResponseSDKType>(endpoint);
+  }
+  /* CommunityPool queries the community pool coins. */
+  async communityPool(_params: QueryCommunityPoolRequest = {}): Promise<QueryCommunityPoolResponseSDKType> {
+    const endpoint = `cosmos/distribution/v1beta1/community_pool`;
+    return await this.req.get<QueryCommunityPoolResponseSDKType>(endpoint);
+  }
+}

src/codegen/cosmos/distribution/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,121 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponse, QueryValidatorCommissionRequest, QueryValidatorCommissionResponse, QueryValidatorSlashesRequest, QueryValidatorSlashesResponse, QueryDelegationRewardsRequest, QueryDelegationRewardsResponse, QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponse, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse, QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponse, QueryCommunityPoolRequest, QueryCommunityPoolResponse } from "./query";
+/** Query defines the gRPC querier service for distribution module. */
+export interface Query {
+  /** Params queries params of the distribution module. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** ValidatorOutstandingRewards queries rewards of a validator address. */
+  validatorOutstandingRewards(request: QueryValidatorOutstandingRewardsRequest): Promise<QueryValidatorOutstandingRewardsResponse>;
+  /** ValidatorCommission queries accumulated commission for a validator. */
+  validatorCommission(request: QueryValidatorCommissionRequest): Promise<QueryValidatorCommissionResponse>;
+  /** ValidatorSlashes queries slash events of a validator. */
+  validatorSlashes(request: QueryValidatorSlashesRequest): Promise<QueryValidatorSlashesResponse>;
+  /** DelegationRewards queries the total rewards accrued by a delegation. */
+  delegationRewards(request: QueryDelegationRewardsRequest): Promise<QueryDelegationRewardsResponse>;
+  /**
+   * DelegationTotalRewards queries the total rewards accrued by a each
+   * validator.
+   */
+  delegationTotalRewards(request: QueryDelegationTotalRewardsRequest): Promise<QueryDelegationTotalRewardsResponse>;
+  /** DelegatorValidators queries the validators of a delegator. */
+  delegatorValidators(request: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponse>;
+  /** DelegatorWithdrawAddress queries withdraw address of a delegator. */
+  delegatorWithdrawAddress(request: QueryDelegatorWithdrawAddressRequest): Promise<QueryDelegatorWithdrawAddressResponse>;
+  /** CommunityPool queries the community pool coins. */
+  communityPool(request?: QueryCommunityPoolRequest): Promise<QueryCommunityPoolResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.validatorOutstandingRewards = this.validatorOutstandingRewards.bind(this);
+    this.validatorCommission = this.validatorCommission.bind(this);
+    this.validatorSlashes = this.validatorSlashes.bind(this);
+    this.delegationRewards = this.delegationRewards.bind(this);
+    this.delegationTotalRewards = this.delegationTotalRewards.bind(this);
+    this.delegatorValidators = this.delegatorValidators.bind(this);
+    this.delegatorWithdrawAddress = this.delegatorWithdrawAddress.bind(this);
+    this.communityPool = this.communityPool.bind(this);
+  }
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  validatorOutstandingRewards(request: QueryValidatorOutstandingRewardsRequest): Promise<QueryValidatorOutstandingRewardsResponse> {
+    const data = QueryValidatorOutstandingRewardsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorOutstandingRewards", data);
+    return promise.then(data => QueryValidatorOutstandingRewardsResponse.decode(new BinaryReader(data)));
+  }
+  validatorCommission(request: QueryValidatorCommissionRequest): Promise<QueryValidatorCommissionResponse> {
+    const data = QueryValidatorCommissionRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorCommission", data);
+    return promise.then(data => QueryValidatorCommissionResponse.decode(new BinaryReader(data)));
+  }
+  validatorSlashes(request: QueryValidatorSlashesRequest): Promise<QueryValidatorSlashesResponse> {
+    const data = QueryValidatorSlashesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "ValidatorSlashes", data);
+    return promise.then(data => QueryValidatorSlashesResponse.decode(new BinaryReader(data)));
+  }
+  delegationRewards(request: QueryDelegationRewardsRequest): Promise<QueryDelegationRewardsResponse> {
+    const data = QueryDelegationRewardsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegationRewards", data);
+    return promise.then(data => QueryDelegationRewardsResponse.decode(new BinaryReader(data)));
+  }
+  delegationTotalRewards(request: QueryDelegationTotalRewardsRequest): Promise<QueryDelegationTotalRewardsResponse> {
+    const data = QueryDelegationTotalRewardsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegationTotalRewards", data);
+    return promise.then(data => QueryDelegationTotalRewardsResponse.decode(new BinaryReader(data)));
+  }
+  delegatorValidators(request: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponse> {
+    const data = QueryDelegatorValidatorsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegatorValidators", data);
+    return promise.then(data => QueryDelegatorValidatorsResponse.decode(new BinaryReader(data)));
+  }
+  delegatorWithdrawAddress(request: QueryDelegatorWithdrawAddressRequest): Promise<QueryDelegatorWithdrawAddressResponse> {
+    const data = QueryDelegatorWithdrawAddressRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "DelegatorWithdrawAddress", data);
+    return promise.then(data => QueryDelegatorWithdrawAddressResponse.decode(new BinaryReader(data)));
+  }
+  communityPool(request: QueryCommunityPoolRequest = {}): Promise<QueryCommunityPoolResponse> {
+    const data = QueryCommunityPoolRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Query", "CommunityPool", data);
+    return promise.then(data => QueryCommunityPoolResponse.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);
+    },
+    validatorOutstandingRewards(request: QueryValidatorOutstandingRewardsRequest): Promise<QueryValidatorOutstandingRewardsResponse> {
+      return queryService.validatorOutstandingRewards(request);
+    },
+    validatorCommission(request: QueryValidatorCommissionRequest): Promise<QueryValidatorCommissionResponse> {
+      return queryService.validatorCommission(request);
+    },
+    validatorSlashes(request: QueryValidatorSlashesRequest): Promise<QueryValidatorSlashesResponse> {
+      return queryService.validatorSlashes(request);
+    },
+    delegationRewards(request: QueryDelegationRewardsRequest): Promise<QueryDelegationRewardsResponse> {
+      return queryService.delegationRewards(request);
+    },
+    delegationTotalRewards(request: QueryDelegationTotalRewardsRequest): Promise<QueryDelegationTotalRewardsResponse> {
+      return queryService.delegationTotalRewards(request);
+    },
+    delegatorValidators(request: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponse> {
+      return queryService.delegatorValidators(request);
+    },
+    delegatorWithdrawAddress(request: QueryDelegatorWithdrawAddressRequest): Promise<QueryDelegatorWithdrawAddressResponse> {
+      return queryService.delegatorWithdrawAddress(request);
+    },
+    communityPool(request?: QueryCommunityPoolRequest): Promise<QueryCommunityPoolResponse> {
+      return queryService.communityPool(request);
+    }
+  };
+};

src/codegen/cosmos/distribution/v1beta1/tx.amino.ts

@@ -0,0 +1,23 @@
+import { MsgSetWithdrawAddress, MsgWithdrawDelegatorReward, MsgWithdrawValidatorCommission, MsgFundCommunityPool } from "./tx";
+export const AminoConverter = {
+  "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress": {
+    aminoType: "cosmos-sdk/MsgModifyWithdrawAddress",
+    toAmino: MsgSetWithdrawAddress.toAmino,
+    fromAmino: MsgSetWithdrawAddress.fromAmino
+  },
+  "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": {
+    aminoType: "cosmos-sdk/MsgWithdrawDelegationReward",
+    toAmino: MsgWithdrawDelegatorReward.toAmino,
+    fromAmino: MsgWithdrawDelegatorReward.fromAmino
+  },
+  "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": {
+    aminoType: "cosmos-sdk/MsgWithdrawValidatorCommission",
+    toAmino: MsgWithdrawValidatorCommission.toAmino,
+    fromAmino: MsgWithdrawValidatorCommission.fromAmino
+  },
+  "/cosmos.distribution.v1beta1.MsgFundCommunityPool": {
+    aminoType: "cosmos-sdk/MsgFundCommunityPool",
+    toAmino: MsgFundCommunityPool.toAmino,
+    fromAmino: MsgFundCommunityPool.fromAmino
+  }
+};

src/codegen/cosmos/distribution/v1beta1/tx.registry.ts

@@ -0,0 +1,88 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSetWithdrawAddress, MsgWithdrawDelegatorReward, MsgWithdrawValidatorCommission, MsgFundCommunityPool } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.distribution.v1beta1.MsgSetWithdrawAddress", MsgSetWithdrawAddress], ["/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward", MsgWithdrawDelegatorReward], ["/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission", MsgWithdrawValidatorCommission], ["/cosmos.distribution.v1beta1.MsgFundCommunityPool", MsgFundCommunityPool]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    setWithdrawAddress(value: MsgSetWithdrawAddress) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+        value: MsgSetWithdrawAddress.encode(value).finish()
+      };
+    },
+    withdrawDelegatorReward(value: MsgWithdrawDelegatorReward) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+        value: MsgWithdrawDelegatorReward.encode(value).finish()
+      };
+    },
+    withdrawValidatorCommission(value: MsgWithdrawValidatorCommission) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+        value: MsgWithdrawValidatorCommission.encode(value).finish()
+      };
+    },
+    fundCommunityPool(value: MsgFundCommunityPool) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+        value: MsgFundCommunityPool.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    setWithdrawAddress(value: MsgSetWithdrawAddress) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+        value
+      };
+    },
+    withdrawDelegatorReward(value: MsgWithdrawDelegatorReward) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+        value
+      };
+    },
+    withdrawValidatorCommission(value: MsgWithdrawValidatorCommission) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+        value
+      };
+    },
+    fundCommunityPool(value: MsgFundCommunityPool) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    setWithdrawAddress(value: MsgSetWithdrawAddress) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+        value: MsgSetWithdrawAddress.fromPartial(value)
+      };
+    },
+    withdrawDelegatorReward(value: MsgWithdrawDelegatorReward) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+        value: MsgWithdrawDelegatorReward.fromPartial(value)
+      };
+    },
+    withdrawValidatorCommission(value: MsgWithdrawValidatorCommission) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+        value: MsgWithdrawValidatorCommission.fromPartial(value)
+      };
+    },
+    fundCommunityPool(value: MsgFundCommunityPool) {
+      return {
+        typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+        value: MsgFundCommunityPool.fromPartial(value)
+      };
+    }
+  }
+};

src/codegen/cosmos/distribution/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,56 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgSetWithdrawAddress, MsgSetWithdrawAddressResponse, MsgWithdrawDelegatorReward, MsgWithdrawDelegatorRewardResponse, MsgWithdrawValidatorCommission, MsgWithdrawValidatorCommissionResponse, MsgFundCommunityPool, MsgFundCommunityPoolResponse } from "./tx";
+/** Msg defines the distribution Msg service. */
+export interface Msg {
+  /**
+   * SetWithdrawAddress defines a method to change the withdraw address
+   * for a delegator (or validator self-delegation).
+   */
+  setWithdrawAddress(request: MsgSetWithdrawAddress): Promise<MsgSetWithdrawAddressResponse>;
+  /**
+   * WithdrawDelegatorReward defines a method to withdraw rewards of delegator
+   * from a single validator.
+   */
+  withdrawDelegatorReward(request: MsgWithdrawDelegatorReward): Promise<MsgWithdrawDelegatorRewardResponse>;
+  /**
+   * WithdrawValidatorCommission defines a method to withdraw the
+   * full commission to the validator address.
+   */
+  withdrawValidatorCommission(request: MsgWithdrawValidatorCommission): Promise<MsgWithdrawValidatorCommissionResponse>;
+  /**
+   * FundCommunityPool defines a method to allow an account to directly
+   * fund the community pool.
+   */
+  fundCommunityPool(request: MsgFundCommunityPool): Promise<MsgFundCommunityPoolResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.setWithdrawAddress = this.setWithdrawAddress.bind(this);
+    this.withdrawDelegatorReward = this.withdrawDelegatorReward.bind(this);
+    this.withdrawValidatorCommission = this.withdrawValidatorCommission.bind(this);
+    this.fundCommunityPool = this.fundCommunityPool.bind(this);
+  }
+  setWithdrawAddress(request: MsgSetWithdrawAddress): Promise<MsgSetWithdrawAddressResponse> {
+    const data = MsgSetWithdrawAddress.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "SetWithdrawAddress", data);
+    return promise.then(data => MsgSetWithdrawAddressResponse.decode(new BinaryReader(data)));
+  }
+  withdrawDelegatorReward(request: MsgWithdrawDelegatorReward): Promise<MsgWithdrawDelegatorRewardResponse> {
+    const data = MsgWithdrawDelegatorReward.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawDelegatorReward", data);
+    return promise.then(data => MsgWithdrawDelegatorRewardResponse.decode(new BinaryReader(data)));
+  }
+  withdrawValidatorCommission(request: MsgWithdrawValidatorCommission): Promise<MsgWithdrawValidatorCommissionResponse> {
+    const data = MsgWithdrawValidatorCommission.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawValidatorCommission", data);
+    return promise.then(data => MsgWithdrawValidatorCommissionResponse.decode(new BinaryReader(data)));
+  }
+  fundCommunityPool(request: MsgFundCommunityPool): Promise<MsgFundCommunityPoolResponse> {
+    const data = MsgFundCommunityPool.encode(request).finish();
+    const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "FundCommunityPool", data);
+    return promise.then(data => MsgFundCommunityPoolResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/distribution/v1beta1/tx.ts

@@ -0,0 +1,721 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * MsgSetWithdrawAddress sets the withdraw address for
+ * a delegator (or validator self-delegation).
+ */
+export interface MsgSetWithdrawAddress {
+  delegatorAddress: string;
+  withdrawAddress: string;
+}
+export interface MsgSetWithdrawAddressProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress";
+  value: Uint8Array;
+}
+/**
+ * MsgSetWithdrawAddress sets the withdraw address for
+ * a delegator (or validator self-delegation).
+ */
+export interface MsgSetWithdrawAddressAmino {
+  delegator_address?: string;
+  withdraw_address?: string;
+}
+export interface MsgSetWithdrawAddressAminoMsg {
+  type: "cosmos-sdk/MsgModifyWithdrawAddress";
+  value: MsgSetWithdrawAddressAmino;
+}
+/**
+ * MsgSetWithdrawAddress sets the withdraw address for
+ * a delegator (or validator self-delegation).
+ */
+export interface MsgSetWithdrawAddressSDKType {
+  delegator_address: string;
+  withdraw_address: string;
+}
+/** MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type. */
+export interface MsgSetWithdrawAddressResponse {}
+export interface MsgSetWithdrawAddressResponseProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse";
+  value: Uint8Array;
+}
+/** MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type. */
+export interface MsgSetWithdrawAddressResponseAmino {}
+export interface MsgSetWithdrawAddressResponseAminoMsg {
+  type: "cosmos-sdk/MsgSetWithdrawAddressResponse";
+  value: MsgSetWithdrawAddressResponseAmino;
+}
+/** MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type. */
+export interface MsgSetWithdrawAddressResponseSDKType {}
+/**
+ * MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator
+ * from a single validator.
+ */
+export interface MsgWithdrawDelegatorReward {
+  delegatorAddress: string;
+  validatorAddress: string;
+}
+export interface MsgWithdrawDelegatorRewardProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward";
+  value: Uint8Array;
+}
+/**
+ * MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator
+ * from a single validator.
+ */
+export interface MsgWithdrawDelegatorRewardAmino {
+  delegator_address?: string;
+  validator_address?: string;
+}
+export interface MsgWithdrawDelegatorRewardAminoMsg {
+  type: "cosmos-sdk/MsgWithdrawDelegationReward";
+  value: MsgWithdrawDelegatorRewardAmino;
+}
+/**
+ * MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator
+ * from a single validator.
+ */
+export interface MsgWithdrawDelegatorRewardSDKType {
+  delegator_address: string;
+  validator_address: string;
+}
+/** MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type. */
+export interface MsgWithdrawDelegatorRewardResponse {}
+export interface MsgWithdrawDelegatorRewardResponseProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse";
+  value: Uint8Array;
+}
+/** MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type. */
+export interface MsgWithdrawDelegatorRewardResponseAmino {}
+export interface MsgWithdrawDelegatorRewardResponseAminoMsg {
+  type: "cosmos-sdk/MsgWithdrawDelegatorRewardResponse";
+  value: MsgWithdrawDelegatorRewardResponseAmino;
+}
+/** MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type. */
+export interface MsgWithdrawDelegatorRewardResponseSDKType {}
+/**
+ * MsgWithdrawValidatorCommission withdraws the full commission to the validator
+ * address.
+ */
+export interface MsgWithdrawValidatorCommission {
+  validatorAddress: string;
+}
+export interface MsgWithdrawValidatorCommissionProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission";
+  value: Uint8Array;
+}
+/**
+ * MsgWithdrawValidatorCommission withdraws the full commission to the validator
+ * address.
+ */
+export interface MsgWithdrawValidatorCommissionAmino {
+  validator_address?: string;
+}
+export interface MsgWithdrawValidatorCommissionAminoMsg {
+  type: "cosmos-sdk/MsgWithdrawValidatorCommission";
+  value: MsgWithdrawValidatorCommissionAmino;
+}
+/**
+ * MsgWithdrawValidatorCommission withdraws the full commission to the validator
+ * address.
+ */
+export interface MsgWithdrawValidatorCommissionSDKType {
+  validator_address: string;
+}
+/** MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type. */
+export interface MsgWithdrawValidatorCommissionResponse {}
+export interface MsgWithdrawValidatorCommissionResponseProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse";
+  value: Uint8Array;
+}
+/** MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type. */
+export interface MsgWithdrawValidatorCommissionResponseAmino {}
+export interface MsgWithdrawValidatorCommissionResponseAminoMsg {
+  type: "cosmos-sdk/MsgWithdrawValidatorCommissionResponse";
+  value: MsgWithdrawValidatorCommissionResponseAmino;
+}
+/** MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type. */
+export interface MsgWithdrawValidatorCommissionResponseSDKType {}
+/**
+ * MsgFundCommunityPool allows an account to directly
+ * fund the community pool.
+ */
+export interface MsgFundCommunityPool {
+  amount: Coin[];
+  depositor: string;
+}
+export interface MsgFundCommunityPoolProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool";
+  value: Uint8Array;
+}
+/**
+ * MsgFundCommunityPool allows an account to directly
+ * fund the community pool.
+ */
+export interface MsgFundCommunityPoolAmino {
+  amount?: CoinAmino[];
+  depositor?: string;
+}
+export interface MsgFundCommunityPoolAminoMsg {
+  type: "cosmos-sdk/MsgFundCommunityPool";
+  value: MsgFundCommunityPoolAmino;
+}
+/**
+ * MsgFundCommunityPool allows an account to directly
+ * fund the community pool.
+ */
+export interface MsgFundCommunityPoolSDKType {
+  amount: CoinSDKType[];
+  depositor: string;
+}
+/** MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. */
+export interface MsgFundCommunityPoolResponse {}
+export interface MsgFundCommunityPoolResponseProtoMsg {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse";
+  value: Uint8Array;
+}
+/** MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. */
+export interface MsgFundCommunityPoolResponseAmino {}
+export interface MsgFundCommunityPoolResponseAminoMsg {
+  type: "cosmos-sdk/MsgFundCommunityPoolResponse";
+  value: MsgFundCommunityPoolResponseAmino;
+}
+/** MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. */
+export interface MsgFundCommunityPoolResponseSDKType {}
+function createBaseMsgSetWithdrawAddress(): MsgSetWithdrawAddress {
+  return {
+    delegatorAddress: "",
+    withdrawAddress: ""
+  };
+}
+export const MsgSetWithdrawAddress = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+  encode(message: MsgSetWithdrawAddress, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.delegatorAddress !== "") {
+      writer.uint32(10).string(message.delegatorAddress);
+    }
+    if (message.withdrawAddress !== "") {
+      writer.uint32(18).string(message.withdrawAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSetWithdrawAddress {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetWithdrawAddress();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.delegatorAddress = reader.string();
+          break;
+        case 2:
+          message.withdrawAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSetWithdrawAddress>): MsgSetWithdrawAddress {
+    const message = createBaseMsgSetWithdrawAddress();
+    message.delegatorAddress = object.delegatorAddress ?? "";
+    message.withdrawAddress = object.withdrawAddress ?? "";
+    return message;
+  },
+  fromAmino(object: MsgSetWithdrawAddressAmino): MsgSetWithdrawAddress {
+    const message = createBaseMsgSetWithdrawAddress();
+    if (object.delegator_address !== undefined && object.delegator_address !== null) {
+      message.delegatorAddress = object.delegator_address;
+    }
+    if (object.withdraw_address !== undefined && object.withdraw_address !== null) {
+      message.withdrawAddress = object.withdraw_address;
+    }
+    return message;
+  },
+  toAmino(message: MsgSetWithdrawAddress): MsgSetWithdrawAddressAmino {
+    const obj: any = {};
+    obj.delegator_address = message.delegatorAddress === "" ? undefined : message.delegatorAddress;
+    obj.withdraw_address = message.withdrawAddress === "" ? undefined : message.withdrawAddress;
+    return obj;
+  },
+  fromAminoMsg(object: MsgSetWithdrawAddressAminoMsg): MsgSetWithdrawAddress {
+    return MsgSetWithdrawAddress.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSetWithdrawAddress): MsgSetWithdrawAddressAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgModifyWithdrawAddress",
+      value: MsgSetWithdrawAddress.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSetWithdrawAddressProtoMsg): MsgSetWithdrawAddress {
+    return MsgSetWithdrawAddress.decode(message.value);
+  },
+  toProto(message: MsgSetWithdrawAddress): Uint8Array {
+    return MsgSetWithdrawAddress.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSetWithdrawAddress): MsgSetWithdrawAddressProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress",
+      value: MsgSetWithdrawAddress.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgSetWithdrawAddressResponse(): MsgSetWithdrawAddressResponse {
+  return {};
+}
+export const MsgSetWithdrawAddressResponse = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse",
+  encode(_: MsgSetWithdrawAddressResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSetWithdrawAddressResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSetWithdrawAddressResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgSetWithdrawAddressResponse>): MsgSetWithdrawAddressResponse {
+    const message = createBaseMsgSetWithdrawAddressResponse();
+    return message;
+  },
+  fromAmino(_: MsgSetWithdrawAddressResponseAmino): MsgSetWithdrawAddressResponse {
+    const message = createBaseMsgSetWithdrawAddressResponse();
+    return message;
+  },
+  toAmino(_: MsgSetWithdrawAddressResponse): MsgSetWithdrawAddressResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgSetWithdrawAddressResponseAminoMsg): MsgSetWithdrawAddressResponse {
+    return MsgSetWithdrawAddressResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSetWithdrawAddressResponse): MsgSetWithdrawAddressResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSetWithdrawAddressResponse",
+      value: MsgSetWithdrawAddressResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSetWithdrawAddressResponseProtoMsg): MsgSetWithdrawAddressResponse {
+    return MsgSetWithdrawAddressResponse.decode(message.value);
+  },
+  toProto(message: MsgSetWithdrawAddressResponse): Uint8Array {
+    return MsgSetWithdrawAddressResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSetWithdrawAddressResponse): MsgSetWithdrawAddressResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse",
+      value: MsgSetWithdrawAddressResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgWithdrawDelegatorReward(): MsgWithdrawDelegatorReward {
+  return {
+    delegatorAddress: "",
+    validatorAddress: ""
+  };
+}
+export const MsgWithdrawDelegatorReward = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+  encode(message: MsgWithdrawDelegatorReward, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.delegatorAddress !== "") {
+      writer.uint32(10).string(message.delegatorAddress);
+    }
+    if (message.validatorAddress !== "") {
+      writer.uint32(18).string(message.validatorAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawDelegatorReward {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgWithdrawDelegatorReward();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.delegatorAddress = reader.string();
+          break;
+        case 2:
+          message.validatorAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgWithdrawDelegatorReward>): MsgWithdrawDelegatorReward {
+    const message = createBaseMsgWithdrawDelegatorReward();
+    message.delegatorAddress = object.delegatorAddress ?? "";
+    message.validatorAddress = object.validatorAddress ?? "";
+    return message;
+  },
+  fromAmino(object: MsgWithdrawDelegatorRewardAmino): MsgWithdrawDelegatorReward {
+    const message = createBaseMsgWithdrawDelegatorReward();
+    if (object.delegator_address !== undefined && object.delegator_address !== null) {
+      message.delegatorAddress = object.delegator_address;
+    }
+    if (object.validator_address !== undefined && object.validator_address !== null) {
+      message.validatorAddress = object.validator_address;
+    }
+    return message;
+  },
+  toAmino(message: MsgWithdrawDelegatorReward): MsgWithdrawDelegatorRewardAmino {
+    const obj: any = {};
+    obj.delegator_address = message.delegatorAddress === "" ? undefined : message.delegatorAddress;
+    obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+    return obj;
+  },
+  fromAminoMsg(object: MsgWithdrawDelegatorRewardAminoMsg): MsgWithdrawDelegatorReward {
+    return MsgWithdrawDelegatorReward.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgWithdrawDelegatorReward): MsgWithdrawDelegatorRewardAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgWithdrawDelegationReward",
+      value: MsgWithdrawDelegatorReward.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgWithdrawDelegatorRewardProtoMsg): MsgWithdrawDelegatorReward {
+    return MsgWithdrawDelegatorReward.decode(message.value);
+  },
+  toProto(message: MsgWithdrawDelegatorReward): Uint8Array {
+    return MsgWithdrawDelegatorReward.encode(message).finish();
+  },
+  toProtoMsg(message: MsgWithdrawDelegatorReward): MsgWithdrawDelegatorRewardProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+      value: MsgWithdrawDelegatorReward.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgWithdrawDelegatorRewardResponse(): MsgWithdrawDelegatorRewardResponse {
+  return {};
+}
+export const MsgWithdrawDelegatorRewardResponse = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse",
+  encode(_: MsgWithdrawDelegatorRewardResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawDelegatorRewardResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgWithdrawDelegatorRewardResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgWithdrawDelegatorRewardResponse>): MsgWithdrawDelegatorRewardResponse {
+    const message = createBaseMsgWithdrawDelegatorRewardResponse();
+    return message;
+  },
+  fromAmino(_: MsgWithdrawDelegatorRewardResponseAmino): MsgWithdrawDelegatorRewardResponse {
+    const message = createBaseMsgWithdrawDelegatorRewardResponse();
+    return message;
+  },
+  toAmino(_: MsgWithdrawDelegatorRewardResponse): MsgWithdrawDelegatorRewardResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgWithdrawDelegatorRewardResponseAminoMsg): MsgWithdrawDelegatorRewardResponse {
+    return MsgWithdrawDelegatorRewardResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgWithdrawDelegatorRewardResponse): MsgWithdrawDelegatorRewardResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgWithdrawDelegatorRewardResponse",
+      value: MsgWithdrawDelegatorRewardResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgWithdrawDelegatorRewardResponseProtoMsg): MsgWithdrawDelegatorRewardResponse {
+    return MsgWithdrawDelegatorRewardResponse.decode(message.value);
+  },
+  toProto(message: MsgWithdrawDelegatorRewardResponse): Uint8Array {
+    return MsgWithdrawDelegatorRewardResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgWithdrawDelegatorRewardResponse): MsgWithdrawDelegatorRewardResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse",
+      value: MsgWithdrawDelegatorRewardResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgWithdrawValidatorCommission(): MsgWithdrawValidatorCommission {
+  return {
+    validatorAddress: ""
+  };
+}
+export const MsgWithdrawValidatorCommission = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+  encode(message: MsgWithdrawValidatorCommission, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.validatorAddress !== "") {
+      writer.uint32(10).string(message.validatorAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawValidatorCommission {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgWithdrawValidatorCommission();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.validatorAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgWithdrawValidatorCommission>): MsgWithdrawValidatorCommission {
+    const message = createBaseMsgWithdrawValidatorCommission();
+    message.validatorAddress = object.validatorAddress ?? "";
+    return message;
+  },
+  fromAmino(object: MsgWithdrawValidatorCommissionAmino): MsgWithdrawValidatorCommission {
+    const message = createBaseMsgWithdrawValidatorCommission();
+    if (object.validator_address !== undefined && object.validator_address !== null) {
+      message.validatorAddress = object.validator_address;
+    }
+    return message;
+  },
+  toAmino(message: MsgWithdrawValidatorCommission): MsgWithdrawValidatorCommissionAmino {
+    const obj: any = {};
+    obj.validator_address = message.validatorAddress === "" ? undefined : message.validatorAddress;
+    return obj;
+  },
+  fromAminoMsg(object: MsgWithdrawValidatorCommissionAminoMsg): MsgWithdrawValidatorCommission {
+    return MsgWithdrawValidatorCommission.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgWithdrawValidatorCommission): MsgWithdrawValidatorCommissionAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgWithdrawValidatorCommission",
+      value: MsgWithdrawValidatorCommission.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgWithdrawValidatorCommissionProtoMsg): MsgWithdrawValidatorCommission {
+    return MsgWithdrawValidatorCommission.decode(message.value);
+  },
+  toProto(message: MsgWithdrawValidatorCommission): Uint8Array {
+    return MsgWithdrawValidatorCommission.encode(message).finish();
+  },
+  toProtoMsg(message: MsgWithdrawValidatorCommission): MsgWithdrawValidatorCommissionProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission",
+      value: MsgWithdrawValidatorCommission.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgWithdrawValidatorCommissionResponse(): MsgWithdrawValidatorCommissionResponse {
+  return {};
+}
+export const MsgWithdrawValidatorCommissionResponse = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse",
+  encode(_: MsgWithdrawValidatorCommissionResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgWithdrawValidatorCommissionResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgWithdrawValidatorCommissionResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgWithdrawValidatorCommissionResponse>): MsgWithdrawValidatorCommissionResponse {
+    const message = createBaseMsgWithdrawValidatorCommissionResponse();
+    return message;
+  },
+  fromAmino(_: MsgWithdrawValidatorCommissionResponseAmino): MsgWithdrawValidatorCommissionResponse {
+    const message = createBaseMsgWithdrawValidatorCommissionResponse();
+    return message;
+  },
+  toAmino(_: MsgWithdrawValidatorCommissionResponse): MsgWithdrawValidatorCommissionResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgWithdrawValidatorCommissionResponseAminoMsg): MsgWithdrawValidatorCommissionResponse {
+    return MsgWithdrawValidatorCommissionResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgWithdrawValidatorCommissionResponse): MsgWithdrawValidatorCommissionResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgWithdrawValidatorCommissionResponse",
+      value: MsgWithdrawValidatorCommissionResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgWithdrawValidatorCommissionResponseProtoMsg): MsgWithdrawValidatorCommissionResponse {
+    return MsgWithdrawValidatorCommissionResponse.decode(message.value);
+  },
+  toProto(message: MsgWithdrawValidatorCommissionResponse): Uint8Array {
+    return MsgWithdrawValidatorCommissionResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgWithdrawValidatorCommissionResponse): MsgWithdrawValidatorCommissionResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse",
+      value: MsgWithdrawValidatorCommissionResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgFundCommunityPool(): MsgFundCommunityPool {
+  return {
+    amount: [],
+    depositor: ""
+  };
+}
+export const MsgFundCommunityPool = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+  encode(message: MsgFundCommunityPool, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.amount) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.depositor !== "") {
+      writer.uint32(18).string(message.depositor);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgFundCommunityPool {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgFundCommunityPool();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.amount.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.depositor = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgFundCommunityPool>): MsgFundCommunityPool {
+    const message = createBaseMsgFundCommunityPool();
+    message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
+    message.depositor = object.depositor ?? "";
+    return message;
+  },
+  fromAmino(object: MsgFundCommunityPoolAmino): MsgFundCommunityPool {
+    const message = createBaseMsgFundCommunityPool();
+    message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
+    if (object.depositor !== undefined && object.depositor !== null) {
+      message.depositor = object.depositor;
+    }
+    return message;
+  },
+  toAmino(message: MsgFundCommunityPool): MsgFundCommunityPoolAmino {
+    const obj: any = {};
+    if (message.amount) {
+      obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.amount = message.amount;
+    }
+    obj.depositor = message.depositor === "" ? undefined : message.depositor;
+    return obj;
+  },
+  fromAminoMsg(object: MsgFundCommunityPoolAminoMsg): MsgFundCommunityPool {
+    return MsgFundCommunityPool.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgFundCommunityPool): MsgFundCommunityPoolAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgFundCommunityPool",
+      value: MsgFundCommunityPool.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgFundCommunityPoolProtoMsg): MsgFundCommunityPool {
+    return MsgFundCommunityPool.decode(message.value);
+  },
+  toProto(message: MsgFundCommunityPool): Uint8Array {
+    return MsgFundCommunityPool.encode(message).finish();
+  },
+  toProtoMsg(message: MsgFundCommunityPool): MsgFundCommunityPoolProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPool",
+      value: MsgFundCommunityPool.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgFundCommunityPoolResponse(): MsgFundCommunityPoolResponse {
+  return {};
+}
+export const MsgFundCommunityPoolResponse = {
+  typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse",
+  encode(_: MsgFundCommunityPoolResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgFundCommunityPoolResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgFundCommunityPoolResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgFundCommunityPoolResponse>): MsgFundCommunityPoolResponse {
+    const message = createBaseMsgFundCommunityPoolResponse();
+    return message;
+  },
+  fromAmino(_: MsgFundCommunityPoolResponseAmino): MsgFundCommunityPoolResponse {
+    const message = createBaseMsgFundCommunityPoolResponse();
+    return message;
+  },
+  toAmino(_: MsgFundCommunityPoolResponse): MsgFundCommunityPoolResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgFundCommunityPoolResponseAminoMsg): MsgFundCommunityPoolResponse {
+    return MsgFundCommunityPoolResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgFundCommunityPoolResponse): MsgFundCommunityPoolResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgFundCommunityPoolResponse",
+      value: MsgFundCommunityPoolResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgFundCommunityPoolResponseProtoMsg): MsgFundCommunityPoolResponse {
+    return MsgFundCommunityPoolResponse.decode(message.value);
+  },
+  toProto(message: MsgFundCommunityPoolResponse): Uint8Array {
+    return MsgFundCommunityPoolResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgFundCommunityPoolResponse): MsgFundCommunityPoolResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse",
+      value: MsgFundCommunityPoolResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/evidence/v1beta1/evidence.ts

@@ -0,0 +1,146 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+/**
+ * Equivocation implements the Evidence interface and defines evidence of double
+ * signing misbehavior.
+ */
+export interface Equivocation {
+  height: bigint;
+  time: Date;
+  power: bigint;
+  consensusAddress: string;
+}
+export interface EquivocationProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.Equivocation";
+  value: Uint8Array;
+}
+/**
+ * Equivocation implements the Evidence interface and defines evidence of double
+ * signing misbehavior.
+ */
+export interface EquivocationAmino {
+  height?: string;
+  time?: string;
+  power?: string;
+  consensus_address?: string;
+}
+export interface EquivocationAminoMsg {
+  type: "cosmos-sdk/Equivocation";
+  value: EquivocationAmino;
+}
+/**
+ * Equivocation implements the Evidence interface and defines evidence of double
+ * signing misbehavior.
+ */
+export interface EquivocationSDKType {
+  height: bigint;
+  time: Date;
+  power: bigint;
+  consensus_address: string;
+}
+function createBaseEquivocation(): Equivocation {
+  return {
+    height: BigInt(0),
+    time: new Date(),
+    power: BigInt(0),
+    consensusAddress: ""
+  };
+}
+export const Equivocation = {
+  typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+  encode(message: Equivocation, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.height !== BigInt(0)) {
+      writer.uint32(8).int64(message.height);
+    }
+    if (message.time !== undefined) {
+      Timestamp.encode(toTimestamp(message.time), writer.uint32(18).fork()).ldelim();
+    }
+    if (message.power !== BigInt(0)) {
+      writer.uint32(24).int64(message.power);
+    }
+    if (message.consensusAddress !== "") {
+      writer.uint32(34).string(message.consensusAddress);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Equivocation {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEquivocation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.int64();
+          break;
+        case 2:
+          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.power = reader.int64();
+          break;
+        case 4:
+          message.consensusAddress = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Equivocation>): Equivocation {
+    const message = createBaseEquivocation();
+    message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+    message.time = object.time ?? undefined;
+    message.power = object.power !== undefined && object.power !== null ? BigInt(object.power.toString()) : BigInt(0);
+    message.consensusAddress = object.consensusAddress ?? "";
+    return message;
+  },
+  fromAmino(object: EquivocationAmino): Equivocation {
+    const message = createBaseEquivocation();
+    if (object.height !== undefined && object.height !== null) {
+      message.height = BigInt(object.height);
+    }
+    if (object.time !== undefined && object.time !== null) {
+      message.time = fromTimestamp(Timestamp.fromAmino(object.time));
+    }
+    if (object.power !== undefined && object.power !== null) {
+      message.power = BigInt(object.power);
+    }
+    if (object.consensus_address !== undefined && object.consensus_address !== null) {
+      message.consensusAddress = object.consensus_address;
+    }
+    return message;
+  },
+  toAmino(message: Equivocation): EquivocationAmino {
+    const obj: any = {};
+    obj.height = message.height !== BigInt(0) ? message.height.toString() : undefined;
+    obj.time = message.time ? Timestamp.toAmino(toTimestamp(message.time)) : undefined;
+    obj.power = message.power !== BigInt(0) ? message.power.toString() : undefined;
+    obj.consensus_address = message.consensusAddress === "" ? undefined : message.consensusAddress;
+    return obj;
+  },
+  fromAminoMsg(object: EquivocationAminoMsg): Equivocation {
+    return Equivocation.fromAmino(object.value);
+  },
+  toAminoMsg(message: Equivocation): EquivocationAminoMsg {
+    return {
+      type: "cosmos-sdk/Equivocation",
+      value: Equivocation.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: EquivocationProtoMsg): Equivocation {
+    return Equivocation.decode(message.value);
+  },
+  toProto(message: Equivocation): Uint8Array {
+    return Equivocation.encode(message).finish();
+  },
+  toProtoMsg(message: Equivocation): EquivocationProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.Equivocation",
+      value: Equivocation.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/evidence/v1beta1/genesis.ts

@@ -0,0 +1,95 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the evidence module's genesis state. */
+export interface GenesisState {
+  /** evidence defines all the evidence at genesis. */
+  evidence: Any[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the evidence module's genesis state. */
+export interface GenesisStateAmino {
+  /** evidence defines all the evidence at genesis. */
+  evidence?: AnyAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the evidence module's genesis state. */
+export interface GenesisStateSDKType {
+  evidence: AnySDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    evidence: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.evidence.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.evidence) {
+      Any.encode(v!, 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.evidence.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.evidence = object.evidence?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.evidence = object.evidence?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.evidence) {
+      obj.evidence = message.evidence.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.evidence = message.evidence;
+    }
+    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.evidence.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/evidence/v1beta1/query.lcd.ts

@@ -0,0 +1,33 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryEvidenceRequest, QueryEvidenceResponseSDKType, QueryAllEvidenceRequest, QueryAllEvidenceResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.evidence = this.evidence.bind(this);
+    this.allEvidence = this.allEvidence.bind(this);
+  }
+  /* Evidence queries evidence based on evidence hash. */
+  async evidence(params: QueryEvidenceRequest): Promise<QueryEvidenceResponseSDKType> {
+    const endpoint = `cosmos/evidence/v1beta1/evidence/${params.evidenceHash}`;
+    return await this.req.get<QueryEvidenceResponseSDKType>(endpoint);
+  }
+  /* AllEvidence queries all evidence. */
+  async allEvidence(params: QueryAllEvidenceRequest = {
+    pagination: undefined
+  }): Promise<QueryAllEvidenceResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/evidence/v1beta1/evidence`;
+    return await this.req.get<QueryAllEvidenceResponseSDKType>(endpoint, options);
+  }
+}

src/codegen/cosmos/evidence/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,43 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryEvidenceRequest, QueryEvidenceResponse, QueryAllEvidenceRequest, QueryAllEvidenceResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Evidence queries evidence based on evidence hash. */
+  evidence(request: QueryEvidenceRequest): Promise<QueryEvidenceResponse>;
+  /** AllEvidence queries all evidence. */
+  allEvidence(request?: QueryAllEvidenceRequest): Promise<QueryAllEvidenceResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.evidence = this.evidence.bind(this);
+    this.allEvidence = this.allEvidence.bind(this);
+  }
+  evidence(request: QueryEvidenceRequest): Promise<QueryEvidenceResponse> {
+    const data = QueryEvidenceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Query", "Evidence", data);
+    return promise.then(data => QueryEvidenceResponse.decode(new BinaryReader(data)));
+  }
+  allEvidence(request: QueryAllEvidenceRequest = {
+    pagination: undefined
+  }): Promise<QueryAllEvidenceResponse> {
+    const data = QueryAllEvidenceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Query", "AllEvidence", data);
+    return promise.then(data => QueryAllEvidenceResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    evidence(request: QueryEvidenceRequest): Promise<QueryEvidenceResponse> {
+      return queryService.evidence(request);
+    },
+    allEvidence(request?: QueryAllEvidenceRequest): Promise<QueryAllEvidenceResponse> {
+      return queryService.allEvidence(request);
+    }
+  };
+};

src/codegen/cosmos/evidence/v1beta1/query.ts

@@ -0,0 +1,405 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequest {
+  /** evidence_hash defines the hash of the requested evidence. */
+  evidenceHash: Uint8Array;
+}
+export interface QueryEvidenceRequestProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceRequest";
+  value: Uint8Array;
+}
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequestAmino {
+  /** evidence_hash defines the hash of the requested evidence. */
+  evidence_hash?: string;
+}
+export interface QueryEvidenceRequestAminoMsg {
+  type: "cosmos-sdk/QueryEvidenceRequest";
+  value: QueryEvidenceRequestAmino;
+}
+/** QueryEvidenceRequest is the request type for the Query/Evidence RPC method. */
+export interface QueryEvidenceRequestSDKType {
+  evidence_hash: Uint8Array;
+}
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponse {
+  /** evidence returns the requested evidence. */
+  evidence?: Any;
+}
+export interface QueryEvidenceResponseProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceResponse";
+  value: Uint8Array;
+}
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponseAmino {
+  /** evidence returns the requested evidence. */
+  evidence?: AnyAmino;
+}
+export interface QueryEvidenceResponseAminoMsg {
+  type: "cosmos-sdk/QueryEvidenceResponse";
+  value: QueryEvidenceResponseAmino;
+}
+/** QueryEvidenceResponse is the response type for the Query/Evidence RPC method. */
+export interface QueryEvidenceResponseSDKType {
+  evidence?: AnySDKType;
+}
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequest {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryAllEvidenceRequestProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceRequest";
+  value: Uint8Array;
+}
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequestAmino {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryAllEvidenceRequestAminoMsg {
+  type: "cosmos-sdk/QueryAllEvidenceRequest";
+  value: QueryAllEvidenceRequestAmino;
+}
+/**
+ * QueryEvidenceRequest is the request type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceRequestSDKType {
+  pagination?: PageRequestSDKType;
+}
+/**
+ * QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceResponse {
+  /** evidence returns all evidences. */
+  evidence: Any[];
+  /** pagination defines the pagination in the response. */
+  pagination?: PageResponse;
+}
+export interface QueryAllEvidenceResponseProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceResponseAmino {
+  /** evidence returns all evidences. */
+  evidence?: AnyAmino[];
+  /** pagination defines the pagination in the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryAllEvidenceResponseAminoMsg {
+  type: "cosmos-sdk/QueryAllEvidenceResponse";
+  value: QueryAllEvidenceResponseAmino;
+}
+/**
+ * QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC
+ * method.
+ */
+export interface QueryAllEvidenceResponseSDKType {
+  evidence: AnySDKType[];
+  pagination?: PageResponseSDKType;
+}
+function createBaseQueryEvidenceRequest(): QueryEvidenceRequest {
+  return {
+    evidenceHash: new Uint8Array()
+  };
+}
+export const QueryEvidenceRequest = {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceRequest",
+  encode(message: QueryEvidenceRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.evidenceHash.length !== 0) {
+      writer.uint32(10).bytes(message.evidenceHash);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryEvidenceRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEvidenceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.evidenceHash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryEvidenceRequest>): QueryEvidenceRequest {
+    const message = createBaseQueryEvidenceRequest();
+    message.evidenceHash = object.evidenceHash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: QueryEvidenceRequestAmino): QueryEvidenceRequest {
+    const message = createBaseQueryEvidenceRequest();
+    if (object.evidence_hash !== undefined && object.evidence_hash !== null) {
+      message.evidenceHash = bytesFromBase64(object.evidence_hash);
+    }
+    return message;
+  },
+  toAmino(message: QueryEvidenceRequest): QueryEvidenceRequestAmino {
+    const obj: any = {};
+    obj.evidence_hash = message.evidenceHash ? base64FromBytes(message.evidenceHash) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryEvidenceRequestAminoMsg): QueryEvidenceRequest {
+    return QueryEvidenceRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryEvidenceRequest): QueryEvidenceRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryEvidenceRequest",
+      value: QueryEvidenceRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryEvidenceRequestProtoMsg): QueryEvidenceRequest {
+    return QueryEvidenceRequest.decode(message.value);
+  },
+  toProto(message: QueryEvidenceRequest): Uint8Array {
+    return QueryEvidenceRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryEvidenceRequest): QueryEvidenceRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceRequest",
+      value: QueryEvidenceRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryEvidenceResponse(): QueryEvidenceResponse {
+  return {
+    evidence: undefined
+  };
+}
+export const QueryEvidenceResponse = {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceResponse",
+  encode(message: QueryEvidenceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.evidence !== undefined) {
+      Any.encode(message.evidence, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryEvidenceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEvidenceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.evidence = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryEvidenceResponse>): QueryEvidenceResponse {
+    const message = createBaseQueryEvidenceResponse();
+    message.evidence = object.evidence !== undefined && object.evidence !== null ? Any.fromPartial(object.evidence) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryEvidenceResponseAmino): QueryEvidenceResponse {
+    const message = createBaseQueryEvidenceResponse();
+    if (object.evidence !== undefined && object.evidence !== null) {
+      message.evidence = Any.fromAmino(object.evidence);
+    }
+    return message;
+  },
+  toAmino(message: QueryEvidenceResponse): QueryEvidenceResponseAmino {
+    const obj: any = {};
+    obj.evidence = message.evidence ? Any.toAmino(message.evidence) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryEvidenceResponseAminoMsg): QueryEvidenceResponse {
+    return QueryEvidenceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryEvidenceResponse): QueryEvidenceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryEvidenceResponse",
+      value: QueryEvidenceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryEvidenceResponseProtoMsg): QueryEvidenceResponse {
+    return QueryEvidenceResponse.decode(message.value);
+  },
+  toProto(message: QueryEvidenceResponse): Uint8Array {
+    return QueryEvidenceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryEvidenceResponse): QueryEvidenceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.QueryEvidenceResponse",
+      value: QueryEvidenceResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllEvidenceRequest(): QueryAllEvidenceRequest {
+  return {
+    pagination: undefined
+  };
+}
+export const QueryAllEvidenceRequest = {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceRequest",
+  encode(message: QueryAllEvidenceRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllEvidenceRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllEvidenceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllEvidenceRequest>): QueryAllEvidenceRequest {
+    const message = createBaseQueryAllEvidenceRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllEvidenceRequestAmino): QueryAllEvidenceRequest {
+    const message = createBaseQueryAllEvidenceRequest();
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestAmino {
+    const obj: any = {};
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllEvidenceRequestAminoMsg): QueryAllEvidenceRequest {
+    return QueryAllEvidenceRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllEvidenceRequest",
+      value: QueryAllEvidenceRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllEvidenceRequestProtoMsg): QueryAllEvidenceRequest {
+    return QueryAllEvidenceRequest.decode(message.value);
+  },
+  toProto(message: QueryAllEvidenceRequest): Uint8Array {
+    return QueryAllEvidenceRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllEvidenceRequest): QueryAllEvidenceRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceRequest",
+      value: QueryAllEvidenceRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllEvidenceResponse(): QueryAllEvidenceResponse {
+  return {
+    evidence: [],
+    pagination: undefined
+  };
+}
+export const QueryAllEvidenceResponse = {
+  typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceResponse",
+  encode(message: QueryAllEvidenceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.evidence) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllEvidenceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllEvidenceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.evidence.push(Any.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllEvidenceResponse>): QueryAllEvidenceResponse {
+    const message = createBaseQueryAllEvidenceResponse();
+    message.evidence = object.evidence?.map(e => Any.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllEvidenceResponseAmino): QueryAllEvidenceResponse {
+    const message = createBaseQueryAllEvidenceResponse();
+    message.evidence = object.evidence?.map(e => Any.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseAmino {
+    const obj: any = {};
+    if (message.evidence) {
+      obj.evidence = message.evidence.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.evidence = message.evidence;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllEvidenceResponseAminoMsg): QueryAllEvidenceResponse {
+    return QueryAllEvidenceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllEvidenceResponse",
+      value: QueryAllEvidenceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllEvidenceResponseProtoMsg): QueryAllEvidenceResponse {
+    return QueryAllEvidenceResponse.decode(message.value);
+  },
+  toProto(message: QueryAllEvidenceResponse): Uint8Array {
+    return QueryAllEvidenceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllEvidenceResponse): QueryAllEvidenceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.QueryAllEvidenceResponse",
+      value: QueryAllEvidenceResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/evidence/v1beta1/tx.amino.ts

@@ -0,0 +1,8 @@
+import { MsgSubmitEvidence } from "./tx";
+export const AminoConverter = {
+  "/cosmos.evidence.v1beta1.MsgSubmitEvidence": {
+    aminoType: "cosmos-sdk/MsgSubmitEvidence",
+    toAmino: MsgSubmitEvidence.toAmino,
+    fromAmino: MsgSubmitEvidence.fromAmino
+  }
+};

src/codegen/cosmos/evidence/v1beta1/tx.registry.ts

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

src/codegen/cosmos/evidence/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,23 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgSubmitEvidence, MsgSubmitEvidenceResponse } from "./tx";
+/** Msg defines the evidence Msg service. */
+export interface Msg {
+  /**
+   * SubmitEvidence submits an arbitrary Evidence of misbehavior such as equivocation or
+   * counterfactual signing.
+   */
+  submitEvidence(request: MsgSubmitEvidence): Promise<MsgSubmitEvidenceResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.submitEvidence = this.submitEvidence.bind(this);
+  }
+  submitEvidence(request: MsgSubmitEvidence): Promise<MsgSubmitEvidenceResponse> {
+    const data = MsgSubmitEvidence.encode(request).finish();
+    const promise = this.rpc.request("cosmos.evidence.v1beta1.Msg", "SubmitEvidence", data);
+    return promise.then(data => MsgSubmitEvidenceResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/evidence/v1beta1/tx.ts

@@ -0,0 +1,207 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/**
+ * MsgSubmitEvidence represents a message that supports submitting arbitrary
+ * Evidence of misbehavior such as equivocation or counterfactual signing.
+ */
+export interface MsgSubmitEvidence {
+  submitter: string;
+  evidence?: Any;
+}
+export interface MsgSubmitEvidenceProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence";
+  value: Uint8Array;
+}
+/**
+ * MsgSubmitEvidence represents a message that supports submitting arbitrary
+ * Evidence of misbehavior such as equivocation or counterfactual signing.
+ */
+export interface MsgSubmitEvidenceAmino {
+  submitter?: string;
+  evidence?: AnyAmino;
+}
+export interface MsgSubmitEvidenceAminoMsg {
+  type: "cosmos-sdk/MsgSubmitEvidence";
+  value: MsgSubmitEvidenceAmino;
+}
+/**
+ * MsgSubmitEvidence represents a message that supports submitting arbitrary
+ * Evidence of misbehavior such as equivocation or counterfactual signing.
+ */
+export interface MsgSubmitEvidenceSDKType {
+  submitter: string;
+  evidence?: AnySDKType;
+}
+/** MsgSubmitEvidenceResponse defines the Msg/SubmitEvidence response type. */
+export interface MsgSubmitEvidenceResponse {
+  /** hash defines the hash of the evidence. */
+  hash: Uint8Array;
+}
+export interface MsgSubmitEvidenceResponseProtoMsg {
+  typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidenceResponse";
+  value: Uint8Array;
+}
+/** MsgSubmitEvidenceResponse defines the Msg/SubmitEvidence response type. */
+export interface MsgSubmitEvidenceResponseAmino {
+  /** hash defines the hash of the evidence. */
+  hash?: string;
+}
+export interface MsgSubmitEvidenceResponseAminoMsg {
+  type: "cosmos-sdk/MsgSubmitEvidenceResponse";
+  value: MsgSubmitEvidenceResponseAmino;
+}
+/** MsgSubmitEvidenceResponse defines the Msg/SubmitEvidence response type. */
+export interface MsgSubmitEvidenceResponseSDKType {
+  hash: Uint8Array;
+}
+function createBaseMsgSubmitEvidence(): MsgSubmitEvidence {
+  return {
+    submitter: "",
+    evidence: undefined
+  };
+}
+export const MsgSubmitEvidence = {
+  typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+  encode(message: MsgSubmitEvidence, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.submitter !== "") {
+      writer.uint32(10).string(message.submitter);
+    }
+    if (message.evidence !== undefined) {
+      Any.encode(message.evidence, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitEvidence {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitEvidence();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.submitter = reader.string();
+          break;
+        case 2:
+          message.evidence = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSubmitEvidence>): MsgSubmitEvidence {
+    const message = createBaseMsgSubmitEvidence();
+    message.submitter = object.submitter ?? "";
+    message.evidence = object.evidence !== undefined && object.evidence !== null ? Any.fromPartial(object.evidence) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgSubmitEvidenceAmino): MsgSubmitEvidence {
+    const message = createBaseMsgSubmitEvidence();
+    if (object.submitter !== undefined && object.submitter !== null) {
+      message.submitter = object.submitter;
+    }
+    if (object.evidence !== undefined && object.evidence !== null) {
+      message.evidence = Any.fromAmino(object.evidence);
+    }
+    return message;
+  },
+  toAmino(message: MsgSubmitEvidence): MsgSubmitEvidenceAmino {
+    const obj: any = {};
+    obj.submitter = message.submitter === "" ? undefined : message.submitter;
+    obj.evidence = message.evidence ? Any.toAmino(message.evidence) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgSubmitEvidenceAminoMsg): MsgSubmitEvidence {
+    return MsgSubmitEvidence.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSubmitEvidence): MsgSubmitEvidenceAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSubmitEvidence",
+      value: MsgSubmitEvidence.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSubmitEvidenceProtoMsg): MsgSubmitEvidence {
+    return MsgSubmitEvidence.decode(message.value);
+  },
+  toProto(message: MsgSubmitEvidence): Uint8Array {
+    return MsgSubmitEvidence.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSubmitEvidence): MsgSubmitEvidenceProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidence",
+      value: MsgSubmitEvidence.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgSubmitEvidenceResponse(): MsgSubmitEvidenceResponse {
+  return {
+    hash: new Uint8Array()
+  };
+}
+export const MsgSubmitEvidenceResponse = {
+  typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidenceResponse",
+  encode(message: MsgSubmitEvidenceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.hash.length !== 0) {
+      writer.uint32(34).bytes(message.hash);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitEvidenceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitEvidenceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 4:
+          message.hash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSubmitEvidenceResponse>): MsgSubmitEvidenceResponse {
+    const message = createBaseMsgSubmitEvidenceResponse();
+    message.hash = object.hash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: MsgSubmitEvidenceResponseAmino): MsgSubmitEvidenceResponse {
+    const message = createBaseMsgSubmitEvidenceResponse();
+    if (object.hash !== undefined && object.hash !== null) {
+      message.hash = bytesFromBase64(object.hash);
+    }
+    return message;
+  },
+  toAmino(message: MsgSubmitEvidenceResponse): MsgSubmitEvidenceResponseAmino {
+    const obj: any = {};
+    obj.hash = message.hash ? base64FromBytes(message.hash) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgSubmitEvidenceResponseAminoMsg): MsgSubmitEvidenceResponse {
+    return MsgSubmitEvidenceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSubmitEvidenceResponse): MsgSubmitEvidenceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSubmitEvidenceResponse",
+      value: MsgSubmitEvidenceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSubmitEvidenceResponseProtoMsg): MsgSubmitEvidenceResponse {
+    return MsgSubmitEvidenceResponse.decode(message.value);
+  },
+  toProto(message: MsgSubmitEvidenceResponse): Uint8Array {
+    return MsgSubmitEvidenceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSubmitEvidenceResponse): MsgSubmitEvidenceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.evidence.v1beta1.MsgSubmitEvidenceResponse",
+      value: MsgSubmitEvidenceResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/feegrant.ts

@@ -0,0 +1,560 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { Duration, DurationAmino, DurationSDKType } from "../../../google/protobuf/duration";
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+/**
+ * BasicAllowance implements Allowance with a one-time grant of tokens
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowance {
+  /**
+   * spend_limit specifies the maximum amount of tokens that can be spent
+   * by this allowance and will be updated as tokens are spent. If it is
+   * empty, there is no spend limit and any amount of coins can be spent.
+   */
+  spendLimit: Coin[];
+  /** expiration specifies an optional time when this allowance expires */
+  expiration?: Date;
+}
+export interface BasicAllowanceProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance";
+  value: Uint8Array;
+}
+/**
+ * BasicAllowance implements Allowance with a one-time grant of tokens
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowanceAmino {
+  /**
+   * spend_limit specifies the maximum amount of tokens that can be spent
+   * by this allowance and will be updated as tokens are spent. If it is
+   * empty, there is no spend limit and any amount of coins can be spent.
+   */
+  spend_limit?: CoinAmino[];
+  /** expiration specifies an optional time when this allowance expires */
+  expiration?: string;
+}
+export interface BasicAllowanceAminoMsg {
+  type: "cosmos-sdk/BasicAllowance";
+  value: BasicAllowanceAmino;
+}
+/**
+ * BasicAllowance implements Allowance with a one-time grant of tokens
+ * that optionally expires. The grantee can use up to SpendLimit to cover fees.
+ */
+export interface BasicAllowanceSDKType {
+  spend_limit: CoinSDKType[];
+  expiration?: Date;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowance {
+  /** basic specifies a struct of `BasicAllowance` */
+  basic: BasicAllowance;
+  /**
+   * period specifies the time duration in which period_spend_limit coins can
+   * be spent before that allowance is reset
+   */
+  period: Duration;
+  /**
+   * period_spend_limit specifies the maximum number of coins that can be spent
+   * in the period
+   */
+  periodSpendLimit: Coin[];
+  /** period_can_spend is the number of coins left to be spent before the period_reset time */
+  periodCanSpend: Coin[];
+  /**
+   * period_reset is the time at which this period resets and a new one begins,
+   * it is calculated from the start time of the first transaction after the
+   * last period ended
+   */
+  periodReset: Date;
+}
+export interface PeriodicAllowanceProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
+  value: Uint8Array;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowanceAmino {
+  /** basic specifies a struct of `BasicAllowance` */
+  basic?: BasicAllowanceAmino;
+  /**
+   * period specifies the time duration in which period_spend_limit coins can
+   * be spent before that allowance is reset
+   */
+  period?: DurationAmino;
+  /**
+   * period_spend_limit specifies the maximum number of coins that can be spent
+   * in the period
+   */
+  period_spend_limit?: CoinAmino[];
+  /** period_can_spend is the number of coins left to be spent before the period_reset time */
+  period_can_spend?: CoinAmino[];
+  /**
+   * period_reset is the time at which this period resets and a new one begins,
+   * it is calculated from the start time of the first transaction after the
+   * last period ended
+   */
+  period_reset?: string;
+}
+export interface PeriodicAllowanceAminoMsg {
+  type: "cosmos-sdk/PeriodicAllowance";
+  value: PeriodicAllowanceAmino;
+}
+/**
+ * PeriodicAllowance extends Allowance to allow for both a maximum cap,
+ * as well as a limit per time period.
+ */
+export interface PeriodicAllowanceSDKType {
+  basic: BasicAllowanceSDKType;
+  period: DurationSDKType;
+  period_spend_limit: CoinSDKType[];
+  period_can_spend: CoinSDKType[];
+  period_reset: Date;
+}
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowance {
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: Any;
+  /** allowed_messages are the messages for which the grantee has the access. */
+  allowedMessages: string[];
+}
+export interface AllowedMsgAllowanceProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
+  value: Uint8Array;
+}
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowanceAmino {
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: AnyAmino;
+  /** allowed_messages are the messages for which the grantee has the access. */
+  allowed_messages?: string[];
+}
+export interface AllowedMsgAllowanceAminoMsg {
+  type: "cosmos-sdk/AllowedMsgAllowance";
+  value: AllowedMsgAllowanceAmino;
+}
+/** AllowedMsgAllowance creates allowance only for specified message types. */
+export interface AllowedMsgAllowanceSDKType {
+  allowance?: AnySDKType;
+  allowed_messages: string[];
+}
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface Grant {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee: string;
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: Any;
+}
+export interface GrantProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.Grant";
+  value: Uint8Array;
+}
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface GrantAmino {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter?: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee?: string;
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: AnyAmino;
+}
+export interface GrantAminoMsg {
+  type: "cosmos-sdk/Grant";
+  value: GrantAmino;
+}
+/** Grant is stored in the KVStore to record a grant with full context */
+export interface GrantSDKType {
+  granter: string;
+  grantee: string;
+  allowance?: AnySDKType;
+}
+function createBaseBasicAllowance(): BasicAllowance {
+  return {
+    spendLimit: [],
+    expiration: undefined
+  };
+}
+export const BasicAllowance = {
+  typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
+  encode(message: BasicAllowance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.spendLimit) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.expiration !== undefined) {
+      Timestamp.encode(toTimestamp(message.expiration), writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): BasicAllowance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBasicAllowance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.spendLimit.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.expiration = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<BasicAllowance>): BasicAllowance {
+    const message = createBaseBasicAllowance();
+    message.spendLimit = object.spendLimit?.map(e => Coin.fromPartial(e)) || [];
+    message.expiration = object.expiration ?? undefined;
+    return message;
+  },
+  fromAmino(object: BasicAllowanceAmino): BasicAllowance {
+    const message = createBaseBasicAllowance();
+    message.spendLimit = object.spend_limit?.map(e => Coin.fromAmino(e)) || [];
+    if (object.expiration !== undefined && object.expiration !== null) {
+      message.expiration = fromTimestamp(Timestamp.fromAmino(object.expiration));
+    }
+    return message;
+  },
+  toAmino(message: BasicAllowance): BasicAllowanceAmino {
+    const obj: any = {};
+    if (message.spendLimit) {
+      obj.spend_limit = message.spendLimit.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.spend_limit = message.spendLimit;
+    }
+    obj.expiration = message.expiration ? Timestamp.toAmino(toTimestamp(message.expiration)) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: BasicAllowanceAminoMsg): BasicAllowance {
+    return BasicAllowance.fromAmino(object.value);
+  },
+  toAminoMsg(message: BasicAllowance): BasicAllowanceAminoMsg {
+    return {
+      type: "cosmos-sdk/BasicAllowance",
+      value: BasicAllowance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BasicAllowanceProtoMsg): BasicAllowance {
+    return BasicAllowance.decode(message.value);
+  },
+  toProto(message: BasicAllowance): Uint8Array {
+    return BasicAllowance.encode(message).finish();
+  },
+  toProtoMsg(message: BasicAllowance): BasicAllowanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.BasicAllowance",
+      value: BasicAllowance.encode(message).finish()
+    };
+  }
+};
+function createBasePeriodicAllowance(): PeriodicAllowance {
+  return {
+    basic: BasicAllowance.fromPartial({}),
+    period: Duration.fromPartial({}),
+    periodSpendLimit: [],
+    periodCanSpend: [],
+    periodReset: new Date()
+  };
+}
+export const PeriodicAllowance = {
+  typeUrl: "/cosmos.feegrant.v1beta1.PeriodicAllowance",
+  encode(message: PeriodicAllowance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.basic !== undefined) {
+      BasicAllowance.encode(message.basic, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.period !== undefined) {
+      Duration.encode(message.period, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.periodSpendLimit) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.periodCanSpend) {
+      Coin.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.periodReset !== undefined) {
+      Timestamp.encode(toTimestamp(message.periodReset), writer.uint32(42).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PeriodicAllowance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePeriodicAllowance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.basic = BasicAllowance.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.period = Duration.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.periodSpendLimit.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.periodCanSpend.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.periodReset = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PeriodicAllowance>): PeriodicAllowance {
+    const message = createBasePeriodicAllowance();
+    message.basic = object.basic !== undefined && object.basic !== null ? BasicAllowance.fromPartial(object.basic) : undefined;
+    message.period = object.period !== undefined && object.period !== null ? Duration.fromPartial(object.period) : undefined;
+    message.periodSpendLimit = object.periodSpendLimit?.map(e => Coin.fromPartial(e)) || [];
+    message.periodCanSpend = object.periodCanSpend?.map(e => Coin.fromPartial(e)) || [];
+    message.periodReset = object.periodReset ?? undefined;
+    return message;
+  },
+  fromAmino(object: PeriodicAllowanceAmino): PeriodicAllowance {
+    const message = createBasePeriodicAllowance();
+    if (object.basic !== undefined && object.basic !== null) {
+      message.basic = BasicAllowance.fromAmino(object.basic);
+    }
+    if (object.period !== undefined && object.period !== null) {
+      message.period = Duration.fromAmino(object.period);
+    }
+    message.periodSpendLimit = object.period_spend_limit?.map(e => Coin.fromAmino(e)) || [];
+    message.periodCanSpend = object.period_can_spend?.map(e => Coin.fromAmino(e)) || [];
+    if (object.period_reset !== undefined && object.period_reset !== null) {
+      message.periodReset = fromTimestamp(Timestamp.fromAmino(object.period_reset));
+    }
+    return message;
+  },
+  toAmino(message: PeriodicAllowance): PeriodicAllowanceAmino {
+    const obj: any = {};
+    obj.basic = message.basic ? BasicAllowance.toAmino(message.basic) : undefined;
+    obj.period = message.period ? Duration.toAmino(message.period) : undefined;
+    if (message.periodSpendLimit) {
+      obj.period_spend_limit = message.periodSpendLimit.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.period_spend_limit = message.periodSpendLimit;
+    }
+    if (message.periodCanSpend) {
+      obj.period_can_spend = message.periodCanSpend.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.period_can_spend = message.periodCanSpend;
+    }
+    obj.period_reset = message.periodReset ? Timestamp.toAmino(toTimestamp(message.periodReset)) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PeriodicAllowanceAminoMsg): PeriodicAllowance {
+    return PeriodicAllowance.fromAmino(object.value);
+  },
+  toAminoMsg(message: PeriodicAllowance): PeriodicAllowanceAminoMsg {
+    return {
+      type: "cosmos-sdk/PeriodicAllowance",
+      value: PeriodicAllowance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PeriodicAllowanceProtoMsg): PeriodicAllowance {
+    return PeriodicAllowance.decode(message.value);
+  },
+  toProto(message: PeriodicAllowance): Uint8Array {
+    return PeriodicAllowance.encode(message).finish();
+  },
+  toProtoMsg(message: PeriodicAllowance): PeriodicAllowanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.PeriodicAllowance",
+      value: PeriodicAllowance.encode(message).finish()
+    };
+  }
+};
+function createBaseAllowedMsgAllowance(): AllowedMsgAllowance {
+  return {
+    allowance: undefined,
+    allowedMessages: []
+  };
+}
+export const AllowedMsgAllowance = {
+  typeUrl: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance",
+  encode(message: AllowedMsgAllowance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.allowance !== undefined) {
+      Any.encode(message.allowance, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.allowedMessages) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): AllowedMsgAllowance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAllowedMsgAllowance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.allowance = Any.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.allowedMessages.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<AllowedMsgAllowance>): AllowedMsgAllowance {
+    const message = createBaseAllowedMsgAllowance();
+    message.allowance = object.allowance !== undefined && object.allowance !== null ? Any.fromPartial(object.allowance) : undefined;
+    message.allowedMessages = object.allowedMessages?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: AllowedMsgAllowanceAmino): AllowedMsgAllowance {
+    const message = createBaseAllowedMsgAllowance();
+    if (object.allowance !== undefined && object.allowance !== null) {
+      message.allowance = Any.fromAmino(object.allowance);
+    }
+    message.allowedMessages = object.allowed_messages?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: AllowedMsgAllowance): AllowedMsgAllowanceAmino {
+    const obj: any = {};
+    obj.allowance = message.allowance ? Any.toAmino(message.allowance) : undefined;
+    if (message.allowedMessages) {
+      obj.allowed_messages = message.allowedMessages.map(e => e);
+    } else {
+      obj.allowed_messages = message.allowedMessages;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: AllowedMsgAllowanceAminoMsg): AllowedMsgAllowance {
+    return AllowedMsgAllowance.fromAmino(object.value);
+  },
+  toAminoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceAminoMsg {
+    return {
+      type: "cosmos-sdk/AllowedMsgAllowance",
+      value: AllowedMsgAllowance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: AllowedMsgAllowanceProtoMsg): AllowedMsgAllowance {
+    return AllowedMsgAllowance.decode(message.value);
+  },
+  toProto(message: AllowedMsgAllowance): Uint8Array {
+    return AllowedMsgAllowance.encode(message).finish();
+  },
+  toProtoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance",
+      value: AllowedMsgAllowance.encode(message).finish()
+    };
+  }
+};
+function createBaseGrant(): Grant {
+  return {
+    granter: "",
+    grantee: "",
+    allowance: undefined
+  };
+}
+export const Grant = {
+  typeUrl: "/cosmos.feegrant.v1beta1.Grant",
+  encode(message: Grant, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.allowance !== undefined) {
+      Any.encode(message.allowance, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Grant {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGrant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.allowance = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Grant>): Grant {
+    const message = createBaseGrant();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.allowance = object.allowance !== undefined && object.allowance !== null ? Any.fromPartial(object.allowance) : undefined;
+    return message;
+  },
+  fromAmino(object: GrantAmino): Grant {
+    const message = createBaseGrant();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.allowance !== undefined && object.allowance !== null) {
+      message.allowance = Any.fromAmino(object.allowance);
+    }
+    return message;
+  },
+  toAmino(message: Grant): GrantAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.allowance = message.allowance ? Any.toAmino(message.allowance) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GrantAminoMsg): Grant {
+    return Grant.fromAmino(object.value);
+  },
+  toAminoMsg(message: Grant): GrantAminoMsg {
+    return {
+      type: "cosmos-sdk/Grant",
+      value: Grant.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GrantProtoMsg): Grant {
+    return Grant.decode(message.value);
+  },
+  toProto(message: Grant): Uint8Array {
+    return Grant.encode(message).finish();
+  },
+  toProtoMsg(message: Grant): GrantProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.Grant",
+      value: Grant.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/genesis.ts

@@ -0,0 +1,93 @@
+import { Grant, GrantAmino, GrantSDKType } from "./feegrant";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState contains a set of fee allowances, persisted from the store */
+export interface GenesisState {
+  allowances: Grant[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState contains a set of fee allowances, persisted from the store */
+export interface GenesisStateAmino {
+  allowances?: GrantAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState contains a set of fee allowances, persisted from the store */
+export interface GenesisStateSDKType {
+  allowances: GrantSDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    allowances: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.feegrant.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.allowances) {
+      Grant.encode(v!, 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.allowances.push(Grant.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.allowances = object.allowances?.map(e => Grant.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.allowances = object.allowances?.map(e => Grant.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.allowances) {
+      obj.allowances = message.allowances.map(e => e ? Grant.toAmino(e) : undefined);
+    } else {
+      obj.allowances = message.allowances;
+    }
+    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.feegrant.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/query.lcd.ts

@@ -0,0 +1,44 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAllowanceRequest, QueryAllowanceResponseSDKType, QueryAllowancesRequest, QueryAllowancesResponseSDKType, QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.allowance = this.allowance.bind(this);
+    this.allowances = this.allowances.bind(this);
+    this.allowancesByGranter = this.allowancesByGranter.bind(this);
+  }
+  /* Allowance returns fee granted to the grantee by the granter. */
+  async allowance(params: QueryAllowanceRequest): Promise<QueryAllowanceResponseSDKType> {
+    const endpoint = `cosmos/feegrant/v1beta1/allowance/${params.granter}/${params.grantee}`;
+    return await this.req.get<QueryAllowanceResponseSDKType>(endpoint);
+  }
+  /* Allowances returns all the grants for address. */
+  async allowances(params: QueryAllowancesRequest): Promise<QueryAllowancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/feegrant/v1beta1/allowances/${params.grantee}`;
+    return await this.req.get<QueryAllowancesResponseSDKType>(endpoint, options);
+  }
+  /* AllowancesByGranter returns all the grants given by an address
+   Since v0.46 */
+  async allowancesByGranter(params: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/feegrant/v1beta1/issued/${params.granter}`;
+    return await this.req.get<QueryAllowancesByGranterResponseSDKType>(endpoint, options);
+  }
+}

src/codegen/cosmos/feegrant/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,55 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAllowanceRequest, QueryAllowanceResponse, QueryAllowancesRequest, QueryAllowancesResponse, QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Allowance returns fee granted to the grantee by the granter. */
+  allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse>;
+  /** Allowances returns all the grants for address. */
+  allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse>;
+  /**
+   * AllowancesByGranter returns all the grants given by an address
+   * Since v0.46
+   */
+  allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.allowance = this.allowance.bind(this);
+    this.allowances = this.allowances.bind(this);
+    this.allowancesByGranter = this.allowancesByGranter.bind(this);
+  }
+  allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse> {
+    const data = QueryAllowanceRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.feegrant.v1beta1.Query", "Allowance", data);
+    return promise.then(data => QueryAllowanceResponse.decode(new BinaryReader(data)));
+  }
+  allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse> {
+    const data = QueryAllowancesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.feegrant.v1beta1.Query", "Allowances", data);
+    return promise.then(data => QueryAllowancesResponse.decode(new BinaryReader(data)));
+  }
+  allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse> {
+    const data = QueryAllowancesByGranterRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.feegrant.v1beta1.Query", "AllowancesByGranter", data);
+    return promise.then(data => QueryAllowancesByGranterResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse> {
+      return queryService.allowance(request);
+    },
+    allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse> {
+      return queryService.allowances(request);
+    },
+    allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse> {
+      return queryService.allowancesByGranter(request);
+    }
+  };
+};

src/codegen/cosmos/feegrant/v1beta1/query.ts

@@ -0,0 +1,634 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { Grant, GrantAmino, GrantSDKType } from "./feegrant";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** QueryAllowanceRequest is the request type for the Query/Allowance RPC method. */
+export interface QueryAllowanceRequest {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee: string;
+}
+export interface QueryAllowanceRequestProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceRequest";
+  value: Uint8Array;
+}
+/** QueryAllowanceRequest is the request type for the Query/Allowance RPC method. */
+export interface QueryAllowanceRequestAmino {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter?: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee?: string;
+}
+export interface QueryAllowanceRequestAminoMsg {
+  type: "cosmos-sdk/QueryAllowanceRequest";
+  value: QueryAllowanceRequestAmino;
+}
+/** QueryAllowanceRequest is the request type for the Query/Allowance RPC method. */
+export interface QueryAllowanceRequestSDKType {
+  granter: string;
+  grantee: string;
+}
+/** QueryAllowanceResponse is the response type for the Query/Allowance RPC method. */
+export interface QueryAllowanceResponse {
+  /** allowance is a allowance granted for grantee by granter. */
+  allowance?: Grant;
+}
+export interface QueryAllowanceResponseProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceResponse";
+  value: Uint8Array;
+}
+/** QueryAllowanceResponse is the response type for the Query/Allowance RPC method. */
+export interface QueryAllowanceResponseAmino {
+  /** allowance is a allowance granted for grantee by granter. */
+  allowance?: GrantAmino;
+}
+export interface QueryAllowanceResponseAminoMsg {
+  type: "cosmos-sdk/QueryAllowanceResponse";
+  value: QueryAllowanceResponseAmino;
+}
+/** QueryAllowanceResponse is the response type for the Query/Allowance RPC method. */
+export interface QueryAllowanceResponseSDKType {
+  allowance?: GrantSDKType;
+}
+/** QueryAllowancesRequest is the request type for the Query/Allowances RPC method. */
+export interface QueryAllowancesRequest {
+  grantee: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryAllowancesRequestProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesRequest";
+  value: Uint8Array;
+}
+/** QueryAllowancesRequest is the request type for the Query/Allowances RPC method. */
+export interface QueryAllowancesRequestAmino {
+  grantee?: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryAllowancesRequestAminoMsg {
+  type: "cosmos-sdk/QueryAllowancesRequest";
+  value: QueryAllowancesRequestAmino;
+}
+/** QueryAllowancesRequest is the request type for the Query/Allowances RPC method. */
+export interface QueryAllowancesRequestSDKType {
+  grantee: string;
+  pagination?: PageRequestSDKType;
+}
+/** QueryAllowancesResponse is the response type for the Query/Allowances RPC method. */
+export interface QueryAllowancesResponse {
+  /** allowances are allowance's granted for grantee by granter. */
+  allowances: Grant[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponse;
+}
+export interface QueryAllowancesResponseProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesResponse";
+  value: Uint8Array;
+}
+/** QueryAllowancesResponse is the response type for the Query/Allowances RPC method. */
+export interface QueryAllowancesResponseAmino {
+  /** allowances are allowance's granted for grantee by granter. */
+  allowances?: GrantAmino[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryAllowancesResponseAminoMsg {
+  type: "cosmos-sdk/QueryAllowancesResponse";
+  value: QueryAllowancesResponseAmino;
+}
+/** QueryAllowancesResponse is the response type for the Query/Allowances RPC method. */
+export interface QueryAllowancesResponseSDKType {
+  allowances: GrantSDKType[];
+  pagination?: PageResponseSDKType;
+}
+/** QueryAllowancesByGranterRequest is the request type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterRequest {
+  granter: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequest;
+}
+export interface QueryAllowancesByGranterRequestProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterRequest";
+  value: Uint8Array;
+}
+/** QueryAllowancesByGranterRequest is the request type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterRequestAmino {
+  granter?: string;
+  /** pagination defines an pagination for the request. */
+  pagination?: PageRequestAmino;
+}
+export interface QueryAllowancesByGranterRequestAminoMsg {
+  type: "cosmos-sdk/QueryAllowancesByGranterRequest";
+  value: QueryAllowancesByGranterRequestAmino;
+}
+/** QueryAllowancesByGranterRequest is the request type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterRequestSDKType {
+  granter: string;
+  pagination?: PageRequestSDKType;
+}
+/** QueryAllowancesByGranterResponse is the response type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterResponse {
+  /** allowances that have been issued by the granter. */
+  allowances: Grant[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponse;
+}
+export interface QueryAllowancesByGranterResponseProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterResponse";
+  value: Uint8Array;
+}
+/** QueryAllowancesByGranterResponse is the response type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterResponseAmino {
+  /** allowances that have been issued by the granter. */
+  allowances?: GrantAmino[];
+  /** pagination defines an pagination for the response. */
+  pagination?: PageResponseAmino;
+}
+export interface QueryAllowancesByGranterResponseAminoMsg {
+  type: "cosmos-sdk/QueryAllowancesByGranterResponse";
+  value: QueryAllowancesByGranterResponseAmino;
+}
+/** QueryAllowancesByGranterResponse is the response type for the Query/AllowancesByGranter RPC method. */
+export interface QueryAllowancesByGranterResponseSDKType {
+  allowances: GrantSDKType[];
+  pagination?: PageResponseSDKType;
+}
+function createBaseQueryAllowanceRequest(): QueryAllowanceRequest {
+  return {
+    granter: "",
+    grantee: ""
+  };
+}
+export const QueryAllowanceRequest = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceRequest",
+  encode(message: QueryAllowanceRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowanceRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowanceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowanceRequest>): QueryAllowanceRequest {
+    const message = createBaseQueryAllowanceRequest();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: QueryAllowanceRequestAmino): QueryAllowanceRequest {
+    const message = createBaseQueryAllowanceRequest();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowanceRequest): QueryAllowanceRequestAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowanceRequestAminoMsg): QueryAllowanceRequest {
+    return QueryAllowanceRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowanceRequest): QueryAllowanceRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowanceRequest",
+      value: QueryAllowanceRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowanceRequestProtoMsg): QueryAllowanceRequest {
+    return QueryAllowanceRequest.decode(message.value);
+  },
+  toProto(message: QueryAllowanceRequest): Uint8Array {
+    return QueryAllowanceRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowanceRequest): QueryAllowanceRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceRequest",
+      value: QueryAllowanceRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllowanceResponse(): QueryAllowanceResponse {
+  return {
+    allowance: undefined
+  };
+}
+export const QueryAllowanceResponse = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceResponse",
+  encode(message: QueryAllowanceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.allowance !== undefined) {
+      Grant.encode(message.allowance, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowanceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowanceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.allowance = Grant.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowanceResponse>): QueryAllowanceResponse {
+    const message = createBaseQueryAllowanceResponse();
+    message.allowance = object.allowance !== undefined && object.allowance !== null ? Grant.fromPartial(object.allowance) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllowanceResponseAmino): QueryAllowanceResponse {
+    const message = createBaseQueryAllowanceResponse();
+    if (object.allowance !== undefined && object.allowance !== null) {
+      message.allowance = Grant.fromAmino(object.allowance);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowanceResponse): QueryAllowanceResponseAmino {
+    const obj: any = {};
+    obj.allowance = message.allowance ? Grant.toAmino(message.allowance) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowanceResponseAminoMsg): QueryAllowanceResponse {
+    return QueryAllowanceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowanceResponse): QueryAllowanceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowanceResponse",
+      value: QueryAllowanceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowanceResponseProtoMsg): QueryAllowanceResponse {
+    return QueryAllowanceResponse.decode(message.value);
+  },
+  toProto(message: QueryAllowanceResponse): Uint8Array {
+    return QueryAllowanceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowanceResponse): QueryAllowanceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowanceResponse",
+      value: QueryAllowanceResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllowancesRequest(): QueryAllowancesRequest {
+  return {
+    grantee: "",
+    pagination: undefined
+  };
+}
+export const QueryAllowancesRequest = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesRequest",
+  encode(message: QueryAllowancesRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.grantee !== "") {
+      writer.uint32(10).string(message.grantee);
+    }
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowancesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowancesRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.grantee = reader.string();
+          break;
+        case 2:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowancesRequest>): QueryAllowancesRequest {
+    const message = createBaseQueryAllowancesRequest();
+    message.grantee = object.grantee ?? "";
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllowancesRequestAmino): QueryAllowancesRequest {
+    const message = createBaseQueryAllowancesRequest();
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowancesRequest): QueryAllowancesRequestAmino {
+    const obj: any = {};
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowancesRequestAminoMsg): QueryAllowancesRequest {
+    return QueryAllowancesRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowancesRequest): QueryAllowancesRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowancesRequest",
+      value: QueryAllowancesRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowancesRequestProtoMsg): QueryAllowancesRequest {
+    return QueryAllowancesRequest.decode(message.value);
+  },
+  toProto(message: QueryAllowancesRequest): Uint8Array {
+    return QueryAllowancesRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowancesRequest): QueryAllowancesRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesRequest",
+      value: QueryAllowancesRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllowancesResponse(): QueryAllowancesResponse {
+  return {
+    allowances: [],
+    pagination: undefined
+  };
+}
+export const QueryAllowancesResponse = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesResponse",
+  encode(message: QueryAllowancesResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.allowances) {
+      Grant.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowancesResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowancesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.allowances.push(Grant.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowancesResponse>): QueryAllowancesResponse {
+    const message = createBaseQueryAllowancesResponse();
+    message.allowances = object.allowances?.map(e => Grant.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllowancesResponseAmino): QueryAllowancesResponse {
+    const message = createBaseQueryAllowancesResponse();
+    message.allowances = object.allowances?.map(e => Grant.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowancesResponse): QueryAllowancesResponseAmino {
+    const obj: any = {};
+    if (message.allowances) {
+      obj.allowances = message.allowances.map(e => e ? Grant.toAmino(e) : undefined);
+    } else {
+      obj.allowances = message.allowances;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowancesResponseAminoMsg): QueryAllowancesResponse {
+    return QueryAllowancesResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowancesResponse): QueryAllowancesResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowancesResponse",
+      value: QueryAllowancesResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowancesResponseProtoMsg): QueryAllowancesResponse {
+    return QueryAllowancesResponse.decode(message.value);
+  },
+  toProto(message: QueryAllowancesResponse): Uint8Array {
+    return QueryAllowancesResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowancesResponse): QueryAllowancesResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesResponse",
+      value: QueryAllowancesResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllowancesByGranterRequest(): QueryAllowancesByGranterRequest {
+  return {
+    granter: "",
+    pagination: undefined
+  };
+}
+export const QueryAllowancesByGranterRequest = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterRequest",
+  encode(message: QueryAllowancesByGranterRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowancesByGranterRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowancesByGranterRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowancesByGranterRequest>): QueryAllowancesByGranterRequest {
+    const message = createBaseQueryAllowancesByGranterRequest();
+    message.granter = object.granter ?? "";
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllowancesByGranterRequestAmino): QueryAllowancesByGranterRequest {
+    const message = createBaseQueryAllowancesByGranterRequest();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageRequest.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowancesByGranterRequestAminoMsg): QueryAllowancesByGranterRequest {
+    return QueryAllowancesByGranterRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowancesByGranterRequest",
+      value: QueryAllowancesByGranterRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowancesByGranterRequestProtoMsg): QueryAllowancesByGranterRequest {
+    return QueryAllowancesByGranterRequest.decode(message.value);
+  },
+  toProto(message: QueryAllowancesByGranterRequest): Uint8Array {
+    return QueryAllowancesByGranterRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterRequest",
+      value: QueryAllowancesByGranterRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAllowancesByGranterResponse(): QueryAllowancesByGranterResponse {
+  return {
+    allowances: [],
+    pagination: undefined
+  };
+}
+export const QueryAllowancesByGranterResponse = {
+  typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterResponse",
+  encode(message: QueryAllowancesByGranterResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.allowances) {
+      Grant.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllowancesByGranterResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAllowancesByGranterResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.allowances.push(Grant.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAllowancesByGranterResponse>): QueryAllowancesByGranterResponse {
+    const message = createBaseQueryAllowancesByGranterResponse();
+    message.allowances = object.allowances?.map(e => Grant.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryAllowancesByGranterResponseAmino): QueryAllowancesByGranterResponse {
+    const message = createBaseQueryAllowancesByGranterResponse();
+    message.allowances = object.allowances?.map(e => Grant.fromAmino(e)) || [];
+    if (object.pagination !== undefined && object.pagination !== null) {
+      message.pagination = PageResponse.fromAmino(object.pagination);
+    }
+    return message;
+  },
+  toAmino(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseAmino {
+    const obj: any = {};
+    if (message.allowances) {
+      obj.allowances = message.allowances.map(e => e ? Grant.toAmino(e) : undefined);
+    } else {
+      obj.allowances = message.allowances;
+    }
+    obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAllowancesByGranterResponseAminoMsg): QueryAllowancesByGranterResponse {
+    return QueryAllowancesByGranterResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAllowancesByGranterResponse",
+      value: QueryAllowancesByGranterResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAllowancesByGranterResponseProtoMsg): QueryAllowancesByGranterResponse {
+    return QueryAllowancesByGranterResponse.decode(message.value);
+  },
+  toProto(message: QueryAllowancesByGranterResponse): Uint8Array {
+    return QueryAllowancesByGranterResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.QueryAllowancesByGranterResponse",
+      value: QueryAllowancesByGranterResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/tx.amino.ts

@@ -0,0 +1,13 @@
+import { MsgGrantAllowance, MsgRevokeAllowance } from "./tx";
+export const AminoConverter = {
+  "/cosmos.feegrant.v1beta1.MsgGrantAllowance": {
+    aminoType: "cosmos-sdk/MsgGrantAllowance",
+    toAmino: MsgGrantAllowance.toAmino,
+    fromAmino: MsgGrantAllowance.fromAmino
+  },
+  "/cosmos.feegrant.v1beta1.MsgRevokeAllowance": {
+    aminoType: "cosmos-sdk/MsgRevokeAllowance",
+    toAmino: MsgRevokeAllowance.toAmino,
+    fromAmino: MsgRevokeAllowance.fromAmino
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/tx.registry.ts

@@ -0,0 +1,52 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgGrantAllowance, MsgRevokeAllowance } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.feegrant.v1beta1.MsgGrantAllowance", MsgGrantAllowance], ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", MsgRevokeAllowance]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    grantAllowance(value: MsgGrantAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+        value: MsgGrantAllowance.encode(value).finish()
+      };
+    },
+    revokeAllowance(value: MsgRevokeAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+        value: MsgRevokeAllowance.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    grantAllowance(value: MsgGrantAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+        value
+      };
+    },
+    revokeAllowance(value: MsgRevokeAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    grantAllowance(value: MsgGrantAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+        value: MsgGrantAllowance.fromPartial(value)
+      };
+    },
+    revokeAllowance(value: MsgRevokeAllowance) {
+      return {
+        typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+        value: MsgRevokeAllowance.fromPartial(value)
+      };
+    }
+  }
+};

src/codegen/cosmos/feegrant/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,34 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgGrantAllowance, MsgGrantAllowanceResponse, MsgRevokeAllowance, MsgRevokeAllowanceResponse } from "./tx";
+/** Msg defines the feegrant msg service. */
+export interface Msg {
+  /**
+   * GrantAllowance grants fee allowance to the grantee on the granter's
+   * account with the provided expiration time.
+   */
+  grantAllowance(request: MsgGrantAllowance): Promise<MsgGrantAllowanceResponse>;
+  /**
+   * RevokeAllowance revokes any fee allowance of granter's account that
+   * has been granted to the grantee.
+   */
+  revokeAllowance(request: MsgRevokeAllowance): Promise<MsgRevokeAllowanceResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.grantAllowance = this.grantAllowance.bind(this);
+    this.revokeAllowance = this.revokeAllowance.bind(this);
+  }
+  grantAllowance(request: MsgGrantAllowance): Promise<MsgGrantAllowanceResponse> {
+    const data = MsgGrantAllowance.encode(request).finish();
+    const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "GrantAllowance", data);
+    return promise.then(data => MsgGrantAllowanceResponse.decode(new BinaryReader(data)));
+  }
+  revokeAllowance(request: MsgRevokeAllowance): Promise<MsgRevokeAllowanceResponse> {
+    const data = MsgRevokeAllowance.encode(request).finish();
+    const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "RevokeAllowance", data);
+    return promise.then(data => MsgRevokeAllowanceResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/feegrant/v1beta1/tx.ts

@@ -0,0 +1,384 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * MsgGrantAllowance adds permission for Grantee to spend up to Allowance
+ * of fees from the account of Granter.
+ */
+export interface MsgGrantAllowance {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee: string;
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: Any;
+}
+export interface MsgGrantAllowanceProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance";
+  value: Uint8Array;
+}
+/**
+ * MsgGrantAllowance adds permission for Grantee to spend up to Allowance
+ * of fees from the account of Granter.
+ */
+export interface MsgGrantAllowanceAmino {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter?: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee?: string;
+  /** allowance can be any of basic and filtered fee allowance. */
+  allowance?: AnyAmino;
+}
+export interface MsgGrantAllowanceAminoMsg {
+  type: "cosmos-sdk/MsgGrantAllowance";
+  value: MsgGrantAllowanceAmino;
+}
+/**
+ * MsgGrantAllowance adds permission for Grantee to spend up to Allowance
+ * of fees from the account of Granter.
+ */
+export interface MsgGrantAllowanceSDKType {
+  granter: string;
+  grantee: string;
+  allowance?: AnySDKType;
+}
+/** MsgGrantAllowanceResponse defines the Msg/GrantAllowanceResponse response type. */
+export interface MsgGrantAllowanceResponse {}
+export interface MsgGrantAllowanceResponseProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowanceResponse";
+  value: Uint8Array;
+}
+/** MsgGrantAllowanceResponse defines the Msg/GrantAllowanceResponse response type. */
+export interface MsgGrantAllowanceResponseAmino {}
+export interface MsgGrantAllowanceResponseAminoMsg {
+  type: "cosmos-sdk/MsgGrantAllowanceResponse";
+  value: MsgGrantAllowanceResponseAmino;
+}
+/** MsgGrantAllowanceResponse defines the Msg/GrantAllowanceResponse response type. */
+export interface MsgGrantAllowanceResponseSDKType {}
+/** MsgRevokeAllowance removes any existing Allowance from Granter to Grantee. */
+export interface MsgRevokeAllowance {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee: string;
+}
+export interface MsgRevokeAllowanceProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance";
+  value: Uint8Array;
+}
+/** MsgRevokeAllowance removes any existing Allowance from Granter to Grantee. */
+export interface MsgRevokeAllowanceAmino {
+  /** granter is the address of the user granting an allowance of their funds. */
+  granter?: string;
+  /** grantee is the address of the user being granted an allowance of another user's funds. */
+  grantee?: string;
+}
+export interface MsgRevokeAllowanceAminoMsg {
+  type: "cosmos-sdk/MsgRevokeAllowance";
+  value: MsgRevokeAllowanceAmino;
+}
+/** MsgRevokeAllowance removes any existing Allowance from Granter to Grantee. */
+export interface MsgRevokeAllowanceSDKType {
+  granter: string;
+  grantee: string;
+}
+/** MsgRevokeAllowanceResponse defines the Msg/RevokeAllowanceResponse response type. */
+export interface MsgRevokeAllowanceResponse {}
+export interface MsgRevokeAllowanceResponseProtoMsg {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowanceResponse";
+  value: Uint8Array;
+}
+/** MsgRevokeAllowanceResponse defines the Msg/RevokeAllowanceResponse response type. */
+export interface MsgRevokeAllowanceResponseAmino {}
+export interface MsgRevokeAllowanceResponseAminoMsg {
+  type: "cosmos-sdk/MsgRevokeAllowanceResponse";
+  value: MsgRevokeAllowanceResponseAmino;
+}
+/** MsgRevokeAllowanceResponse defines the Msg/RevokeAllowanceResponse response type. */
+export interface MsgRevokeAllowanceResponseSDKType {}
+function createBaseMsgGrantAllowance(): MsgGrantAllowance {
+  return {
+    granter: "",
+    grantee: "",
+    allowance: undefined
+  };
+}
+export const MsgGrantAllowance = {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+  encode(message: MsgGrantAllowance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    if (message.allowance !== undefined) {
+      Any.encode(message.allowance, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgGrantAllowance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrantAllowance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        case 3:
+          message.allowance = Any.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgGrantAllowance>): MsgGrantAllowance {
+    const message = createBaseMsgGrantAllowance();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    message.allowance = object.allowance !== undefined && object.allowance !== null ? Any.fromPartial(object.allowance) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgGrantAllowanceAmino): MsgGrantAllowance {
+    const message = createBaseMsgGrantAllowance();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    if (object.allowance !== undefined && object.allowance !== null) {
+      message.allowance = Any.fromAmino(object.allowance);
+    }
+    return message;
+  },
+  toAmino(message: MsgGrantAllowance): MsgGrantAllowanceAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    obj.allowance = message.allowance ? Any.toAmino(message.allowance) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgGrantAllowanceAminoMsg): MsgGrantAllowance {
+    return MsgGrantAllowance.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgGrantAllowance): MsgGrantAllowanceAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgGrantAllowance",
+      value: MsgGrantAllowance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgGrantAllowanceProtoMsg): MsgGrantAllowance {
+    return MsgGrantAllowance.decode(message.value);
+  },
+  toProto(message: MsgGrantAllowance): Uint8Array {
+    return MsgGrantAllowance.encode(message).finish();
+  },
+  toProtoMsg(message: MsgGrantAllowance): MsgGrantAllowanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance",
+      value: MsgGrantAllowance.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgGrantAllowanceResponse(): MsgGrantAllowanceResponse {
+  return {};
+}
+export const MsgGrantAllowanceResponse = {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowanceResponse",
+  encode(_: MsgGrantAllowanceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgGrantAllowanceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgGrantAllowanceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgGrantAllowanceResponse>): MsgGrantAllowanceResponse {
+    const message = createBaseMsgGrantAllowanceResponse();
+    return message;
+  },
+  fromAmino(_: MsgGrantAllowanceResponseAmino): MsgGrantAllowanceResponse {
+    const message = createBaseMsgGrantAllowanceResponse();
+    return message;
+  },
+  toAmino(_: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgGrantAllowanceResponseAminoMsg): MsgGrantAllowanceResponse {
+    return MsgGrantAllowanceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgGrantAllowanceResponse",
+      value: MsgGrantAllowanceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgGrantAllowanceResponseProtoMsg): MsgGrantAllowanceResponse {
+    return MsgGrantAllowanceResponse.decode(message.value);
+  },
+  toProto(message: MsgGrantAllowanceResponse): Uint8Array {
+    return MsgGrantAllowanceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowanceResponse",
+      value: MsgGrantAllowanceResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgRevokeAllowance(): MsgRevokeAllowance {
+  return {
+    granter: "",
+    grantee: ""
+  };
+}
+export const MsgRevokeAllowance = {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+  encode(message: MsgRevokeAllowance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.granter !== "") {
+      writer.uint32(10).string(message.granter);
+    }
+    if (message.grantee !== "") {
+      writer.uint32(18).string(message.grantee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeAllowance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevokeAllowance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.granter = reader.string();
+          break;
+        case 2:
+          message.grantee = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgRevokeAllowance>): MsgRevokeAllowance {
+    const message = createBaseMsgRevokeAllowance();
+    message.granter = object.granter ?? "";
+    message.grantee = object.grantee ?? "";
+    return message;
+  },
+  fromAmino(object: MsgRevokeAllowanceAmino): MsgRevokeAllowance {
+    const message = createBaseMsgRevokeAllowance();
+    if (object.granter !== undefined && object.granter !== null) {
+      message.granter = object.granter;
+    }
+    if (object.grantee !== undefined && object.grantee !== null) {
+      message.grantee = object.grantee;
+    }
+    return message;
+  },
+  toAmino(message: MsgRevokeAllowance): MsgRevokeAllowanceAmino {
+    const obj: any = {};
+    obj.granter = message.granter === "" ? undefined : message.granter;
+    obj.grantee = message.grantee === "" ? undefined : message.grantee;
+    return obj;
+  },
+  fromAminoMsg(object: MsgRevokeAllowanceAminoMsg): MsgRevokeAllowance {
+    return MsgRevokeAllowance.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgRevokeAllowance",
+      value: MsgRevokeAllowance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgRevokeAllowanceProtoMsg): MsgRevokeAllowance {
+    return MsgRevokeAllowance.decode(message.value);
+  },
+  toProto(message: MsgRevokeAllowance): Uint8Array {
+    return MsgRevokeAllowance.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance",
+      value: MsgRevokeAllowance.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgRevokeAllowanceResponse(): MsgRevokeAllowanceResponse {
+  return {};
+}
+export const MsgRevokeAllowanceResponse = {
+  typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowanceResponse",
+  encode(_: MsgRevokeAllowanceResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeAllowanceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRevokeAllowanceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgRevokeAllowanceResponse>): MsgRevokeAllowanceResponse {
+    const message = createBaseMsgRevokeAllowanceResponse();
+    return message;
+  },
+  fromAmino(_: MsgRevokeAllowanceResponseAmino): MsgRevokeAllowanceResponse {
+    const message = createBaseMsgRevokeAllowanceResponse();
+    return message;
+  },
+  toAmino(_: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgRevokeAllowanceResponseAminoMsg): MsgRevokeAllowanceResponse {
+    return MsgRevokeAllowanceResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgRevokeAllowanceResponse",
+      value: MsgRevokeAllowanceResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgRevokeAllowanceResponseProtoMsg): MsgRevokeAllowanceResponse {
+    return MsgRevokeAllowanceResponse.decode(message.value);
+  },
+  toProto(message: MsgRevokeAllowanceResponse): Uint8Array {
+    return MsgRevokeAllowanceResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowanceResponse",
+      value: MsgRevokeAllowanceResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/genutil/v1beta1/genesis.ts

@@ -0,0 +1,95 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/** GenesisState defines the raw genesis transaction in JSON. */
+export interface GenesisState {
+  /** gen_txs defines the genesis transactions. */
+  genTxs: Uint8Array[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.genutil.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the raw genesis transaction in JSON. */
+export interface GenesisStateAmino {
+  /** gen_txs defines the genesis transactions. */
+  gen_txs: string[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the raw genesis transaction in JSON. */
+export interface GenesisStateSDKType {
+  gen_txs: Uint8Array[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    genTxs: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.genutil.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.genTxs) {
+      writer.uint32(10).bytes(v!);
+    }
+    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.genTxs.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.genTxs = object.genTxs?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.genTxs = object.gen_txs?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.genTxs) {
+      obj.gen_txs = message.genTxs.map(e => base64FromBytes(e));
+    } else {
+      obj.gen_txs = message.genTxs;
+    }
+    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.genutil.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/gov/v1beta1/genesis.ts

@@ -0,0 +1,201 @@
+import { Deposit, DepositAmino, DepositSDKType, Vote, VoteAmino, VoteSDKType, Proposal, ProposalAmino, ProposalSDKType, DepositParams, DepositParamsAmino, DepositParamsSDKType, VotingParams, VotingParamsAmino, VotingParamsSDKType, TallyParams, TallyParamsAmino, TallyParamsSDKType } from "./gov";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the gov module's genesis state. */
+export interface GenesisState {
+  /** starting_proposal_id is the ID of the starting proposal. */
+  startingProposalId: bigint;
+  /** deposits defines all the deposits present at genesis. */
+  deposits: Deposit[];
+  /** votes defines all the votes present at genesis. */
+  votes: Vote[];
+  /** proposals defines all the proposals present at genesis. */
+  proposals: Proposal[];
+  /** params defines all the paramaters of related to deposit. */
+  depositParams: DepositParams;
+  /** params defines all the paramaters of related to voting. */
+  votingParams: VotingParams;
+  /** params defines all the paramaters of related to tally. */
+  tallyParams: TallyParams;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the gov module's genesis state. */
+export interface GenesisStateAmino {
+  /** starting_proposal_id is the ID of the starting proposal. */
+  starting_proposal_id?: string;
+  /** deposits defines all the deposits present at genesis. */
+  deposits?: DepositAmino[];
+  /** votes defines all the votes present at genesis. */
+  votes?: VoteAmino[];
+  /** proposals defines all the proposals present at genesis. */
+  proposals?: ProposalAmino[];
+  /** params defines all the paramaters of related to deposit. */
+  deposit_params?: DepositParamsAmino;
+  /** params defines all the paramaters of related to voting. */
+  voting_params?: VotingParamsAmino;
+  /** params defines all the paramaters of related to tally. */
+  tally_params?: TallyParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the gov module's genesis state. */
+export interface GenesisStateSDKType {
+  starting_proposal_id: bigint;
+  deposits: DepositSDKType[];
+  votes: VoteSDKType[];
+  proposals: ProposalSDKType[];
+  deposit_params: DepositParamsSDKType;
+  voting_params: VotingParamsSDKType;
+  tally_params: TallyParamsSDKType;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    startingProposalId: BigInt(0),
+    deposits: [],
+    votes: [],
+    proposals: [],
+    depositParams: DepositParams.fromPartial({}),
+    votingParams: VotingParams.fromPartial({}),
+    tallyParams: TallyParams.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.gov.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.startingProposalId !== BigInt(0)) {
+      writer.uint32(8).uint64(message.startingProposalId);
+    }
+    for (const v of message.deposits) {
+      Deposit.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.votes) {
+      Vote.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.proposals) {
+      Proposal.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.depositParams !== undefined) {
+      DepositParams.encode(message.depositParams, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.votingParams !== undefined) {
+      VotingParams.encode(message.votingParams, writer.uint32(50).fork()).ldelim();
+    }
+    if (message.tallyParams !== undefined) {
+      TallyParams.encode(message.tallyParams, writer.uint32(58).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.startingProposalId = reader.uint64();
+          break;
+        case 2:
+          message.deposits.push(Deposit.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.votes.push(Vote.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.proposals.push(Proposal.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.depositParams = DepositParams.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.votingParams = VotingParams.decode(reader, reader.uint32());
+          break;
+        case 7:
+          message.tallyParams = TallyParams.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.startingProposalId = object.startingProposalId !== undefined && object.startingProposalId !== null ? BigInt(object.startingProposalId.toString()) : BigInt(0);
+    message.deposits = object.deposits?.map(e => Deposit.fromPartial(e)) || [];
+    message.votes = object.votes?.map(e => Vote.fromPartial(e)) || [];
+    message.proposals = object.proposals?.map(e => Proposal.fromPartial(e)) || [];
+    message.depositParams = object.depositParams !== undefined && object.depositParams !== null ? DepositParams.fromPartial(object.depositParams) : undefined;
+    message.votingParams = object.votingParams !== undefined && object.votingParams !== null ? VotingParams.fromPartial(object.votingParams) : undefined;
+    message.tallyParams = object.tallyParams !== undefined && object.tallyParams !== null ? TallyParams.fromPartial(object.tallyParams) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.starting_proposal_id !== undefined && object.starting_proposal_id !== null) {
+      message.startingProposalId = BigInt(object.starting_proposal_id);
+    }
+    message.deposits = object.deposits?.map(e => Deposit.fromAmino(e)) || [];
+    message.votes = object.votes?.map(e => Vote.fromAmino(e)) || [];
+    message.proposals = object.proposals?.map(e => Proposal.fromAmino(e)) || [];
+    if (object.deposit_params !== undefined && object.deposit_params !== null) {
+      message.depositParams = DepositParams.fromAmino(object.deposit_params);
+    }
+    if (object.voting_params !== undefined && object.voting_params !== null) {
+      message.votingParams = VotingParams.fromAmino(object.voting_params);
+    }
+    if (object.tally_params !== undefined && object.tally_params !== null) {
+      message.tallyParams = TallyParams.fromAmino(object.tally_params);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.starting_proposal_id = message.startingProposalId !== BigInt(0) ? message.startingProposalId.toString() : undefined;
+    if (message.deposits) {
+      obj.deposits = message.deposits.map(e => e ? Deposit.toAmino(e) : undefined);
+    } else {
+      obj.deposits = message.deposits;
+    }
+    if (message.votes) {
+      obj.votes = message.votes.map(e => e ? Vote.toAmino(e) : undefined);
+    } else {
+      obj.votes = message.votes;
+    }
+    if (message.proposals) {
+      obj.proposals = message.proposals.map(e => e ? Proposal.toAmino(e) : undefined);
+    } else {
+      obj.proposals = message.proposals;
+    }
+    obj.deposit_params = message.depositParams ? DepositParams.toAmino(message.depositParams) : undefined;
+    obj.voting_params = message.votingParams ? VotingParams.toAmino(message.votingParams) : undefined;
+    obj.tally_params = message.tallyParams ? TallyParams.toAmino(message.tallyParams) : undefined;
+    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.gov.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/gov/v1beta1/query.lcd.ts

@@ -0,0 +1,88 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryProposalRequest, QueryProposalResponseSDKType, QueryProposalsRequest, QueryProposalsResponseSDKType, QueryVoteRequest, QueryVoteResponseSDKType, QueryVotesRequest, QueryVotesResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDepositRequest, QueryDepositResponseSDKType, QueryDepositsRequest, QueryDepositsResponseSDKType, QueryTallyResultRequest, QueryTallyResultResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.proposal = this.proposal.bind(this);
+    this.proposals = this.proposals.bind(this);
+    this.vote = this.vote.bind(this);
+    this.votes = this.votes.bind(this);
+    this.params = this.params.bind(this);
+    this.deposit = this.deposit.bind(this);
+    this.deposits = this.deposits.bind(this);
+    this.tallyResult = this.tallyResult.bind(this);
+  }
+  /* Proposal queries proposal details based on ProposalID. */
+  async proposal(params: QueryProposalRequest): Promise<QueryProposalResponseSDKType> {
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}`;
+    return await this.req.get<QueryProposalResponseSDKType>(endpoint);
+  }
+  /* Proposals queries all proposals based on given status. */
+  async proposals(params: QueryProposalsRequest): Promise<QueryProposalsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.proposalStatus !== "undefined") {
+      options.params.proposal_status = params.proposalStatus;
+    }
+    if (typeof params?.voter !== "undefined") {
+      options.params.voter = params.voter;
+    }
+    if (typeof params?.depositor !== "undefined") {
+      options.params.depositor = params.depositor;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/gov/v1beta1/proposals`;
+    return await this.req.get<QueryProposalsResponseSDKType>(endpoint, options);
+  }
+  /* Vote queries voted information based on proposalID, voterAddr. */
+  async vote(params: QueryVoteRequest): Promise<QueryVoteResponseSDKType> {
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}/votes/${params.voter}`;
+    return await this.req.get<QueryVoteResponseSDKType>(endpoint);
+  }
+  /* Votes queries votes of a given proposal. */
+  async votes(params: QueryVotesRequest): Promise<QueryVotesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}/votes`;
+    return await this.req.get<QueryVotesResponseSDKType>(endpoint, options);
+  }
+  /* Params queries all parameters of the gov module. */
+  async params(params: QueryParamsRequest): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/gov/v1beta1/params/${params.paramsType}`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* Deposit queries single deposit information based proposalID, depositAddr. */
+  async deposit(params: QueryDepositRequest): Promise<QueryDepositResponseSDKType> {
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}/deposits/${params.depositor}`;
+    return await this.req.get<QueryDepositResponseSDKType>(endpoint);
+  }
+  /* Deposits queries all deposits of a single proposal. */
+  async deposits(params: QueryDepositsRequest): Promise<QueryDepositsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}/deposits`;
+    return await this.req.get<QueryDepositsResponseSDKType>(endpoint, options);
+  }
+  /* TallyResult queries the tally of a proposal vote. */
+  async tallyResult(params: QueryTallyResultRequest): Promise<QueryTallyResultResponseSDKType> {
+    const endpoint = `cosmos/gov/v1beta1/proposals/${params.proposalId}/tally`;
+    return await this.req.get<QueryTallyResultResponseSDKType>(endpoint);
+  }
+}

src/codegen/cosmos/gov/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,107 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryProposalRequest, QueryProposalResponse, QueryProposalsRequest, QueryProposalsResponse, QueryVoteRequest, QueryVoteResponse, QueryVotesRequest, QueryVotesResponse, QueryParamsRequest, QueryParamsResponse, QueryDepositRequest, QueryDepositResponse, QueryDepositsRequest, QueryDepositsResponse, QueryTallyResultRequest, QueryTallyResultResponse } from "./query";
+/** Query defines the gRPC querier service for gov module */
+export interface Query {
+  /** Proposal queries proposal details based on ProposalID. */
+  proposal(request: QueryProposalRequest): Promise<QueryProposalResponse>;
+  /** Proposals queries all proposals based on given status. */
+  proposals(request: QueryProposalsRequest): Promise<QueryProposalsResponse>;
+  /** Vote queries voted information based on proposalID, voterAddr. */
+  vote(request: QueryVoteRequest): Promise<QueryVoteResponse>;
+  /** Votes queries votes of a given proposal. */
+  votes(request: QueryVotesRequest): Promise<QueryVotesResponse>;
+  /** Params queries all parameters of the gov module. */
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Deposit queries single deposit information based proposalID, depositAddr. */
+  deposit(request: QueryDepositRequest): Promise<QueryDepositResponse>;
+  /** Deposits queries all deposits of a single proposal. */
+  deposits(request: QueryDepositsRequest): Promise<QueryDepositsResponse>;
+  /** TallyResult queries the tally of a proposal vote. */
+  tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.proposal = this.proposal.bind(this);
+    this.proposals = this.proposals.bind(this);
+    this.vote = this.vote.bind(this);
+    this.votes = this.votes.bind(this);
+    this.params = this.params.bind(this);
+    this.deposit = this.deposit.bind(this);
+    this.deposits = this.deposits.bind(this);
+    this.tallyResult = this.tallyResult.bind(this);
+  }
+  proposal(request: QueryProposalRequest): Promise<QueryProposalResponse> {
+    const data = QueryProposalRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Proposal", data);
+    return promise.then(data => QueryProposalResponse.decode(new BinaryReader(data)));
+  }
+  proposals(request: QueryProposalsRequest): Promise<QueryProposalsResponse> {
+    const data = QueryProposalsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Proposals", data);
+    return promise.then(data => QueryProposalsResponse.decode(new BinaryReader(data)));
+  }
+  vote(request: QueryVoteRequest): Promise<QueryVoteResponse> {
+    const data = QueryVoteRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Vote", data);
+    return promise.then(data => QueryVoteResponse.decode(new BinaryReader(data)));
+  }
+  votes(request: QueryVotesRequest): Promise<QueryVotesResponse> {
+    const data = QueryVotesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Votes", data);
+    return promise.then(data => QueryVotesResponse.decode(new BinaryReader(data)));
+  }
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  deposit(request: QueryDepositRequest): Promise<QueryDepositResponse> {
+    const data = QueryDepositRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Deposit", data);
+    return promise.then(data => QueryDepositResponse.decode(new BinaryReader(data)));
+  }
+  deposits(request: QueryDepositsRequest): Promise<QueryDepositsResponse> {
+    const data = QueryDepositsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "Deposits", data);
+    return promise.then(data => QueryDepositsResponse.decode(new BinaryReader(data)));
+  }
+  tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse> {
+    const data = QueryTallyResultRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Query", "TallyResult", data);
+    return promise.then(data => QueryTallyResultResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    proposal(request: QueryProposalRequest): Promise<QueryProposalResponse> {
+      return queryService.proposal(request);
+    },
+    proposals(request: QueryProposalsRequest): Promise<QueryProposalsResponse> {
+      return queryService.proposals(request);
+    },
+    vote(request: QueryVoteRequest): Promise<QueryVoteResponse> {
+      return queryService.vote(request);
+    },
+    votes(request: QueryVotesRequest): Promise<QueryVotesResponse> {
+      return queryService.votes(request);
+    },
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    deposit(request: QueryDepositRequest): Promise<QueryDepositResponse> {
+      return queryService.deposit(request);
+    },
+    deposits(request: QueryDepositsRequest): Promise<QueryDepositsResponse> {
+      return queryService.deposits(request);
+    },
+    tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse> {
+      return queryService.tallyResult(request);
+    }
+  };
+};

src/codegen/cosmos/gov/v1beta1/tx.amino.ts

@@ -0,0 +1,23 @@
+import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
+export const AminoConverter = {
+  "/cosmos.gov.v1beta1.MsgSubmitProposal": {
+    aminoType: "cosmos-sdk/MsgSubmitProposal",
+    toAmino: MsgSubmitProposal.toAmino,
+    fromAmino: MsgSubmitProposal.fromAmino
+  },
+  "/cosmos.gov.v1beta1.MsgVote": {
+    aminoType: "cosmos-sdk/MsgVote",
+    toAmino: MsgVote.toAmino,
+    fromAmino: MsgVote.fromAmino
+  },
+  "/cosmos.gov.v1beta1.MsgVoteWeighted": {
+    aminoType: "cosmos-sdk/MsgVoteWeighted",
+    toAmino: MsgVoteWeighted.toAmino,
+    fromAmino: MsgVoteWeighted.fromAmino
+  },
+  "/cosmos.gov.v1beta1.MsgDeposit": {
+    aminoType: "cosmos-sdk/MsgDeposit",
+    toAmino: MsgDeposit.toAmino,
+    fromAmino: MsgDeposit.fromAmino
+  }
+};

src/codegen/cosmos/gov/v1beta1/tx.registry.ts

@@ -0,0 +1,88 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
+export const registry: ReadonlyArray<[string, GeneratedType]> = [["/cosmos.gov.v1beta1.MsgSubmitProposal", MsgSubmitProposal], ["/cosmos.gov.v1beta1.MsgVote", MsgVote], ["/cosmos.gov.v1beta1.MsgVoteWeighted", MsgVoteWeighted], ["/cosmos.gov.v1beta1.MsgDeposit", MsgDeposit]];
+export const load = (protoRegistry: Registry) => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    submitProposal(value: MsgSubmitProposal) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
+        value: MsgSubmitProposal.encode(value).finish()
+      };
+    },
+    vote(value: MsgVote) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVote",
+        value: MsgVote.encode(value).finish()
+      };
+    },
+    voteWeighted(value: MsgVoteWeighted) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
+        value: MsgVoteWeighted.encode(value).finish()
+      };
+    },
+    deposit(value: MsgDeposit) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
+        value: MsgDeposit.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    submitProposal(value: MsgSubmitProposal) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
+        value
+      };
+    },
+    vote(value: MsgVote) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVote",
+        value
+      };
+    },
+    voteWeighted(value: MsgVoteWeighted) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
+        value
+      };
+    },
+    deposit(value: MsgDeposit) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    submitProposal(value: MsgSubmitProposal) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
+        value: MsgSubmitProposal.fromPartial(value)
+      };
+    },
+    vote(value: MsgVote) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVote",
+        value: MsgVote.fromPartial(value)
+      };
+    },
+    voteWeighted(value: MsgVoteWeighted) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
+        value: MsgVoteWeighted.fromPartial(value)
+      };
+    },
+    deposit(value: MsgDeposit) {
+      return {
+        typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
+        value: MsgDeposit.fromPartial(value)
+      };
+    }
+  }
+};

src/codegen/cosmos/gov/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,48 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { MsgSubmitProposal, MsgSubmitProposalResponse, MsgVote, MsgVoteResponse, MsgVoteWeighted, MsgVoteWeightedResponse, MsgDeposit, MsgDepositResponse } from "./tx";
+/** Msg defines the bank Msg service. */
+export interface Msg {
+  /** SubmitProposal defines a method to create new proposal given a content. */
+  submitProposal(request: MsgSubmitProposal): Promise<MsgSubmitProposalResponse>;
+  /** Vote defines a method to add a vote on a specific proposal. */
+  vote(request: MsgVote): Promise<MsgVoteResponse>;
+  /**
+   * VoteWeighted defines a method to add a weighted vote on a specific proposal.
+   * 
+   * Since: cosmos-sdk 0.43
+   */
+  voteWeighted(request: MsgVoteWeighted): Promise<MsgVoteWeightedResponse>;
+  /** Deposit defines a method to add deposit on a specific proposal. */
+  deposit(request: MsgDeposit): Promise<MsgDepositResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.submitProposal = this.submitProposal.bind(this);
+    this.vote = this.vote.bind(this);
+    this.voteWeighted = this.voteWeighted.bind(this);
+    this.deposit = this.deposit.bind(this);
+  }
+  submitProposal(request: MsgSubmitProposal): Promise<MsgSubmitProposalResponse> {
+    const data = MsgSubmitProposal.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "SubmitProposal", data);
+    return promise.then(data => MsgSubmitProposalResponse.decode(new BinaryReader(data)));
+  }
+  vote(request: MsgVote): Promise<MsgVoteResponse> {
+    const data = MsgVote.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "Vote", data);
+    return promise.then(data => MsgVoteResponse.decode(new BinaryReader(data)));
+  }
+  voteWeighted(request: MsgVoteWeighted): Promise<MsgVoteWeightedResponse> {
+    const data = MsgVoteWeighted.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "VoteWeighted", data);
+    return promise.then(data => MsgVoteWeightedResponse.decode(new BinaryReader(data)));
+  }
+  deposit(request: MsgDeposit): Promise<MsgDepositResponse> {
+    const data = MsgDeposit.encode(request).finish();
+    const promise = this.rpc.request("cosmos.gov.v1beta1.Msg", "Deposit", data);
+    return promise.then(data => MsgDepositResponse.decode(new BinaryReader(data)));
+  }
+}

src/codegen/cosmos/gov/v1beta1/tx.ts

@@ -0,0 +1,818 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { VoteOption, WeightedVoteOption, WeightedVoteOptionAmino, WeightedVoteOptionSDKType } from "./gov";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary
+ * proposal Content.
+ */
+export interface MsgSubmitProposal {
+  content?: Any;
+  initialDeposit: Coin[];
+  proposer: string;
+}
+export interface MsgSubmitProposalProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal";
+  value: Uint8Array;
+}
+/**
+ * MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary
+ * proposal Content.
+ */
+export interface MsgSubmitProposalAmino {
+  content?: AnyAmino;
+  initial_deposit?: CoinAmino[];
+  proposer?: string;
+}
+export interface MsgSubmitProposalAminoMsg {
+  type: "cosmos-sdk/MsgSubmitProposal";
+  value: MsgSubmitProposalAmino;
+}
+/**
+ * MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary
+ * proposal Content.
+ */
+export interface MsgSubmitProposalSDKType {
+  content?: AnySDKType;
+  initial_deposit: CoinSDKType[];
+  proposer: string;
+}
+/** MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. */
+export interface MsgSubmitProposalResponse {
+  proposalId: bigint;
+}
+export interface MsgSubmitProposalResponseProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposalResponse";
+  value: Uint8Array;
+}
+/** MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. */
+export interface MsgSubmitProposalResponseAmino {
+  proposal_id: string;
+}
+export interface MsgSubmitProposalResponseAminoMsg {
+  type: "cosmos-sdk/MsgSubmitProposalResponse";
+  value: MsgSubmitProposalResponseAmino;
+}
+/** MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. */
+export interface MsgSubmitProposalResponseSDKType {
+  proposal_id: bigint;
+}
+/** MsgVote defines a message to cast a vote. */
+export interface MsgVote {
+  proposalId: bigint;
+  voter: string;
+  option: VoteOption;
+}
+export interface MsgVoteProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVote";
+  value: Uint8Array;
+}
+/** MsgVote defines a message to cast a vote. */
+export interface MsgVoteAmino {
+  proposal_id: string;
+  voter?: string;
+  option?: VoteOption;
+}
+export interface MsgVoteAminoMsg {
+  type: "cosmos-sdk/MsgVote";
+  value: MsgVoteAmino;
+}
+/** MsgVote defines a message to cast a vote. */
+export interface MsgVoteSDKType {
+  proposal_id: bigint;
+  voter: string;
+  option: VoteOption;
+}
+/** MsgVoteResponse defines the Msg/Vote response type. */
+export interface MsgVoteResponse {}
+export interface MsgVoteResponseProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteResponse";
+  value: Uint8Array;
+}
+/** MsgVoteResponse defines the Msg/Vote response type. */
+export interface MsgVoteResponseAmino {}
+export interface MsgVoteResponseAminoMsg {
+  type: "cosmos-sdk/MsgVoteResponse";
+  value: MsgVoteResponseAmino;
+}
+/** MsgVoteResponse defines the Msg/Vote response type. */
+export interface MsgVoteResponseSDKType {}
+/**
+ * MsgVoteWeighted defines a message to cast a vote.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeighted {
+  proposalId: bigint;
+  voter: string;
+  options: WeightedVoteOption[];
+}
+export interface MsgVoteWeightedProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted";
+  value: Uint8Array;
+}
+/**
+ * MsgVoteWeighted defines a message to cast a vote.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeightedAmino {
+  proposal_id?: string;
+  voter?: string;
+  options?: WeightedVoteOptionAmino[];
+}
+export interface MsgVoteWeightedAminoMsg {
+  type: "cosmos-sdk/MsgVoteWeighted";
+  value: MsgVoteWeightedAmino;
+}
+/**
+ * MsgVoteWeighted defines a message to cast a vote.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeightedSDKType {
+  proposal_id: bigint;
+  voter: string;
+  options: WeightedVoteOptionSDKType[];
+}
+/**
+ * MsgVoteWeightedResponse defines the Msg/VoteWeighted response type.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeightedResponse {}
+export interface MsgVoteWeightedResponseProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeightedResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgVoteWeightedResponse defines the Msg/VoteWeighted response type.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeightedResponseAmino {}
+export interface MsgVoteWeightedResponseAminoMsg {
+  type: "cosmos-sdk/MsgVoteWeightedResponse";
+  value: MsgVoteWeightedResponseAmino;
+}
+/**
+ * MsgVoteWeightedResponse defines the Msg/VoteWeighted response type.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface MsgVoteWeightedResponseSDKType {}
+/** MsgDeposit defines a message to submit a deposit to an existing proposal. */
+export interface MsgDeposit {
+  proposalId: bigint;
+  depositor: string;
+  amount: Coin[];
+}
+export interface MsgDepositProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgDeposit";
+  value: Uint8Array;
+}
+/** MsgDeposit defines a message to submit a deposit to an existing proposal. */
+export interface MsgDepositAmino {
+  proposal_id: string;
+  depositor?: string;
+  amount?: CoinAmino[];
+}
+export interface MsgDepositAminoMsg {
+  type: "cosmos-sdk/MsgDeposit";
+  value: MsgDepositAmino;
+}
+/** MsgDeposit defines a message to submit a deposit to an existing proposal. */
+export interface MsgDepositSDKType {
+  proposal_id: bigint;
+  depositor: string;
+  amount: CoinSDKType[];
+}
+/** MsgDepositResponse defines the Msg/Deposit response type. */
+export interface MsgDepositResponse {}
+export interface MsgDepositResponseProtoMsg {
+  typeUrl: "/cosmos.gov.v1beta1.MsgDepositResponse";
+  value: Uint8Array;
+}
+/** MsgDepositResponse defines the Msg/Deposit response type. */
+export interface MsgDepositResponseAmino {}
+export interface MsgDepositResponseAminoMsg {
+  type: "cosmos-sdk/MsgDepositResponse";
+  value: MsgDepositResponseAmino;
+}
+/** MsgDepositResponse defines the Msg/Deposit response type. */
+export interface MsgDepositResponseSDKType {}
+function createBaseMsgSubmitProposal(): MsgSubmitProposal {
+  return {
+    content: undefined,
+    initialDeposit: [],
+    proposer: ""
+  };
+}
+export const MsgSubmitProposal = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
+  encode(message: MsgSubmitProposal, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.content !== undefined) {
+      Any.encode(message.content, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.initialDeposit) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.proposer !== "") {
+      writer.uint32(26).string(message.proposer);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitProposal {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitProposal();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.content = Any.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.initialDeposit.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.proposer = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSubmitProposal>): MsgSubmitProposal {
+    const message = createBaseMsgSubmitProposal();
+    message.content = object.content !== undefined && object.content !== null ? Any.fromPartial(object.content) : undefined;
+    message.initialDeposit = object.initialDeposit?.map(e => Coin.fromPartial(e)) || [];
+    message.proposer = object.proposer ?? "";
+    return message;
+  },
+  fromAmino(object: MsgSubmitProposalAmino): MsgSubmitProposal {
+    const message = createBaseMsgSubmitProposal();
+    if (object.content !== undefined && object.content !== null) {
+      message.content = Any.fromAmino(object.content);
+    }
+    message.initialDeposit = object.initial_deposit?.map(e => Coin.fromAmino(e)) || [];
+    if (object.proposer !== undefined && object.proposer !== null) {
+      message.proposer = object.proposer;
+    }
+    return message;
+  },
+  toAmino(message: MsgSubmitProposal): MsgSubmitProposalAmino {
+    const obj: any = {};
+    obj.content = message.content ? Any.toAmino(message.content) : undefined;
+    if (message.initialDeposit) {
+      obj.initial_deposit = message.initialDeposit.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.initial_deposit = message.initialDeposit;
+    }
+    obj.proposer = message.proposer === "" ? undefined : message.proposer;
+    return obj;
+  },
+  fromAminoMsg(object: MsgSubmitProposalAminoMsg): MsgSubmitProposal {
+    return MsgSubmitProposal.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSubmitProposal): MsgSubmitProposalAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSubmitProposal",
+      value: MsgSubmitProposal.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSubmitProposalProtoMsg): MsgSubmitProposal {
+    return MsgSubmitProposal.decode(message.value);
+  },
+  toProto(message: MsgSubmitProposal): Uint8Array {
+    return MsgSubmitProposal.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSubmitProposal): MsgSubmitProposalProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal",
+      value: MsgSubmitProposal.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgSubmitProposalResponse(): MsgSubmitProposalResponse {
+  return {
+    proposalId: BigInt(0)
+  };
+}
+export const MsgSubmitProposalResponse = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposalResponse",
+  encode(message: MsgSubmitProposalResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.proposalId !== BigInt(0)) {
+      writer.uint32(8).uint64(message.proposalId);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgSubmitProposalResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSubmitProposalResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.proposalId = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgSubmitProposalResponse>): MsgSubmitProposalResponse {
+    const message = createBaseMsgSubmitProposalResponse();
+    message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: MsgSubmitProposalResponseAmino): MsgSubmitProposalResponse {
+    const message = createBaseMsgSubmitProposalResponse();
+    if (object.proposal_id !== undefined && object.proposal_id !== null) {
+      message.proposalId = BigInt(object.proposal_id);
+    }
+    return message;
+  },
+  toAmino(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseAmino {
+    const obj: any = {};
+    obj.proposal_id = message.proposalId ? message.proposalId.toString() : "0";
+    return obj;
+  },
+  fromAminoMsg(object: MsgSubmitProposalResponseAminoMsg): MsgSubmitProposalResponse {
+    return MsgSubmitProposalResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgSubmitProposalResponse",
+      value: MsgSubmitProposalResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgSubmitProposalResponseProtoMsg): MsgSubmitProposalResponse {
+    return MsgSubmitProposalResponse.decode(message.value);
+  },
+  toProto(message: MsgSubmitProposalResponse): Uint8Array {
+    return MsgSubmitProposalResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposalResponse",
+      value: MsgSubmitProposalResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgVote(): MsgVote {
+  return {
+    proposalId: BigInt(0),
+    voter: "",
+    option: 0
+  };
+}
+export const MsgVote = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVote",
+  encode(message: MsgVote, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.proposalId !== BigInt(0)) {
+      writer.uint32(8).uint64(message.proposalId);
+    }
+    if (message.voter !== "") {
+      writer.uint32(18).string(message.voter);
+    }
+    if (message.option !== 0) {
+      writer.uint32(24).int32(message.option);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVote {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVote();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.proposalId = reader.uint64();
+          break;
+        case 2:
+          message.voter = reader.string();
+          break;
+        case 3:
+          message.option = (reader.int32() as any);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgVote>): MsgVote {
+    const message = createBaseMsgVote();
+    message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+    message.voter = object.voter ?? "";
+    message.option = object.option ?? 0;
+    return message;
+  },
+  fromAmino(object: MsgVoteAmino): MsgVote {
+    const message = createBaseMsgVote();
+    if (object.proposal_id !== undefined && object.proposal_id !== null) {
+      message.proposalId = BigInt(object.proposal_id);
+    }
+    if (object.voter !== undefined && object.voter !== null) {
+      message.voter = object.voter;
+    }
+    if (object.option !== undefined && object.option !== null) {
+      message.option = object.option;
+    }
+    return message;
+  },
+  toAmino(message: MsgVote): MsgVoteAmino {
+    const obj: any = {};
+    obj.proposal_id = message.proposalId ? message.proposalId.toString() : "0";
+    obj.voter = message.voter === "" ? undefined : message.voter;
+    obj.option = message.option === 0 ? undefined : message.option;
+    return obj;
+  },
+  fromAminoMsg(object: MsgVoteAminoMsg): MsgVote {
+    return MsgVote.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVote): MsgVoteAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVote",
+      value: MsgVote.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVoteProtoMsg): MsgVote {
+    return MsgVote.decode(message.value);
+  },
+  toProto(message: MsgVote): Uint8Array {
+    return MsgVote.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVote): MsgVoteProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgVote",
+      value: MsgVote.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgVoteResponse(): MsgVoteResponse {
+  return {};
+}
+export const MsgVoteResponse = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteResponse",
+  encode(_: MsgVoteResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVoteResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVoteResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgVoteResponse>): MsgVoteResponse {
+    const message = createBaseMsgVoteResponse();
+    return message;
+  },
+  fromAmino(_: MsgVoteResponseAmino): MsgVoteResponse {
+    const message = createBaseMsgVoteResponse();
+    return message;
+  },
+  toAmino(_: MsgVoteResponse): MsgVoteResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgVoteResponseAminoMsg): MsgVoteResponse {
+    return MsgVoteResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVoteResponse): MsgVoteResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVoteResponse",
+      value: MsgVoteResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVoteResponseProtoMsg): MsgVoteResponse {
+    return MsgVoteResponse.decode(message.value);
+  },
+  toProto(message: MsgVoteResponse): Uint8Array {
+    return MsgVoteResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVoteResponse): MsgVoteResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgVoteResponse",
+      value: MsgVoteResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgVoteWeighted(): MsgVoteWeighted {
+  return {
+    proposalId: BigInt(0),
+    voter: "",
+    options: []
+  };
+}
+export const MsgVoteWeighted = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
+  encode(message: MsgVoteWeighted, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.proposalId !== BigInt(0)) {
+      writer.uint32(8).uint64(message.proposalId);
+    }
+    if (message.voter !== "") {
+      writer.uint32(18).string(message.voter);
+    }
+    for (const v of message.options) {
+      WeightedVoteOption.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVoteWeighted {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVoteWeighted();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.proposalId = reader.uint64();
+          break;
+        case 2:
+          message.voter = reader.string();
+          break;
+        case 3:
+          message.options.push(WeightedVoteOption.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgVoteWeighted>): MsgVoteWeighted {
+    const message = createBaseMsgVoteWeighted();
+    message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+    message.voter = object.voter ?? "";
+    message.options = object.options?.map(e => WeightedVoteOption.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: MsgVoteWeightedAmino): MsgVoteWeighted {
+    const message = createBaseMsgVoteWeighted();
+    if (object.proposal_id !== undefined && object.proposal_id !== null) {
+      message.proposalId = BigInt(object.proposal_id);
+    }
+    if (object.voter !== undefined && object.voter !== null) {
+      message.voter = object.voter;
+    }
+    message.options = object.options?.map(e => WeightedVoteOption.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgVoteWeighted): MsgVoteWeightedAmino {
+    const obj: any = {};
+    obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId.toString() : undefined;
+    obj.voter = message.voter === "" ? undefined : message.voter;
+    if (message.options) {
+      obj.options = message.options.map(e => e ? WeightedVoteOption.toAmino(e) : undefined);
+    } else {
+      obj.options = message.options;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgVoteWeightedAminoMsg): MsgVoteWeighted {
+    return MsgVoteWeighted.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVoteWeighted): MsgVoteWeightedAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVoteWeighted",
+      value: MsgVoteWeighted.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVoteWeightedProtoMsg): MsgVoteWeighted {
+    return MsgVoteWeighted.decode(message.value);
+  },
+  toProto(message: MsgVoteWeighted): Uint8Array {
+    return MsgVoteWeighted.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVoteWeighted): MsgVoteWeightedProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted",
+      value: MsgVoteWeighted.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgVoteWeightedResponse(): MsgVoteWeightedResponse {
+  return {};
+}
+export const MsgVoteWeightedResponse = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeightedResponse",
+  encode(_: MsgVoteWeightedResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgVoteWeightedResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVoteWeightedResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgVoteWeightedResponse>): MsgVoteWeightedResponse {
+    const message = createBaseMsgVoteWeightedResponse();
+    return message;
+  },
+  fromAmino(_: MsgVoteWeightedResponseAmino): MsgVoteWeightedResponse {
+    const message = createBaseMsgVoteWeightedResponse();
+    return message;
+  },
+  toAmino(_: MsgVoteWeightedResponse): MsgVoteWeightedResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgVoteWeightedResponseAminoMsg): MsgVoteWeightedResponse {
+    return MsgVoteWeightedResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgVoteWeightedResponse): MsgVoteWeightedResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgVoteWeightedResponse",
+      value: MsgVoteWeightedResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgVoteWeightedResponseProtoMsg): MsgVoteWeightedResponse {
+    return MsgVoteWeightedResponse.decode(message.value);
+  },
+  toProto(message: MsgVoteWeightedResponse): Uint8Array {
+    return MsgVoteWeightedResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgVoteWeightedResponse): MsgVoteWeightedResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeightedResponse",
+      value: MsgVoteWeightedResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgDeposit(): MsgDeposit {
+  return {
+    proposalId: BigInt(0),
+    depositor: "",
+    amount: []
+  };
+}
+export const MsgDeposit = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
+  encode(message: MsgDeposit, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.proposalId !== BigInt(0)) {
+      writer.uint32(8).uint64(message.proposalId);
+    }
+    if (message.depositor !== "") {
+      writer.uint32(18).string(message.depositor);
+    }
+    for (const v of message.amount) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgDeposit {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDeposit();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.proposalId = reader.uint64();
+          break;
+        case 2:
+          message.depositor = reader.string();
+          break;
+        case 3:
+          message.amount.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgDeposit>): MsgDeposit {
+    const message = createBaseMsgDeposit();
+    message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+    message.depositor = object.depositor ?? "";
+    message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: MsgDepositAmino): MsgDeposit {
+    const message = createBaseMsgDeposit();
+    if (object.proposal_id !== undefined && object.proposal_id !== null) {
+      message.proposalId = BigInt(object.proposal_id);
+    }
+    if (object.depositor !== undefined && object.depositor !== null) {
+      message.depositor = object.depositor;
+    }
+    message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: MsgDeposit): MsgDepositAmino {
+    const obj: any = {};
+    obj.proposal_id = message.proposalId ? message.proposalId.toString() : "0";
+    obj.depositor = message.depositor === "" ? undefined : message.depositor;
+    if (message.amount) {
+      obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.amount = message.amount;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: MsgDepositAminoMsg): MsgDeposit {
+    return MsgDeposit.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgDeposit): MsgDepositAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgDeposit",
+      value: MsgDeposit.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgDepositProtoMsg): MsgDeposit {
+    return MsgDeposit.decode(message.value);
+  },
+  toProto(message: MsgDeposit): Uint8Array {
+    return MsgDeposit.encode(message).finish();
+  },
+  toProtoMsg(message: MsgDeposit): MsgDepositProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgDeposit",
+      value: MsgDeposit.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgDepositResponse(): MsgDepositResponse {
+  return {};
+}
+export const MsgDepositResponse = {
+  typeUrl: "/cosmos.gov.v1beta1.MsgDepositResponse",
+  encode(_: MsgDepositResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgDepositResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDepositResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgDepositResponse>): MsgDepositResponse {
+    const message = createBaseMsgDepositResponse();
+    return message;
+  },
+  fromAmino(_: MsgDepositResponseAmino): MsgDepositResponse {
+    const message = createBaseMsgDepositResponse();
+    return message;
+  },
+  toAmino(_: MsgDepositResponse): MsgDepositResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgDepositResponseAminoMsg): MsgDepositResponse {
+    return MsgDepositResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgDepositResponse): MsgDepositResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/MsgDepositResponse",
+      value: MsgDepositResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgDepositResponseProtoMsg): MsgDepositResponse {
+    return MsgDepositResponse.decode(message.value);
+  },
+  toProto(message: MsgDepositResponse): Uint8Array {
+    return MsgDepositResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgDepositResponse): MsgDepositResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.gov.v1beta1.MsgDepositResponse",
+      value: MsgDepositResponse.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/lcd.ts

@@ -0,0 +1,91 @@
+import { LCDClient } from "@cosmology/lcd";
+export const createLCDClient = async ({
+  restEndpoint
+}: {
+  restEndpoint: string;
+}) => {
+  const requestClient = new LCDClient({
+    restEndpoint
+  });
+  return {
+    cosmos: {
+      auth: {
+        v1beta1: new (await import("./auth/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      authz: {
+        v1beta1: new (await import("./authz/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      bank: {
+        v1beta1: new (await import("./bank/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      base: {
+        node: {
+          v1beta1: new (await import("./base/node/v1beta1/query.lcd")).LCDQueryClient({
+            requestClient
+          })
+        },
+        tendermint: {
+          v1beta1: new (await import("./base/tendermint/v1beta1/query.lcd")).LCDQueryClient({
+            requestClient
+          })
+        }
+      },
+      distribution: {
+        v1beta1: new (await import("./distribution/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      evidence: {
+        v1beta1: new (await import("./evidence/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      feegrant: {
+        v1beta1: new (await import("./feegrant/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      gov: {
+        v1beta1: new (await import("./gov/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      mint: {
+        v1beta1: new (await import("./mint/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      params: {
+        v1beta1: new (await import("./params/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      slashing: {
+        v1beta1: new (await import("./slashing/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      staking: {
+        v1beta1: new (await import("./staking/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      tx: {
+        v1beta1: new (await import("./tx/v1beta1/service.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      upgrade: {
+        v1beta1: new (await import("./upgrade/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    }
+  };
+};

src/codegen/cosmos/mint/v1beta1/genesis.ts

@@ -0,0 +1,110 @@
+import { Minter, MinterAmino, MinterSDKType, Params, ParamsAmino, ParamsSDKType } from "./mint";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisState {
+  /** minter is a space for holding current inflation information. */
+  minter: Minter;
+  /** params defines all the paramaters of the module. */
+  params: Params;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisStateAmino {
+  /** minter is a space for holding current inflation information. */
+  minter?: MinterAmino;
+  /** params defines all the paramaters of the module. */
+  params?: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisStateSDKType {
+  minter: MinterSDKType;
+  params: ParamsSDKType;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    minter: Minter.fromPartial({}),
+    params: Params.fromPartial({})
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.mint.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.minter !== undefined) {
+      Minter.encode(message.minter, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).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.minter = Minter.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.minter = object.minter !== undefined && object.minter !== null ? Minter.fromPartial(object.minter) : undefined;
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.minter !== undefined && object.minter !== null) {
+      message.minter = Minter.fromAmino(object.minter);
+    }
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.minter = message.minter ? Minter.toAmino(message.minter) : undefined;
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    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.mint.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/mint/v1beta1/mint.ts

@@ -0,0 +1,286 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@cosmjs/math";
+/** Minter represents the minting state. */
+export interface Minter {
+  /** current annual inflation rate */
+  inflation: string;
+  /** current annual expected provisions */
+  annualProvisions: string;
+}
+export interface MinterProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.Minter";
+  value: Uint8Array;
+}
+/** Minter represents the minting state. */
+export interface MinterAmino {
+  /** current annual inflation rate */
+  inflation?: string;
+  /** current annual expected provisions */
+  annual_provisions?: string;
+}
+export interface MinterAminoMsg {
+  type: "cosmos-sdk/Minter";
+  value: MinterAmino;
+}
+/** Minter represents the minting state. */
+export interface MinterSDKType {
+  inflation: string;
+  annual_provisions: string;
+}
+/** Params holds parameters for the mint module. */
+export interface Params {
+  /** type of coin to mint */
+  mintDenom: string;
+  /** maximum annual change in inflation rate */
+  inflationRateChange: string;
+  /** maximum inflation rate */
+  inflationMax: string;
+  /** minimum inflation rate */
+  inflationMin: string;
+  /** goal of percent bonded atoms */
+  goalBonded: string;
+  /** expected blocks per year */
+  blocksPerYear: bigint;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.Params";
+  value: Uint8Array;
+}
+/** Params holds parameters for the mint module. */
+export interface ParamsAmino {
+  /** type of coin to mint */
+  mint_denom?: string;
+  /** maximum annual change in inflation rate */
+  inflation_rate_change?: string;
+  /** maximum inflation rate */
+  inflation_max?: string;
+  /** minimum inflation rate */
+  inflation_min?: string;
+  /** goal of percent bonded atoms */
+  goal_bonded?: string;
+  /** expected blocks per year */
+  blocks_per_year?: string;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/Params";
+  value: ParamsAmino;
+}
+/** Params holds parameters for the mint module. */
+export interface ParamsSDKType {
+  mint_denom: string;
+  inflation_rate_change: string;
+  inflation_max: string;
+  inflation_min: string;
+  goal_bonded: string;
+  blocks_per_year: bigint;
+}
+function createBaseMinter(): Minter {
+  return {
+    inflation: "",
+    annualProvisions: ""
+  };
+}
+export const Minter = {
+  typeUrl: "/cosmos.mint.v1beta1.Minter",
+  encode(message: Minter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.inflation !== "") {
+      writer.uint32(10).string(Decimal.fromUserInput(message.inflation, 18).atomics);
+    }
+    if (message.annualProvisions !== "") {
+      writer.uint32(18).string(Decimal.fromUserInput(message.annualProvisions, 18).atomics);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Minter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMinter();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.inflation = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 2:
+          message.annualProvisions = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Minter>): Minter {
+    const message = createBaseMinter();
+    message.inflation = object.inflation ?? "";
+    message.annualProvisions = object.annualProvisions ?? "";
+    return message;
+  },
+  fromAmino(object: MinterAmino): Minter {
+    const message = createBaseMinter();
+    if (object.inflation !== undefined && object.inflation !== null) {
+      message.inflation = object.inflation;
+    }
+    if (object.annual_provisions !== undefined && object.annual_provisions !== null) {
+      message.annualProvisions = object.annual_provisions;
+    }
+    return message;
+  },
+  toAmino(message: Minter): MinterAmino {
+    const obj: any = {};
+    obj.inflation = message.inflation === "" ? undefined : message.inflation;
+    obj.annual_provisions = message.annualProvisions === "" ? undefined : message.annualProvisions;
+    return obj;
+  },
+  fromAminoMsg(object: MinterAminoMsg): Minter {
+    return Minter.fromAmino(object.value);
+  },
+  toAminoMsg(message: Minter): MinterAminoMsg {
+    return {
+      type: "cosmos-sdk/Minter",
+      value: Minter.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MinterProtoMsg): Minter {
+    return Minter.decode(message.value);
+  },
+  toProto(message: Minter): Uint8Array {
+    return Minter.encode(message).finish();
+  },
+  toProtoMsg(message: Minter): MinterProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.Minter",
+      value: Minter.encode(message).finish()
+    };
+  }
+};
+function createBaseParams(): Params {
+  return {
+    mintDenom: "",
+    inflationRateChange: "",
+    inflationMax: "",
+    inflationMin: "",
+    goalBonded: "",
+    blocksPerYear: BigInt(0)
+  };
+}
+export const Params = {
+  typeUrl: "/cosmos.mint.v1beta1.Params",
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.mintDenom !== "") {
+      writer.uint32(10).string(message.mintDenom);
+    }
+    if (message.inflationRateChange !== "") {
+      writer.uint32(18).string(Decimal.fromUserInput(message.inflationRateChange, 18).atomics);
+    }
+    if (message.inflationMax !== "") {
+      writer.uint32(26).string(Decimal.fromUserInput(message.inflationMax, 18).atomics);
+    }
+    if (message.inflationMin !== "") {
+      writer.uint32(34).string(Decimal.fromUserInput(message.inflationMin, 18).atomics);
+    }
+    if (message.goalBonded !== "") {
+      writer.uint32(42).string(Decimal.fromUserInput(message.goalBonded, 18).atomics);
+    }
+    if (message.blocksPerYear !== BigInt(0)) {
+      writer.uint32(48).uint64(message.blocksPerYear);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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.mintDenom = reader.string();
+          break;
+        case 2:
+          message.inflationRateChange = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 3:
+          message.inflationMax = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 4:
+          message.inflationMin = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 5:
+          message.goalBonded = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 6:
+          message.blocksPerYear = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Params>): Params {
+    const message = createBaseParams();
+    message.mintDenom = object.mintDenom ?? "";
+    message.inflationRateChange = object.inflationRateChange ?? "";
+    message.inflationMax = object.inflationMax ?? "";
+    message.inflationMin = object.inflationMin ?? "";
+    message.goalBonded = object.goalBonded ?? "";
+    message.blocksPerYear = object.blocksPerYear !== undefined && object.blocksPerYear !== null ? BigInt(object.blocksPerYear.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (object.mint_denom !== undefined && object.mint_denom !== null) {
+      message.mintDenom = object.mint_denom;
+    }
+    if (object.inflation_rate_change !== undefined && object.inflation_rate_change !== null) {
+      message.inflationRateChange = object.inflation_rate_change;
+    }
+    if (object.inflation_max !== undefined && object.inflation_max !== null) {
+      message.inflationMax = object.inflation_max;
+    }
+    if (object.inflation_min !== undefined && object.inflation_min !== null) {
+      message.inflationMin = object.inflation_min;
+    }
+    if (object.goal_bonded !== undefined && object.goal_bonded !== null) {
+      message.goalBonded = object.goal_bonded;
+    }
+    if (object.blocks_per_year !== undefined && object.blocks_per_year !== null) {
+      message.blocksPerYear = BigInt(object.blocks_per_year);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.mint_denom = message.mintDenom === "" ? undefined : message.mintDenom;
+    obj.inflation_rate_change = message.inflationRateChange === "" ? undefined : message.inflationRateChange;
+    obj.inflation_max = message.inflationMax === "" ? undefined : message.inflationMax;
+    obj.inflation_min = message.inflationMin === "" ? undefined : message.inflationMin;
+    obj.goal_bonded = message.goalBonded === "" ? undefined : message.goalBonded;
+    obj.blocks_per_year = message.blocksPerYear !== BigInt(0) ? message.blocksPerYear.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "cosmos-sdk/Params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};

src/codegen/cosmos/mint/v1beta1/query.lcd.ts

@@ -0,0 +1,30 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryInflationRequest, QueryInflationResponseSDKType, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.params = this.params.bind(this);
+    this.inflation = this.inflation.bind(this);
+    this.annualProvisions = this.annualProvisions.bind(this);
+  }
+  /* Params returns the total set of minting parameters. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/mint/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* Inflation returns the current minting inflation value. */
+  async inflation(_params: QueryInflationRequest = {}): Promise<QueryInflationResponseSDKType> {
+    const endpoint = `cosmos/mint/v1beta1/inflation`;
+    return await this.req.get<QueryInflationResponseSDKType>(endpoint);
+  }
+  /* AnnualProvisions current minting annual provisions value. */
+  async annualProvisions(_params: QueryAnnualProvisionsRequest = {}): Promise<QueryAnnualProvisionsResponseSDKType> {
+    const endpoint = `cosmos/mint/v1beta1/annual_provisions`;
+    return await this.req.get<QueryAnnualProvisionsResponseSDKType>(endpoint);
+  }
+}

src/codegen/cosmos/mint/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,52 @@
+import { Rpc } from "../../../helpers";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
+/** Query provides defines the gRPC querier service. */
+export interface Query {
+  /** Params returns the total set of minting parameters. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** Inflation returns the current minting inflation value. */
+  inflation(request?: QueryInflationRequest): Promise<QueryInflationResponse>;
+  /** AnnualProvisions current minting annual provisions value. */
+  annualProvisions(request?: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.inflation = this.inflation.bind(this);
+    this.annualProvisions = this.annualProvisions.bind(this);
+  }
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  }
+  inflation(request: QueryInflationRequest = {}): Promise<QueryInflationResponse> {
+    const data = QueryInflationRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "Inflation", data);
+    return promise.then(data => QueryInflationResponse.decode(new BinaryReader(data)));
+  }
+  annualProvisions(request: QueryAnnualProvisionsRequest = {}): Promise<QueryAnnualProvisionsResponse> {
+    const data = QueryAnnualProvisionsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.mint.v1beta1.Query", "AnnualProvisions", data);
+    return promise.then(data => QueryAnnualProvisionsResponse.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);
+    },
+    inflation(request?: QueryInflationRequest): Promise<QueryInflationResponse> {
+      return queryService.inflation(request);
+    },
+    annualProvisions(request?: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponse> {
+      return queryService.annualProvisions(request);
+    }
+  };
+};

src/codegen/cosmos/mint/v1beta1/query.ts

@@ -0,0 +1,513 @@
+import { Params, ParamsAmino, ParamsSDKType } from "./mint";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {}
+export interface QueryParamsRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest";
+  value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {}
+export interface QueryParamsRequestAminoMsg {
+  type: "cosmos-sdk/QueryParamsRequest";
+  value: QueryParamsRequestAmino;
+}
+/** 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 defines the parameters of the module. */
+  params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+  typeUrl: "/cosmos.mint.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: "cosmos-sdk/QueryParamsResponse";
+  value: QueryParamsResponseAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseSDKType {
+  params: ParamsSDKType;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequest {}
+export interface QueryInflationRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest";
+  value: Uint8Array;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequestAmino {}
+export interface QueryInflationRequestAminoMsg {
+  type: "cosmos-sdk/QueryInflationRequest";
+  value: QueryInflationRequestAmino;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequestSDKType {}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponse {
+  /** inflation is the current minting inflation value. */
+  inflation: Uint8Array;
+}
+export interface QueryInflationResponseProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponseAmino {
+  /** inflation is the current minting inflation value. */
+  inflation?: string;
+}
+export interface QueryInflationResponseAminoMsg {
+  type: "cosmos-sdk/QueryInflationResponse";
+  value: QueryInflationResponseAmino;
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponseSDKType {
+  inflation: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequest {}
+export interface QueryAnnualProvisionsRequestProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest";
+  value: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequestAmino {}
+export interface QueryAnnualProvisionsRequestAminoMsg {
+  type: "cosmos-sdk/QueryAnnualProvisionsRequest";
+  value: QueryAnnualProvisionsRequestAmino;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequestSDKType {}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponse {
+  /** annual_provisions is the current minting annual provisions value. */
+  annualProvisions: Uint8Array;
+}
+export interface QueryAnnualProvisionsResponseProtoMsg {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse";
+  value: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponseAmino {
+  /** annual_provisions is the current minting annual provisions value. */
+  annual_provisions?: string;
+}
+export interface QueryAnnualProvisionsResponseAminoMsg {
+  type: "cosmos-sdk/QueryAnnualProvisionsResponse";
+  value: QueryAnnualProvisionsResponseAmino;
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponseSDKType {
+  annual_provisions: Uint8Array;
+}
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+export const QueryParamsRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest",
+  encode(_: QueryParamsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof BinaryReader ? input : new 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(_: Partial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  toAmino(_: QueryParamsRequest): QueryParamsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest {
+    return QueryParamsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsRequest",
+      value: QueryParamsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest {
+    return QueryParamsRequest.decode(message.value);
+  },
+  toProto(message: QueryParamsRequest): Uint8Array {
+    return QueryParamsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryParamsRequest",
+      value: QueryParamsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: Params.fromPartial({})
+  };
+}
+export const QueryParamsResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
+  encode(message: QueryParamsResponse, 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): QueryParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new 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 = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: QueryParamsResponse): QueryParamsResponseAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse {
+    return QueryParamsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryParamsResponse",
+      value: QueryParamsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse {
+    return QueryParamsResponse.decode(message.value);
+  },
+  toProto(message: QueryParamsResponse): Uint8Array {
+    return QueryParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryParamsResponse",
+      value: QueryParamsResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryInflationRequest(): QueryInflationRequest {
+  return {};
+}
+export const QueryInflationRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
+  encode(_: QueryInflationRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryInflationRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryInflationRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<QueryInflationRequest>): QueryInflationRequest {
+    const message = createBaseQueryInflationRequest();
+    return message;
+  },
+  fromAmino(_: QueryInflationRequestAmino): QueryInflationRequest {
+    const message = createBaseQueryInflationRequest();
+    return message;
+  },
+  toAmino(_: QueryInflationRequest): QueryInflationRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryInflationRequestAminoMsg): QueryInflationRequest {
+    return QueryInflationRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryInflationRequest): QueryInflationRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryInflationRequest",
+      value: QueryInflationRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryInflationRequestProtoMsg): QueryInflationRequest {
+    return QueryInflationRequest.decode(message.value);
+  },
+  toProto(message: QueryInflationRequest): Uint8Array {
+    return QueryInflationRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryInflationRequest): QueryInflationRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryInflationRequest",
+      value: QueryInflationRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryInflationResponse(): QueryInflationResponse {
+  return {
+    inflation: new Uint8Array()
+  };
+}
+export const QueryInflationResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
+  encode(message: QueryInflationResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.inflation.length !== 0) {
+      writer.uint32(10).bytes(message.inflation);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryInflationResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryInflationResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.inflation = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryInflationResponse>): QueryInflationResponse {
+    const message = createBaseQueryInflationResponse();
+    message.inflation = object.inflation ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: QueryInflationResponseAmino): QueryInflationResponse {
+    const message = createBaseQueryInflationResponse();
+    if (object.inflation !== undefined && object.inflation !== null) {
+      message.inflation = bytesFromBase64(object.inflation);
+    }
+    return message;
+  },
+  toAmino(message: QueryInflationResponse): QueryInflationResponseAmino {
+    const obj: any = {};
+    obj.inflation = message.inflation ? base64FromBytes(message.inflation) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryInflationResponseAminoMsg): QueryInflationResponse {
+    return QueryInflationResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryInflationResponse): QueryInflationResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryInflationResponse",
+      value: QueryInflationResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryInflationResponseProtoMsg): QueryInflationResponse {
+    return QueryInflationResponse.decode(message.value);
+  },
+  toProto(message: QueryInflationResponse): Uint8Array {
+    return QueryInflationResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryInflationResponse): QueryInflationResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryInflationResponse",
+      value: QueryInflationResponse.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAnnualProvisionsRequest(): QueryAnnualProvisionsRequest {
+  return {};
+}
+export const QueryAnnualProvisionsRequest = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
+  encode(_: QueryAnnualProvisionsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAnnualProvisionsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAnnualProvisionsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<QueryAnnualProvisionsRequest>): QueryAnnualProvisionsRequest {
+    const message = createBaseQueryAnnualProvisionsRequest();
+    return message;
+  },
+  fromAmino(_: QueryAnnualProvisionsRequestAmino): QueryAnnualProvisionsRequest {
+    const message = createBaseQueryAnnualProvisionsRequest();
+    return message;
+  },
+  toAmino(_: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryAnnualProvisionsRequestAminoMsg): QueryAnnualProvisionsRequest {
+    return QueryAnnualProvisionsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAnnualProvisionsRequest",
+      value: QueryAnnualProvisionsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAnnualProvisionsRequestProtoMsg): QueryAnnualProvisionsRequest {
+    return QueryAnnualProvisionsRequest.decode(message.value);
+  },
+  toProto(message: QueryAnnualProvisionsRequest): Uint8Array {
+    return QueryAnnualProvisionsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAnnualProvisionsRequest): QueryAnnualProvisionsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsRequest",
+      value: QueryAnnualProvisionsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseQueryAnnualProvisionsResponse(): QueryAnnualProvisionsResponse {
+  return {
+    annualProvisions: new Uint8Array()
+  };
+}
+export const QueryAnnualProvisionsResponse = {
+  typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
+  encode(message: QueryAnnualProvisionsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.annualProvisions.length !== 0) {
+      writer.uint32(10).bytes(message.annualProvisions);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryAnnualProvisionsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryAnnualProvisionsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.annualProvisions = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<QueryAnnualProvisionsResponse>): QueryAnnualProvisionsResponse {
+    const message = createBaseQueryAnnualProvisionsResponse();
+    message.annualProvisions = object.annualProvisions ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: QueryAnnualProvisionsResponseAmino): QueryAnnualProvisionsResponse {
+    const message = createBaseQueryAnnualProvisionsResponse();
+    if (object.annual_provisions !== undefined && object.annual_provisions !== null) {
+      message.annualProvisions = bytesFromBase64(object.annual_provisions);
+    }
+    return message;
+  },
+  toAmino(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseAmino {
+    const obj: any = {};
+    obj.annual_provisions = message.annualProvisions ? base64FromBytes(message.annualProvisions) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryAnnualProvisionsResponseAminoMsg): QueryAnnualProvisionsResponse {
+    return QueryAnnualProvisionsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/QueryAnnualProvisionsResponse",
+      value: QueryAnnualProvisionsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: QueryAnnualProvisionsResponseProtoMsg): QueryAnnualProvisionsResponse {
+    return QueryAnnualProvisionsResponse.decode(message.value);
+  },
+  toProto(message: QueryAnnualProvisionsResponse): Uint8Array {
+    return QueryAnnualProvisionsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryAnnualProvisionsResponse): QueryAnnualProvisionsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse",
+      value: QueryAnnualProvisionsResponse.encode(message).finish()
+    };
+  }
+};

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

@@ -0,0 +1,250 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposal {
+  title: string;
+  description: string;
+  changes: ParamChange[];
+}
+export interface ParameterChangeProposalProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal";
+  value: Uint8Array;
+}
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposalAmino {
+  title?: string;
+  description?: string;
+  changes?: ParamChangeAmino[];
+}
+export interface ParameterChangeProposalAminoMsg {
+  type: "cosmos-sdk/ParameterChangeProposal";
+  value: ParameterChangeProposalAmino;
+}
+/** 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;
+}
+export interface ParamChangeProtoMsg {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange";
+  value: Uint8Array;
+}
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChangeAmino {
+  subspace?: string;
+  key?: string;
+  value?: string;
+}
+export interface ParamChangeAminoMsg {
+  type: "cosmos-sdk/ParamChange";
+  value: ParamChangeAmino;
+}
+/**
+ * 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 = {
+  typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+  encode(message: ParameterChangeProposal, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    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: BinaryReader | Uint8Array, length?: number): ParameterChangeProposal {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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: Partial<ParameterChangeProposal>): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    message.title = object.title ?? "";
+    message.description = object.description ?? "";
+    message.changes = object.changes?.map(e => ParamChange.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: ParameterChangeProposalAmino): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    if (object.title !== undefined && object.title !== null) {
+      message.title = object.title;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    message.changes = object.changes?.map(e => ParamChange.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: ParameterChangeProposal): ParameterChangeProposalAmino {
+    const obj: any = {};
+    obj.title = message.title === "" ? undefined : message.title;
+    obj.description = message.description === "" ? undefined : message.description;
+    if (message.changes) {
+      obj.changes = message.changes.map(e => e ? ParamChange.toAmino(e) : undefined);
+    } else {
+      obj.changes = message.changes;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ParameterChangeProposalAminoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParameterChangeProposal): ParameterChangeProposalAminoMsg {
+    return {
+      type: "cosmos-sdk/ParameterChangeProposal",
+      value: ParameterChangeProposal.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParameterChangeProposalProtoMsg): ParameterChangeProposal {
+    return ParameterChangeProposal.decode(message.value);
+  },
+  toProto(message: ParameterChangeProposal): Uint8Array {
+    return ParameterChangeProposal.encode(message).finish();
+  },
+  toProtoMsg(message: ParameterChangeProposal): ParameterChangeProposalProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParameterChangeProposal",
+      value: ParameterChangeProposal.encode(message).finish()
+    };
+  }
+};
+function createBaseParamChange(): ParamChange {
+  return {
+    subspace: "",
+    key: "",
+    value: ""
+  };
+}
+export const ParamChange = {
+  typeUrl: "/cosmos.params.v1beta1.ParamChange",
+  encode(message: ParamChange, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    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: BinaryReader | Uint8Array, length?: number): ParamChange {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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: Partial<ParamChange>): ParamChange {
+    const message = createBaseParamChange();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+  fromAmino(object: ParamChangeAmino): ParamChange {
+    const message = createBaseParamChange();
+    if (object.subspace !== undefined && object.subspace !== null) {
+      message.subspace = object.subspace;
+    }
+    if (object.key !== undefined && object.key !== null) {
+      message.key = object.key;
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = object.value;
+    }
+    return message;
+  },
+  toAmino(message: ParamChange): ParamChangeAmino {
+    const obj: any = {};
+    obj.subspace = message.subspace === "" ? undefined : message.subspace;
+    obj.key = message.key === "" ? undefined : message.key;
+    obj.value = message.value === "" ? undefined : message.value;
+    return obj;
+  },
+  fromAminoMsg(object: ParamChangeAminoMsg): ParamChange {
+    return ParamChange.fromAmino(object.value);
+  },
+  toAminoMsg(message: ParamChange): ParamChangeAminoMsg {
+    return {
+      type: "cosmos-sdk/ParamChange",
+      value: ParamChange.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamChangeProtoMsg): ParamChange {
+    return ParamChange.decode(message.value);
+  },
+  toProto(message: ParamChange): Uint8Array {
+    return ParamChange.encode(message).finish();
+  },
+  toProtoMsg(message: ParamChange): ParamChangeProtoMsg {
+    return {
+      typeUrl: "/cosmos.params.v1beta1.ParamChange",
+      value: ParamChange.encode(message).finish()
+    };
+  }
+};