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

package/types/cosmos/protocolpool/v1/types.ts

@@ -0,0 +1,268 @@
+//@ts-nocheck
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@cosmjs/math";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+/** ContinuousFund defines the fields of continuous fund proposal. */
+export interface ContinuousFund {
+  /** Recipient is the address string of the account receiving funds. */
+  recipient: string;
+  /** Percentage is the percentage of funds to be allocated from Community pool. */
+  percentage: string;
+  /** Optional, if expiry is set, removes the state object when expired. */
+  expiry?: Date;
+}
+export interface ContinuousFundProtoMsg {
+  typeUrl: "/cosmos.protocolpool.v1.ContinuousFund";
+  value: Uint8Array;
+}
+/**
+ * ContinuousFund defines the fields of continuous fund proposal.
+ * @name ContinuousFundAmino
+ * @package cosmos.protocolpool.v1
+ * @see proto type: cosmos.protocolpool.v1.ContinuousFund
+ */
+export interface ContinuousFundAmino {
+  /**
+   * Recipient is the address string of the account receiving funds.
+   */
+  recipient?: string;
+  /**
+   * Percentage is the percentage of funds to be allocated from Community pool.
+   */
+  percentage?: string;
+  /**
+   * Optional, if expiry is set, removes the state object when expired.
+   */
+  expiry?: string;
+}
+export interface ContinuousFundAminoMsg {
+  type: "cosmos-sdk/ContinuousFund";
+  value: ContinuousFundAmino;
+}
+/** ContinuousFund defines the fields of continuous fund proposal. */
+export interface ContinuousFundSDKType {
+  recipient: string;
+  percentage: string;
+  expiry?: Date;
+}
+/** Params defines the parameters for the protocolpool module. */
+export interface Params {
+  /**
+   * EnabledDistributionDenoms lists the denoms that are allowed to be distributed.
+   * This is to avoid spending time distributing undesired tokens to continuous funds and budgets.
+   */
+  enabledDistributionDenoms: string[];
+  /**
+   * DistributionFrequency is the frequency (in terms of blocks) that funds are distributed out from the
+   * x/protocolpool module.
+   */
+  distributionFrequency: bigint;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/cosmos.protocolpool.v1.Params";
+  value: Uint8Array;
+}
+/**
+ * Params defines the parameters for the protocolpool module.
+ * @name ParamsAmino
+ * @package cosmos.protocolpool.v1
+ * @see proto type: cosmos.protocolpool.v1.Params
+ */
+export interface ParamsAmino {
+  /**
+   * EnabledDistributionDenoms lists the denoms that are allowed to be distributed.
+   * This is to avoid spending time distributing undesired tokens to continuous funds and budgets.
+   */
+  enabled_distribution_denoms?: string[];
+  /**
+   * DistributionFrequency is the frequency (in terms of blocks) that funds are distributed out from the
+   * x/protocolpool module.
+   */
+  distribution_frequency?: string;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/Params";
+  value: ParamsAmino;
+}
+/** Params defines the parameters for the protocolpool module. */
+export interface ParamsSDKType {
+  enabled_distribution_denoms: string[];
+  distribution_frequency: bigint;
+}
+function createBaseContinuousFund(): ContinuousFund {
+  return {
+    recipient: "",
+    percentage: "",
+    expiry: undefined
+  };
+}
+export const ContinuousFund = {
+  typeUrl: "/cosmos.protocolpool.v1.ContinuousFund",
+  encode(message: ContinuousFund, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.recipient !== "") {
+      writer.uint32(10).string(message.recipient);
+    }
+    if (message.percentage !== "") {
+      writer.uint32(18).string(Decimal.fromUserInput(message.percentage, 18).atomics);
+    }
+    if (message.expiry !== undefined) {
+      Timestamp.encode(toTimestamp(message.expiry), writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ContinuousFund {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContinuousFund();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.recipient = reader.string();
+          break;
+        case 2:
+          message.percentage = Decimal.fromAtomics(reader.string(), 18).toString();
+          break;
+        case 3:
+          message.expiry = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ContinuousFund>): ContinuousFund {
+    const message = createBaseContinuousFund();
+    message.recipient = object.recipient ?? "";
+    message.percentage = object.percentage ?? "";
+    message.expiry = object.expiry ?? undefined;
+    return message;
+  },
+  fromAmino(object: ContinuousFundAmino): ContinuousFund {
+    const message = createBaseContinuousFund();
+    if (object.recipient !== undefined && object.recipient !== null) {
+      message.recipient = object.recipient;
+    }
+    if (object.percentage !== undefined && object.percentage !== null) {
+      message.percentage = object.percentage;
+    }
+    if (object.expiry !== undefined && object.expiry !== null) {
+      message.expiry = fromTimestamp(Timestamp.fromAmino(object.expiry));
+    }
+    return message;
+  },
+  toAmino(message: ContinuousFund): ContinuousFundAmino {
+    const obj: any = {};
+    obj.recipient = message.recipient === "" ? undefined : message.recipient;
+    obj.percentage = message.percentage === "" ? undefined : message.percentage;
+    obj.expiry = message.expiry ? Timestamp.toAmino(toTimestamp(message.expiry)) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ContinuousFundAminoMsg): ContinuousFund {
+    return ContinuousFund.fromAmino(object.value);
+  },
+  toAminoMsg(message: ContinuousFund): ContinuousFundAminoMsg {
+    return {
+      type: "cosmos-sdk/ContinuousFund",
+      value: ContinuousFund.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ContinuousFundProtoMsg): ContinuousFund {
+    return ContinuousFund.decode(message.value);
+  },
+  toProto(message: ContinuousFund): Uint8Array {
+    return ContinuousFund.encode(message).finish();
+  },
+  toProtoMsg(message: ContinuousFund): ContinuousFundProtoMsg {
+    return {
+      typeUrl: "/cosmos.protocolpool.v1.ContinuousFund",
+      value: ContinuousFund.encode(message).finish()
+    };
+  }
+};
+function createBaseParams(): Params {
+  return {
+    enabledDistributionDenoms: [],
+    distributionFrequency: BigInt(0)
+  };
+}
+export const Params = {
+  typeUrl: "/cosmos.protocolpool.v1.Params",
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.enabledDistributionDenoms) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.distributionFrequency !== BigInt(0)) {
+      writer.uint32(16).uint64(message.distributionFrequency);
+    }
+    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.enabledDistributionDenoms.push(reader.string());
+          break;
+        case 2:
+          message.distributionFrequency = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Params>): Params {
+    const message = createBaseParams();
+    message.enabledDistributionDenoms = object.enabledDistributionDenoms?.map(e => e) || [];
+    message.distributionFrequency = object.distributionFrequency !== undefined && object.distributionFrequency !== null ? BigInt(object.distributionFrequency.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    message.enabledDistributionDenoms = object.enabled_distribution_denoms?.map(e => e) || [];
+    if (object.distribution_frequency !== undefined && object.distribution_frequency !== null) {
+      message.distributionFrequency = BigInt(object.distribution_frequency);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    if (message.enabledDistributionDenoms) {
+      obj.enabled_distribution_denoms = message.enabledDistributionDenoms.map(e => e);
+    } else {
+      obj.enabled_distribution_denoms = message.enabledDistributionDenoms;
+    }
+    obj.distribution_frequency = message.distributionFrequency !== BigInt(0) ? message.distributionFrequency?.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.protocolpool.v1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};

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

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

package/types/cosmos/reflection/v1/reflection.ts

@@ -0,0 +1,178 @@
+//@ts-nocheck
+import { FileDescriptorProto, FileDescriptorProtoAmino, FileDescriptorProtoSDKType } from "../../../google/protobuf/descriptor";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** FileDescriptorsRequest is the Query/FileDescriptors request type. */
+export interface FileDescriptorsRequest {}
+export interface FileDescriptorsRequestProtoMsg {
+  typeUrl: "/cosmos.reflection.v1.FileDescriptorsRequest";
+  value: Uint8Array;
+}
+/**
+ * FileDescriptorsRequest is the Query/FileDescriptors request type.
+ * @name FileDescriptorsRequestAmino
+ * @package cosmos.reflection.v1
+ * @see proto type: cosmos.reflection.v1.FileDescriptorsRequest
+ */
+export interface FileDescriptorsRequestAmino {}
+export interface FileDescriptorsRequestAminoMsg {
+  type: "cosmos-sdk/FileDescriptorsRequest";
+  value: FileDescriptorsRequestAmino;
+}
+/** FileDescriptorsRequest is the Query/FileDescriptors request type. */
+export interface FileDescriptorsRequestSDKType {}
+/** FileDescriptorsResponse is the Query/FileDescriptors response type. */
+export interface FileDescriptorsResponse {
+  /** files is the file descriptors. */
+  files: FileDescriptorProto[];
+}
+export interface FileDescriptorsResponseProtoMsg {
+  typeUrl: "/cosmos.reflection.v1.FileDescriptorsResponse";
+  value: Uint8Array;
+}
+/**
+ * FileDescriptorsResponse is the Query/FileDescriptors response type.
+ * @name FileDescriptorsResponseAmino
+ * @package cosmos.reflection.v1
+ * @see proto type: cosmos.reflection.v1.FileDescriptorsResponse
+ */
+export interface FileDescriptorsResponseAmino {
+  /**
+   * files is the file descriptors.
+   */
+  files?: FileDescriptorProtoAmino[];
+}
+export interface FileDescriptorsResponseAminoMsg {
+  type: "cosmos-sdk/FileDescriptorsResponse";
+  value: FileDescriptorsResponseAmino;
+}
+/** FileDescriptorsResponse is the Query/FileDescriptors response type. */
+export interface FileDescriptorsResponseSDKType {
+  files: FileDescriptorProtoSDKType[];
+}
+function createBaseFileDescriptorsRequest(): FileDescriptorsRequest {
+  return {};
+}
+export const FileDescriptorsRequest = {
+  typeUrl: "/cosmos.reflection.v1.FileDescriptorsRequest",
+  encode(_: FileDescriptorsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): FileDescriptorsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDescriptorsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<FileDescriptorsRequest>): FileDescriptorsRequest {
+    const message = createBaseFileDescriptorsRequest();
+    return message;
+  },
+  fromAmino(_: FileDescriptorsRequestAmino): FileDescriptorsRequest {
+    const message = createBaseFileDescriptorsRequest();
+    return message;
+  },
+  toAmino(_: FileDescriptorsRequest): FileDescriptorsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: FileDescriptorsRequestAminoMsg): FileDescriptorsRequest {
+    return FileDescriptorsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: FileDescriptorsRequest): FileDescriptorsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/FileDescriptorsRequest",
+      value: FileDescriptorsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: FileDescriptorsRequestProtoMsg): FileDescriptorsRequest {
+    return FileDescriptorsRequest.decode(message.value);
+  },
+  toProto(message: FileDescriptorsRequest): Uint8Array {
+    return FileDescriptorsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: FileDescriptorsRequest): FileDescriptorsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.reflection.v1.FileDescriptorsRequest",
+      value: FileDescriptorsRequest.encode(message).finish()
+    };
+  }
+};
+function createBaseFileDescriptorsResponse(): FileDescriptorsResponse {
+  return {
+    files: []
+  };
+}
+export const FileDescriptorsResponse = {
+  typeUrl: "/cosmos.reflection.v1.FileDescriptorsResponse",
+  encode(message: FileDescriptorsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.files) {
+      FileDescriptorProto.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): FileDescriptorsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileDescriptorsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.files.push(FileDescriptorProto.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<FileDescriptorsResponse>): FileDescriptorsResponse {
+    const message = createBaseFileDescriptorsResponse();
+    message.files = object.files?.map(e => FileDescriptorProto.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: FileDescriptorsResponseAmino): FileDescriptorsResponse {
+    const message = createBaseFileDescriptorsResponse();
+    message.files = object.files?.map(e => FileDescriptorProto.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: FileDescriptorsResponse): FileDescriptorsResponseAmino {
+    const obj: any = {};
+    if (message.files) {
+      obj.files = message.files.map(e => e ? FileDescriptorProto.toAmino(e) : undefined);
+    } else {
+      obj.files = message.files;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: FileDescriptorsResponseAminoMsg): FileDescriptorsResponse {
+    return FileDescriptorsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: FileDescriptorsResponse): FileDescriptorsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/FileDescriptorsResponse",
+      value: FileDescriptorsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: FileDescriptorsResponseProtoMsg): FileDescriptorsResponse {
+    return FileDescriptorsResponse.decode(message.value);
+  },
+  toProto(message: FileDescriptorsResponse): Uint8Array {
+    return FileDescriptorsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: FileDescriptorsResponse): FileDescriptorsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.reflection.v1.FileDescriptorsResponse",
+      value: FileDescriptorsResponse.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/rpc.query.ts

@@ -0,0 +1,90 @@
+//@ts-nocheck
+import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({
+  rpcEndpoint
+}: {
+  rpcEndpoint: string | HttpEndpoint;
+}) => {
+  const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+  const client = new QueryClient(tmClient);
+  return {
+    cosmos: {
+      app: {
+        v1alpha1: (await import("./app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      auth: {
+        v1beta1: (await import("./auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      authz: {
+        v1beta1: (await import("./authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      autocli: {
+        v1: (await import("./autocli/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("./bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      base: {
+        node: {
+          v1beta1: (await import("./base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        },
+        tendermint: {
+          v1beta1: (await import("./base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
+      circuit: {
+        v1: (await import("./circuit/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      consensus: {
+        v1: (await import("./consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      counter: {
+        v1: (await import("./counter/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("./distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      epochs: {
+        v1beta1: (await import("./epochs/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      evidence: {
+        v1beta1: (await import("./evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feegrant: {
+        v1beta1: (await import("./feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      gov: {
+        v1: (await import("./gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+        v1beta1: (await import("./gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      group: {
+        v1: (await import("./group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      mint: {
+        v1beta1: (await import("./mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      nft: {
+        v1beta1: (await import("./nft/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      params: {
+        v1beta1: (await import("./params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      protocolpool: {
+        v1: (await import("./protocolpool/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      slashing: {
+        v1beta1: (await import("./slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      staking: {
+        v1beta1: (await import("./staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("./tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("./upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      }
+    }
+  };
+};

package/types/cosmos/rpc.tx.ts

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { Rpc } from "../helpers";
+export const createRPCMsgClient = async ({
+  rpc
+}: {
+  rpc: Rpc;
+}) => ({
+  cosmos: {
+    auth: {
+      v1beta1: new (await import("./auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    authz: {
+      v1beta1: new (await import("./authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    bank: {
+      v1beta1: new (await import("./bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    benchmark: {
+      v1: new (await import("./benchmark/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    circuit: {
+      v1: new (await import("./circuit/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    consensus: {
+      v1: new (await import("./consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    counter: {
+      v1: new (await import("./counter/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    crisis: {
+      v1beta1: new (await import("./crisis/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    distribution: {
+      v1beta1: new (await import("./distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    evidence: {
+      v1beta1: new (await import("./evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feegrant: {
+      v1beta1: new (await import("./feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    gov: {
+      v1: new (await import("./gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+      v1beta1: new (await import("./gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    group: {
+      v1: new (await import("./group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    mint: {
+      v1beta1: new (await import("./mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    nft: {
+      v1beta1: new (await import("./nft/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    protocolpool: {
+      v1: new (await import("./protocolpool/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    slashing: {
+      v1beta1: new (await import("./slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    staking: {
+      v1beta1: new (await import("./staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    upgrade: {
+      v1beta1: new (await import("./upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    vesting: {
+      v1beta1: new (await import("./vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  }
+});