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

package/types/ibc/lightclients/wasm/v1/wasm.ts

@@ -0,0 +1,444 @@
+//@ts-nocheck
+import { Height, HeightAmino, HeightSDKType } from "../../../core/client/v1/client";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/** Wasm light client's Client state */
+export interface ClientState {
+  /**
+   * bytes encoding the client state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: Uint8Array;
+  checksum: Uint8Array;
+  latestHeight: Height;
+}
+export interface ClientStateProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientState";
+  value: Uint8Array;
+}
+/**
+ * Wasm light client's Client state
+ * @name ClientStateAmino
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ClientState
+ */
+export interface ClientStateAmino {
+  /**
+   * bytes encoding the client state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data?: string;
+  checksum?: string;
+  latest_height?: HeightAmino;
+}
+export interface ClientStateAminoMsg {
+  type: "cosmos-sdk/ClientState";
+  value: ClientStateAmino;
+}
+/** Wasm light client's Client state */
+export interface ClientStateSDKType {
+  data: Uint8Array;
+  checksum: Uint8Array;
+  latest_height: HeightSDKType;
+}
+/** Wasm light client's ConsensusState */
+export interface ConsensusState {
+  /**
+   * bytes encoding the consensus state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data: Uint8Array;
+}
+export interface ConsensusStateProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState";
+  value: Uint8Array;
+}
+/**
+ * Wasm light client's ConsensusState
+ * @name ConsensusStateAmino
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ConsensusState
+ */
+export interface ConsensusStateAmino {
+  /**
+   * bytes encoding the consensus state of the underlying light client
+   * implemented as a Wasm contract.
+   */
+  data?: string;
+}
+export interface ConsensusStateAminoMsg {
+  type: "cosmos-sdk/ConsensusState";
+  value: ConsensusStateAmino;
+}
+/** Wasm light client's ConsensusState */
+export interface ConsensusStateSDKType {
+  data: Uint8Array;
+}
+/** Wasm light client message (either header(s) or misbehaviour) */
+export interface ClientMessage {
+  data: Uint8Array;
+}
+export interface ClientMessageProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage";
+  value: Uint8Array;
+}
+/**
+ * Wasm light client message (either header(s) or misbehaviour)
+ * @name ClientMessageAmino
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ClientMessage
+ */
+export interface ClientMessageAmino {
+  data?: string;
+}
+export interface ClientMessageAminoMsg {
+  type: "cosmos-sdk/ClientMessage";
+  value: ClientMessageAmino;
+}
+/** Wasm light client message (either header(s) or misbehaviour) */
+export interface ClientMessageSDKType {
+  data: Uint8Array;
+}
+/**
+ * Checksums defines a list of all checksums that are stored
+ * 
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ */
+/** @deprecated */
+export interface Checksums {
+  checksums: Uint8Array[];
+}
+export interface ChecksumsProtoMsg {
+  typeUrl: "/ibc.lightclients.wasm.v1.Checksums";
+  value: Uint8Array;
+}
+/**
+ * Checksums defines a list of all checksums that are stored
+ * 
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ * @name ChecksumsAmino
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.Checksums
+ * @deprecated
+ */
+export interface ChecksumsAmino {
+  checksums?: string[];
+}
+export interface ChecksumsAminoMsg {
+  type: "cosmos-sdk/Checksums";
+  value: ChecksumsAmino;
+}
+/**
+ * Checksums defines a list of all checksums that are stored
+ * 
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ */
+/** @deprecated */
+export interface ChecksumsSDKType {
+  checksums: Uint8Array[];
+}
+function createBaseClientState(): ClientState {
+  return {
+    data: new Uint8Array(),
+    checksum: new Uint8Array(),
+    latestHeight: Height.fromPartial({})
+  };
+}
+export const ClientState = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientState",
+  encode(message: ClientState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    if (message.checksum.length !== 0) {
+      writer.uint32(18).bytes(message.checksum);
+    }
+    if (message.latestHeight !== undefined) {
+      Height.encode(message.latestHeight, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ClientState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClientState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        case 2:
+          message.checksum = reader.bytes();
+          break;
+        case 3:
+          message.latestHeight = Height.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ClientState>): ClientState {
+    const message = createBaseClientState();
+    message.data = object.data ?? new Uint8Array();
+    message.checksum = object.checksum ?? new Uint8Array();
+    message.latestHeight = object.latestHeight !== undefined && object.latestHeight !== null ? Height.fromPartial(object.latestHeight) : undefined;
+    return message;
+  },
+  fromAmino(object: ClientStateAmino): ClientState {
+    const message = createBaseClientState();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    if (object.checksum !== undefined && object.checksum !== null) {
+      message.checksum = bytesFromBase64(object.checksum);
+    }
+    if (object.latest_height !== undefined && object.latest_height !== null) {
+      message.latestHeight = Height.fromAmino(object.latest_height);
+    }
+    return message;
+  },
+  toAmino(message: ClientState): ClientStateAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    obj.checksum = message.checksum ? base64FromBytes(message.checksum) : undefined;
+    obj.latest_height = message.latestHeight ? Height.toAmino(message.latestHeight) : {};
+    return obj;
+  },
+  fromAminoMsg(object: ClientStateAminoMsg): ClientState {
+    return ClientState.fromAmino(object.value);
+  },
+  toAminoMsg(message: ClientState): ClientStateAminoMsg {
+    return {
+      type: "cosmos-sdk/ClientState",
+      value: ClientState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ClientStateProtoMsg): ClientState {
+    return ClientState.decode(message.value);
+  },
+  toProto(message: ClientState): Uint8Array {
+    return ClientState.encode(message).finish();
+  },
+  toProtoMsg(message: ClientState): ClientStateProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ClientState",
+      value: ClientState.encode(message).finish()
+    };
+  }
+};
+function createBaseConsensusState(): ConsensusState {
+  return {
+    data: new Uint8Array()
+  };
+}
+export const ConsensusState = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState",
+  encode(message: ConsensusState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ConsensusState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsensusState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ConsensusState>): ConsensusState {
+    const message = createBaseConsensusState();
+    message.data = object.data ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: ConsensusStateAmino): ConsensusState {
+    const message = createBaseConsensusState();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    return message;
+  },
+  toAmino(message: ConsensusState): ConsensusStateAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ConsensusStateAminoMsg): ConsensusState {
+    return ConsensusState.fromAmino(object.value);
+  },
+  toAminoMsg(message: ConsensusState): ConsensusStateAminoMsg {
+    return {
+      type: "cosmos-sdk/ConsensusState",
+      value: ConsensusState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ConsensusStateProtoMsg): ConsensusState {
+    return ConsensusState.decode(message.value);
+  },
+  toProto(message: ConsensusState): Uint8Array {
+    return ConsensusState.encode(message).finish();
+  },
+  toProtoMsg(message: ConsensusState): ConsensusStateProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState",
+      value: ConsensusState.encode(message).finish()
+    };
+  }
+};
+function createBaseClientMessage(): ClientMessage {
+  return {
+    data: new Uint8Array()
+  };
+}
+export const ClientMessage = {
+  typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage",
+  encode(message: ClientMessage, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ClientMessage {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClientMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<ClientMessage>): ClientMessage {
+    const message = createBaseClientMessage();
+    message.data = object.data ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: ClientMessageAmino): ClientMessage {
+    const message = createBaseClientMessage();
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    return message;
+  },
+  toAmino(message: ClientMessage): ClientMessageAmino {
+    const obj: any = {};
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ClientMessageAminoMsg): ClientMessage {
+    return ClientMessage.fromAmino(object.value);
+  },
+  toAminoMsg(message: ClientMessage): ClientMessageAminoMsg {
+    return {
+      type: "cosmos-sdk/ClientMessage",
+      value: ClientMessage.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ClientMessageProtoMsg): ClientMessage {
+    return ClientMessage.decode(message.value);
+  },
+  toProto(message: ClientMessage): Uint8Array {
+    return ClientMessage.encode(message).finish();
+  },
+  toProtoMsg(message: ClientMessage): ClientMessageProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage",
+      value: ClientMessage.encode(message).finish()
+    };
+  }
+};
+function createBaseChecksums(): Checksums {
+  return {
+    checksums: []
+  };
+}
+export const Checksums = {
+  typeUrl: "/ibc.lightclients.wasm.v1.Checksums",
+  encode(message: Checksums, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.checksums) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Checksums {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChecksums();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.checksums.push(reader.bytes());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Checksums>): Checksums {
+    const message = createBaseChecksums();
+    message.checksums = object.checksums?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ChecksumsAmino): Checksums {
+    const message = createBaseChecksums();
+    message.checksums = object.checksums?.map(e => bytesFromBase64(e)) || [];
+    return message;
+  },
+  toAmino(message: Checksums): ChecksumsAmino {
+    const obj: any = {};
+    if (message.checksums) {
+      obj.checksums = message.checksums.map(e => base64FromBytes(e));
+    } else {
+      obj.checksums = message.checksums;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ChecksumsAminoMsg): Checksums {
+    return Checksums.fromAmino(object.value);
+  },
+  toAminoMsg(message: Checksums): ChecksumsAminoMsg {
+    return {
+      type: "cosmos-sdk/Checksums",
+      value: Checksums.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ChecksumsProtoMsg): Checksums {
+    return Checksums.decode(message.value);
+  },
+  toProto(message: Checksums): Uint8Array {
+    return Checksums.encode(message).finish();
+  },
+  toProtoMsg(message: Checksums): ChecksumsProtoMsg {
+    return {
+      typeUrl: "/ibc.lightclients.wasm.v1.Checksums",
+      value: Checksums.encode(message).finish()
+    };
+  }
+};

package/types/ibc/rpc.query.ts

@@ -0,0 +1,123 @@
+//@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("../cosmos/app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      auth: {
+        v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      authz: {
+        v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      autocli: {
+        v1: (await import("../cosmos/autocli/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      base: {
+        node: {
+          v1beta1: (await import("../cosmos/base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        },
+        tendermint: {
+          v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
+      circuit: {
+        v1: (await import("../cosmos/circuit/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      consensus: {
+        v1: (await import("../cosmos/consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      counter: {
+        v1: (await import("../cosmos/counter/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      epochs: {
+        v1beta1: (await import("../cosmos/epochs/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      evidence: {
+        v1beta1: (await import("../cosmos/evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feegrant: {
+        v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      gov: {
+        v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+        v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      group: {
+        v1: (await import("../cosmos/group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      mint: {
+        v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      nft: {
+        v1beta1: (await import("../cosmos/nft/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      params: {
+        v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      protocolpool: {
+        v1: (await import("../cosmos/protocolpool/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      slashing: {
+        v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      staking: {
+        v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      }
+    },
+    ibc: {
+      applications: {
+        interchain_accounts: {
+          controller: {
+            v1: (await import("./applications/interchain_accounts/controller/v1/query.rpc.Query")).createRpcQueryExtension(client)
+          },
+          host: {
+            v1: (await import("./applications/interchain_accounts/host/v1/query.rpc.Query")).createRpcQueryExtension(client)
+          }
+        },
+        transfer: {
+          v1: (await import("./applications/transfer/v1/query.rpc.Query")).createRpcQueryExtension(client)
+        }
+      },
+      core: {
+        channel: {
+          v1: (await import("./core/channel/v1/query.rpc.Query")).createRpcQueryExtension(client),
+          v2: (await import("./core/channel/v2/query.rpc.Query")).createRpcQueryExtension(client)
+        },
+        client: {
+          v1: (await import("./core/client/v1/query.rpc.Query")).createRpcQueryExtension(client),
+          v2: (await import("./core/client/v2/query.rpc.Query")).createRpcQueryExtension(client)
+        },
+        connection: {
+          v1: (await import("./core/connection/v1/query.rpc.Query")).createRpcQueryExtension(client)
+        }
+      },
+      lightclients: {
+        wasm: {
+          v1: (await import("./lightclients/wasm/v1/query.rpc.Query")).createRpcQueryExtension(client)
+        }
+      }
+    }
+  };
+};

package/types/ibc/rpc.tx.ts

@@ -0,0 +1,104 @@
+//@ts-nocheck
+import { Rpc } from "../helpers";
+export const createRPCMsgClient = async ({
+  rpc
+}: {
+  rpc: Rpc;
+}) => ({
+  cosmos: {
+    auth: {
+      v1beta1: new (await import("../cosmos/auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    authz: {
+      v1beta1: new (await import("../cosmos/authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    bank: {
+      v1beta1: new (await import("../cosmos/bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    benchmark: {
+      v1: new (await import("../cosmos/benchmark/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    circuit: {
+      v1: new (await import("../cosmos/circuit/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    consensus: {
+      v1: new (await import("../cosmos/consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    counter: {
+      v1: new (await import("../cosmos/counter/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    crisis: {
+      v1beta1: new (await import("../cosmos/crisis/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    distribution: {
+      v1beta1: new (await import("../cosmos/distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    evidence: {
+      v1beta1: new (await import("../cosmos/evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feegrant: {
+      v1beta1: new (await import("../cosmos/feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    gov: {
+      v1: new (await import("../cosmos/gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+      v1beta1: new (await import("../cosmos/gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    group: {
+      v1: new (await import("../cosmos/group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    mint: {
+      v1beta1: new (await import("../cosmos/mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    nft: {
+      v1beta1: new (await import("../cosmos/nft/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    protocolpool: {
+      v1: new (await import("../cosmos/protocolpool/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    slashing: {
+      v1beta1: new (await import("../cosmos/slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    staking: {
+      v1beta1: new (await import("../cosmos/staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    upgrade: {
+      v1beta1: new (await import("../cosmos/upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    vesting: {
+      v1beta1: new (await import("../cosmos/vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  },
+  ibc: {
+    applications: {
+      interchain_accounts: {
+        controller: {
+          v1: new (await import("./applications/interchain_accounts/controller/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        host: {
+          v1: new (await import("./applications/interchain_accounts/host/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+      },
+      transfer: {
+        v1: new (await import("./applications/transfer/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+      }
+    },
+    core: {
+      channel: {
+        v1: new (await import("./core/channel/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+        v2: new (await import("./core/channel/v2/tx.rpc.msg")).MsgClientImpl(rpc)
+      },
+      client: {
+        v1: new (await import("./core/client/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+        v2: new (await import("./core/client/v2/tx.rpc.msg")).MsgClientImpl(rpc)
+      },
+      connection: {
+        v1: new (await import("./core/connection/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+      }
+    },
+    lightclients: {
+      wasm: {
+        v1: new (await import("./lightclients/wasm/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+      }
+    }
+  }
+});

package/types/index.ts

@@ -0,0 +1,25 @@
+//@ts-nocheck
+/**
+  * This file and any referenced files were automatically generated by @cosmology/telescope@1.12.20
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+    * and run the transpile command or npm scripts command that is used to regenerate this bundle.
+  */
+ 
+export * from "./abstractaccount/bundle";
+export * from "./abstractaccount/client";
+export * from "./amino/bundle";
+export * from "./cosmos_proto/bundle";
+export * from "./cosmos/bundle";
+export * from "./cosmos/client";
+export * from "./cosmwasm/bundle";
+export * from "./cosmwasm/client";
+export * from "./gogoproto/bundle";
+export * from "./google/bundle";
+export * from "./ibc/bundle";
+export * from "./ibc/client";
+export * from "./tendermint/bundle";
+export * from "./xion/bundle";
+export * from "./xion/client";
+export * from "./varint";
+export * from "./utf8";
+export * from "./binary";