juno-network 0.15.0 → 0.17.0

package/src/codegen/juno/mint/tx.amino.ts

@@ -0,0 +1,8 @@
+import { MsgUpdateParams } from "./tx";
+export const AminoConverter = {
+  "/juno.mint.MsgUpdateParams": {
+    aminoType: "/juno.mint.MsgUpdateParams",
+    toAmino: MsgUpdateParams.toAmino,
+    fromAmino: MsgUpdateParams.fromAmino
+  }
+};

package/src/codegen/juno/mint/tx.registry.ts

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

package/src/codegen/juno/mint/tx.rpc.msg.ts

@@ -0,0 +1,25 @@
+import { Rpc } from "../../helpers";
+import { BinaryReader } from "../../binary";
+import { MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+/** Msg defines the x/mint Msg service. */
+export interface Msg {
+  /**
+   * UpdateParams defines a governance operation for updating the x/mint module
+   * parameters. The authority is hard-coded to the x/gov module account.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.updateParams = this.updateParams.bind(this);
+  }
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("juno.mint.Msg", "UpdateParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+  }
+}

package/src/codegen/juno/mint/tx.ts

@@ -0,0 +1,203 @@
+import { Params, ParamsAmino, ParamsSDKType } from "./mint";
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParams {
+  /** authority is the address of the governance account. */
+  authority: string;
+  /**
+   * params defines the x/mint parameters to update.
+   * 
+   * NOTE: All parameters must be supplied.
+   */
+  params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+  typeUrl: "/juno.mint.MsgUpdateParams";
+  value: Uint8Array;
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsAmino {
+  /** authority is the address of the governance account. */
+  authority?: string;
+  /**
+   * params defines the x/mint parameters to update.
+   * 
+   * NOTE: All parameters must be supplied.
+   */
+  params?: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+  type: "/juno.mint.MsgUpdateParams";
+  value: MsgUpdateParamsAmino;
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsSDKType {
+  authority: string;
+  params: ParamsSDKType;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsResponse {}
+export interface MsgUpdateParamsResponseProtoMsg {
+  typeUrl: "/juno.mint.MsgUpdateParamsResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsResponseAmino {}
+export interface MsgUpdateParamsResponseAminoMsg {
+  type: "/juno.mint.MsgUpdateParamsResponse";
+  value: MsgUpdateParamsResponseAmino;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * 
+ * Since: cosmos-sdk 0.47
+ */
+export interface MsgUpdateParamsResponseSDKType {}
+function createBaseMsgUpdateParams(): MsgUpdateParams {
+  return {
+    authority: "",
+    params: Params.fromPartial({})
+  };
+}
+export const MsgUpdateParams = {
+  typeUrl: "/juno.mint.MsgUpdateParams",
+  encode(message: MsgUpdateParams, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParams();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<MsgUpdateParams>): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino {
+    const obj: any = {};
+    obj.authority = message.authority;
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams {
+    return MsgUpdateParams.fromAmino(object.value);
+  },
+  fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams {
+    return MsgUpdateParams.decode(message.value);
+  },
+  toProto(message: MsgUpdateParams): Uint8Array {
+    return MsgUpdateParams.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg {
+    return {
+      typeUrl: "/juno.mint.MsgUpdateParams",
+      value: MsgUpdateParams.encode(message).finish()
+    };
+  }
+};
+function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse {
+  return {};
+}
+export const MsgUpdateParamsResponse = {
+  typeUrl: "/juno.mint.MsgUpdateParamsResponse",
+  encode(_: MsgUpdateParamsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParamsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: Partial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  },
+  fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  },
+  toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse {
+    return MsgUpdateParamsResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse {
+    return MsgUpdateParamsResponse.decode(message.value);
+  },
+  toProto(message: MsgUpdateParamsResponse): Uint8Array {
+    return MsgUpdateParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg {
+    return {
+      typeUrl: "/juno.mint.MsgUpdateParamsResponse",
+      value: MsgUpdateParamsResponse.encode(message).finish()
+    };
+  }
+};

package/src/codegen/juno/rpc.query.ts

@@ -9,19 +9,51 @@ export const createRPCQueryClient = async ({
   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)
       },
       bank: {
         v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
+      base: {
+        tendermint: {
+          v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
       distribution: {
         v1beta1: (await import("../cosmos/distribution/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)
+      },
+      slashing: {
+        v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       staking: {
         v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
@@ -33,6 +65,18 @@ export const createRPCQueryClient = async ({
       }
     },
     juno: {
+      clock: {
+        v1: (await import("./clock/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      cwhooks: {
+        v1: (await import("./cwhooks/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      drip: {
+        v1: (await import("./drip/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feepay: {
+        v1: (await import("./feepay/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       feeshare: {
         v1: (await import("./feeshare/v1/query.rpc.Query")).createRpcQueryExtension(client)
       },

package/src/codegen/juno/rpc.tx.ts

@@ -11,23 +11,57 @@ export const createRPCMsgClient = async ({
     bank: {
       v1beta1: new (await import("../cosmos/bank/v1beta1/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)
+    },
+    nft: {
+      v1beta1: new (await import("../cosmos/nft/v1beta1/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)
     }
   },
   juno: {
+    clock: {
+      v1: new (await import("./clock/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    cwhooks: {
+      v1: new (await import("./cwhooks/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    drip: {
+      v1: new (await import("./drip/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feepay: {
+      v1: new (await import("./feepay/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
     feeshare: {
       v1: new (await import("./feeshare/v1/tx.rpc.msg")).MsgClientImpl(rpc)
-    }
+    },
+    mint: new (await import("./mint/tx.rpc.msg")).MsgClientImpl(rpc)
   }
 });

package/src/codegen/osmosis/bundle.ts

@@ -1,32 +1,34 @@
-import * as _89 from "./tokenfactory/v1beta1/authorityMetadata";
-import * as _90 from "./tokenfactory/v1beta1/genesis";
-import * as _91 from "./tokenfactory/v1beta1/params";
-import * as _92 from "./tokenfactory/v1beta1/query";
-import * as _93 from "./tokenfactory/v1beta1/tx";
-import * as _176 from "./tokenfactory/v1beta1/tx.amino";
-import * as _177 from "./tokenfactory/v1beta1/tx.registry";
-import * as _178 from "./tokenfactory/v1beta1/query.lcd";
-import * as _179 from "./tokenfactory/v1beta1/query.rpc.Query";
-import * as _180 from "./tokenfactory/v1beta1/tx.rpc.msg";
-import * as _197 from "./lcd";
-import * as _198 from "./rpc.query";
-import * as _199 from "./rpc.tx";
+import * as _157 from "./tokenfactory/v1beta1/authorityMetadata";
+import * as _158 from "./tokenfactory/v1beta1/genesis";
+import * as _159 from "./tokenfactory/v1beta1/params";
+import * as _160 from "./tokenfactory/v1beta1/query";
+import * as _161 from "./tokenfactory/v1beta1/tx";
+import * as _310 from "./tokenfactory/v1beta1/tx.amino";
+import * as _311 from "./tokenfactory/v1beta1/tx.registry";
+import * as _312 from "./tokenfactory/v1beta1/query.lcd";
+import * as _313 from "./tokenfactory/v1beta1/query.rpc.Query";
+import * as _314 from "./tokenfactory/v1beta1/tx.rpc.msg";
+import * as _331 from "./lcd";
+import * as _332 from "./rpc.query";
+import * as _333 from "./rpc.tx";
 export namespace osmosis {
   export namespace tokenfactory {
-    export const v1beta1 = { ..._89,
-      ..._90,
-      ..._91,
-      ..._92,
-      ..._93,
-      ..._176,
-      ..._177,
-      ..._178,
-      ..._179,
-      ..._180
+    export const v1beta1 = {
+      ..._157,
+      ..._158,
+      ..._159,
+      ..._160,
+      ..._161,
+      ..._310,
+      ..._311,
+      ..._312,
+      ..._313,
+      ..._314
     };
   }
-  export const ClientFactory = { ..._197,
-    ..._198,
-    ..._199
+  export const ClientFactory = {
+    ..._331,
+    ..._332,
+    ..._333
   };
 }

package/src/codegen/osmosis/client.ts

@@ -3,7 +3,8 @@ import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs
 import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
 import * as osmosisTokenfactoryV1beta1TxRegistry from "./tokenfactory/v1beta1/tx.registry";
 import * as osmosisTokenfactoryV1beta1TxAmino from "./tokenfactory/v1beta1/tx.amino";
-export const osmosisAminoConverters = { ...osmosisTokenfactoryV1beta1TxAmino.AminoConverter
+export const osmosisAminoConverters = {
+  ...osmosisTokenfactoryV1beta1TxAmino.AminoConverter
 };
 export const osmosisProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...osmosisTokenfactoryV1beta1TxRegistry.registry];
 export const getSigningOsmosisClientOptions = ({
@@ -15,7 +16,8 @@ export const getSigningOsmosisClientOptions = ({
   aminoTypes: AminoTypes;
 } => {
   const registry = new Registry([...defaultTypes, ...osmosisProtoRegistry]);
-  const aminoTypes = new AminoTypes({ ...osmosisAminoConverters
+  const aminoTypes = new AminoTypes({
+    ...osmosisAminoConverters
   });
   return {
     registry,
@@ -38,7 +40,7 @@ export const getSigningOsmosisClient = async ({
     defaultTypes
   });
   const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
-    registry,
+    registry: (registry as any),
     aminoTypes
   });
   return client;

package/src/codegen/osmosis/lcd.ts

@@ -1,4 +1,4 @@
-import { LCDClient } from "@osmonauts/lcd";
+import { LCDClient } from "@cosmology/lcd";
 export const createLCDClient = async ({
   restEndpoint
 }: {
@@ -9,6 +9,11 @@ export const createLCDClient = async ({
   });
   return {
     cosmos: {
+      auth: {
+        v1beta1: new (await import("../cosmos/auth/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
       authz: {
         v1beta1: new (await import("../cosmos/authz/v1beta1/query.lcd")).LCDQueryClient({
           requestClient
@@ -19,11 +24,28 @@ export const createLCDClient = async ({
           requestClient
         })
       },
+      base: {
+        tendermint: {
+          v1beta1: new (await import("../cosmos/base/tendermint/v1beta1/query.lcd")).LCDQueryClient({
+            requestClient
+          })
+        }
+      },
       distribution: {
         v1beta1: new (await import("../cosmos/distribution/v1beta1/query.lcd")).LCDQueryClient({
           requestClient
         })
       },
+      evidence: {
+        v1beta1: new (await import("../cosmos/evidence/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      feegrant: {
+        v1beta1: new (await import("../cosmos/feegrant/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
       gov: {
         v1: new (await import("../cosmos/gov/v1/query.lcd")).LCDQueryClient({
           requestClient
@@ -32,6 +54,31 @@ export const createLCDClient = async ({
           requestClient
         })
       },
+      group: {
+        v1: new (await import("../cosmos/group/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      mint: {
+        v1beta1: new (await import("../cosmos/mint/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      nft: {
+        v1beta1: new (await import("../cosmos/nft/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      params: {
+        v1beta1: new (await import("../cosmos/params/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      slashing: {
+        v1beta1: new (await import("../cosmos/slashing/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
       staking: {
         v1beta1: new (await import("../cosmos/staking/v1beta1/query.lcd")).LCDQueryClient({
           requestClient

package/src/codegen/osmosis/rpc.query.ts

@@ -9,19 +9,51 @@ export const createRPCQueryClient = async ({
   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)
       },
       bank: {
         v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
+      base: {
+        tendermint: {
+          v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
       distribution: {
         v1beta1: (await import("../cosmos/distribution/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)
+      },
+      slashing: {
+        v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       staking: {
         v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },

package/src/codegen/osmosis/rpc.tx.ts

@@ -11,18 +11,39 @@ export const createRPCMsgClient = async ({
     bank: {
       v1beta1: new (await import("../cosmos/bank/v1beta1/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)
+    },
+    nft: {
+      v1beta1: new (await import("../cosmos/nft/v1beta1/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)
     }
   },
   osmosis: {