juno-network 0.15.1 → 0.18.0

package/src/codegen/cosmos_proto/bundle.ts

@@ -1,3 +1,4 @@
-import * as _1 from "./cosmos";
-export const cosmos_proto = { ..._1
+import * as _2 from "./cosmos";
+export const cosmos_proto = {
+  ..._2
 };

package/src/codegen/cosmos_proto/cosmos.ts

@@ -1,31 +1,23 @@
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../helpers";
+import { BinaryReader, BinaryWriter } from "../binary";
 export enum ScalarType {
   SCALAR_TYPE_UNSPECIFIED = 0,
   SCALAR_TYPE_STRING = 1,
   SCALAR_TYPE_BYTES = 2,
   UNRECOGNIZED = -1,
 }
-export enum ScalarTypeSDKType {
-  SCALAR_TYPE_UNSPECIFIED = 0,
-  SCALAR_TYPE_STRING = 1,
-  SCALAR_TYPE_BYTES = 2,
-  UNRECOGNIZED = -1,
-}
+export const ScalarTypeSDKType = ScalarType;
+export const ScalarTypeAmino = ScalarType;
 export function scalarTypeFromJSON(object: any): ScalarType {
   switch (object) {
     case 0:
     case "SCALAR_TYPE_UNSPECIFIED":
       return ScalarType.SCALAR_TYPE_UNSPECIFIED;
-
     case 1:
     case "SCALAR_TYPE_STRING":
       return ScalarType.SCALAR_TYPE_STRING;
-
     case 2:
     case "SCALAR_TYPE_BYTES":
       return ScalarType.SCALAR_TYPE_BYTES;
-
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -36,13 +28,10 @@ export function scalarTypeToJSON(object: ScalarType): string {
   switch (object) {
     case ScalarType.SCALAR_TYPE_UNSPECIFIED:
       return "SCALAR_TYPE_UNSPECIFIED";
-
     case ScalarType.SCALAR_TYPE_STRING:
       return "SCALAR_TYPE_STRING";
-
     case ScalarType.SCALAR_TYPE_BYTES:
       return "SCALAR_TYPE_BYTES";
-
     case ScalarType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -52,7 +41,6 @@ export function scalarTypeToJSON(object: ScalarType): string {
  * InterfaceDescriptor describes an interface type to be used with
  * accepts_interface and implements_interface and declared by declare_interface.
  */
-
 export interface InterfaceDescriptor {
   /**
    * name is the name of the interface. It should be a short-name (without
@@ -65,27 +53,40 @@ export interface InterfaceDescriptor {
    * description is a human-readable description of the interface and its
    * purpose.
    */
-
   description: string;
 }
+export interface InterfaceDescriptorProtoMsg {
+  typeUrl: "/cosmos_proto.InterfaceDescriptor";
+  value: Uint8Array;
+}
 /**
  * InterfaceDescriptor describes an interface type to be used with
  * accepts_interface and implements_interface and declared by declare_interface.
  */
-
-export interface InterfaceDescriptorSDKType {
+export interface InterfaceDescriptorAmino {
   /**
    * name is the name of the interface. It should be a short-name (without
    * a period) such that the fully qualified name of the interface will be
    * package.name, ex. for the package a.b and interface named C, the
    * fully-qualified name will be a.b.C.
    */
-  name: string;
+  name?: string;
   /**
    * description is a human-readable description of the interface and its
    * purpose.
    */
-
+  description?: string;
+}
+export interface InterfaceDescriptorAminoMsg {
+  type: "/cosmos_proto.InterfaceDescriptor";
+  value: InterfaceDescriptorAmino;
+}
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+export interface InterfaceDescriptorSDKType {
+  name: string;
   description: string;
 }
 /**
@@ -97,7 +98,6 @@ export interface InterfaceDescriptorSDKType {
  * valid syntactical representation for a given semantic meaning,
  * i.e. the encoding should be deterministic.
  */
-
 export interface ScalarDescriptor {
   /**
    * name is the name of the scalar. It should be a short-name (without
@@ -111,7 +111,6 @@ export interface ScalarDescriptor {
    * encoding format. For instance a big integer or decimal scalar should
    * specify precisely the expected encoding format.
    */
-
   description: string;
   /**
    * field_type is the type of field with which this scalar can be used.
@@ -119,9 +118,12 @@ export interface ScalarDescriptor {
    * encoding standards and simple and clear. Currently only string and
    * bytes fields are supported for scalars.
    */
-
   fieldType: ScalarType[];
 }
+export interface ScalarDescriptorProtoMsg {
+  typeUrl: "/cosmos_proto.ScalarDescriptor";
+  value: Uint8Array;
+}
 /**
  * ScalarDescriptor describes an scalar type to be used with
  * the scalar field option and declared by declare_scalar.
@@ -131,87 +133,121 @@ export interface ScalarDescriptor {
  * valid syntactical representation for a given semantic meaning,
  * i.e. the encoding should be deterministic.
  */
-
-export interface ScalarDescriptorSDKType {
+export interface ScalarDescriptorAmino {
   /**
    * name is the name of the scalar. It should be a short-name (without
    * a period) such that the fully qualified name of the scalar will be
    * package.name, ex. for the package a.b and scalar named C, the
    * fully-qualified name will be a.b.C.
    */
-  name: string;
+  name?: string;
   /**
    * description is a human-readable description of the scalar and its
    * encoding format. For instance a big integer or decimal scalar should
    * specify precisely the expected encoding format.
    */
-
-  description: string;
+  description?: string;
   /**
    * field_type is the type of field with which this scalar can be used.
    * Scalars can be used with one and only one type of field so that
    * encoding standards and simple and clear. Currently only string and
    * bytes fields are supported for scalars.
    */
-
-  field_type: ScalarTypeSDKType[];
+  field_type?: ScalarType[];
+}
+export interface ScalarDescriptorAminoMsg {
+  type: "/cosmos_proto.ScalarDescriptor";
+  value: ScalarDescriptorAmino;
+}
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ */
+export interface ScalarDescriptorSDKType {
+  name: string;
+  description: string;
+  field_type: ScalarType[];
 }
-
 function createBaseInterfaceDescriptor(): InterfaceDescriptor {
   return {
     name: "",
     description: ""
   };
 }
-
 export const InterfaceDescriptor = {
-  encode(message: InterfaceDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/cosmos_proto.InterfaceDescriptor",
+  encode(message: InterfaceDescriptor, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     if (message.name !== "") {
       writer.uint32(10).string(message.name);
     }
-
     if (message.description !== "") {
       writer.uint32(18).string(message.description);
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): InterfaceDescriptor {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): InterfaceDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInterfaceDescriptor();
-
     while (reader.pos < end) {
       const tag = reader.uint32();
-
       switch (tag >>> 3) {
         case 1:
           message.name = reader.string();
           break;
-
         case 2:
           message.description = reader.string();
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<InterfaceDescriptor>): InterfaceDescriptor {
+  fromPartial(object: Partial<InterfaceDescriptor>): InterfaceDescriptor {
     const message = createBaseInterfaceDescriptor();
     message.name = object.name ?? "";
     message.description = object.description ?? "";
     return message;
+  },
+  fromAmino(object: InterfaceDescriptorAmino): InterfaceDescriptor {
+    const message = createBaseInterfaceDescriptor();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    return message;
+  },
+  toAmino(message: InterfaceDescriptor): InterfaceDescriptorAmino {
+    const obj: any = {};
+    obj.name = message.name;
+    obj.description = message.description;
+    return obj;
+  },
+  fromAminoMsg(object: InterfaceDescriptorAminoMsg): InterfaceDescriptor {
+    return InterfaceDescriptor.fromAmino(object.value);
+  },
+  fromProtoMsg(message: InterfaceDescriptorProtoMsg): InterfaceDescriptor {
+    return InterfaceDescriptor.decode(message.value);
+  },
+  toProto(message: InterfaceDescriptor): Uint8Array {
+    return InterfaceDescriptor.encode(message).finish();
+  },
+  toProtoMsg(message: InterfaceDescriptor): InterfaceDescriptorProtoMsg {
+    return {
+      typeUrl: "/cosmos_proto.InterfaceDescriptor",
+      value: InterfaceDescriptor.encode(message).finish()
+    };
   }
-
 };
-
 function createBaseScalarDescriptor(): ScalarDescriptor {
   return {
     name: "",
@@ -219,72 +255,94 @@ function createBaseScalarDescriptor(): ScalarDescriptor {
     fieldType: []
   };
 }
-
 export const ScalarDescriptor = {
-  encode(message: ScalarDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/cosmos_proto.ScalarDescriptor",
+  encode(message: ScalarDescriptor, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
     if (message.name !== "") {
       writer.uint32(10).string(message.name);
     }
-
     if (message.description !== "") {
       writer.uint32(18).string(message.description);
     }
-
     writer.uint32(26).fork();
-
     for (const v of message.fieldType) {
       writer.int32(v);
     }
-
     writer.ldelim();
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): ScalarDescriptor {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): ScalarDescriptor {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseScalarDescriptor();
-
     while (reader.pos < end) {
       const tag = reader.uint32();
-
       switch (tag >>> 3) {
         case 1:
           message.name = reader.string();
           break;
-
         case 2:
           message.description = reader.string();
           break;
-
         case 3:
           if ((tag & 7) === 2) {
             const end2 = reader.uint32() + reader.pos;
-
             while (reader.pos < end2) {
               message.fieldType.push((reader.int32() as any));
             }
           } else {
             message.fieldType.push((reader.int32() as any));
           }
-
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<ScalarDescriptor>): ScalarDescriptor {
+  fromPartial(object: Partial<ScalarDescriptor>): ScalarDescriptor {
     const message = createBaseScalarDescriptor();
     message.name = object.name ?? "";
     message.description = object.description ?? "";
     message.fieldType = object.fieldType?.map(e => e) || [];
     return message;
+  },
+  fromAmino(object: ScalarDescriptorAmino): ScalarDescriptor {
+    const message = createBaseScalarDescriptor();
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    if (object.description !== undefined && object.description !== null) {
+      message.description = object.description;
+    }
+    message.fieldType = object.field_type?.map(e => scalarTypeFromJSON(e)) || [];
+    return message;
+  },
+  toAmino(message: ScalarDescriptor): ScalarDescriptorAmino {
+    const obj: any = {};
+    obj.name = message.name;
+    obj.description = message.description;
+    if (message.fieldType) {
+      obj.field_type = message.fieldType.map(e => scalarTypeToJSON(e));
+    } else {
+      obj.field_type = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ScalarDescriptorAminoMsg): ScalarDescriptor {
+    return ScalarDescriptor.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ScalarDescriptorProtoMsg): ScalarDescriptor {
+    return ScalarDescriptor.decode(message.value);
+  },
+  toProto(message: ScalarDescriptor): Uint8Array {
+    return ScalarDescriptor.encode(message).finish();
+  },
+  toProtoMsg(message: ScalarDescriptor): ScalarDescriptorProtoMsg {
+    return {
+      typeUrl: "/cosmos_proto.ScalarDescriptor",
+      value: ScalarDescriptor.encode(message).finish()
+    };
   }
-
 };

package/src/codegen/cosmwasm/bundle.ts

@@ -1,36 +1,38 @@
-import * as _45 from "./wasm/v1/authz";
-import * as _46 from "./wasm/v1/genesis";
-import * as _47 from "./wasm/v1/ibc";
-import * as _48 from "./wasm/v1/proposal";
-import * as _49 from "./wasm/v1/query";
-import * as _50 from "./wasm/v1/tx";
-import * as _51 from "./wasm/v1/types";
-import * as _142 from "./wasm/v1/tx.amino";
-import * as _143 from "./wasm/v1/tx.registry";
-import * as _144 from "./wasm/v1/query.lcd";
-import * as _145 from "./wasm/v1/query.rpc.Query";
-import * as _146 from "./wasm/v1/tx.rpc.msg";
-import * as _186 from "./lcd";
-import * as _187 from "./rpc.query";
-import * as _188 from "./rpc.tx";
+import * as _95 from "./wasm/v1/authz";
+import * as _96 from "./wasm/v1/genesis";
+import * as _97 from "./wasm/v1/ibc";
+import * as _98 from "./wasm/v1/proposal";
+import * as _99 from "./wasm/v1/query";
+import * as _100 from "./wasm/v1/tx";
+import * as _101 from "./wasm/v1/types";
+import * as _252 from "./wasm/v1/tx.amino";
+import * as _253 from "./wasm/v1/tx.registry";
+import * as _254 from "./wasm/v1/query.lcd";
+import * as _255 from "./wasm/v1/query.rpc.Query";
+import * as _256 from "./wasm/v1/tx.rpc.msg";
+import * as _320 from "./lcd";
+import * as _321 from "./rpc.query";
+import * as _322 from "./rpc.tx";
 export namespace cosmwasm {
   export namespace wasm {
-    export const v1 = { ..._45,
-      ..._46,
-      ..._47,
-      ..._48,
-      ..._49,
-      ..._50,
-      ..._51,
-      ..._142,
-      ..._143,
-      ..._144,
-      ..._145,
-      ..._146
+    export const v1 = {
+      ..._95,
+      ..._96,
+      ..._97,
+      ..._98,
+      ..._99,
+      ..._100,
+      ..._101,
+      ..._252,
+      ..._253,
+      ..._254,
+      ..._255,
+      ..._256
     };
   }
-  export const ClientFactory = { ..._186,
-    ..._187,
-    ..._188
+  export const ClientFactory = {
+    ..._320,
+    ..._321,
+    ..._322
   };
 }

package/src/codegen/cosmwasm/client.ts

@@ -3,7 +3,8 @@ import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs
 import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
 import * as cosmwasmWasmV1TxRegistry from "./wasm/v1/tx.registry";
 import * as cosmwasmWasmV1TxAmino from "./wasm/v1/tx.amino";
-export const cosmwasmAminoConverters = { ...cosmwasmWasmV1TxAmino.AminoConverter
+export const cosmwasmAminoConverters = {
+  ...cosmwasmWasmV1TxAmino.AminoConverter
 };
 export const cosmwasmProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmwasmWasmV1TxRegistry.registry];
 export const getSigningCosmwasmClientOptions = ({
@@ -15,7 +16,8 @@ export const getSigningCosmwasmClientOptions = ({
   aminoTypes: AminoTypes;
 } => {
   const registry = new Registry([...defaultTypes, ...cosmwasmProtoRegistry]);
-  const aminoTypes = new AminoTypes({ ...cosmwasmAminoConverters
+  const aminoTypes = new AminoTypes({
+    ...cosmwasmAminoConverters
   });
   return {
     registry,
@@ -38,7 +40,7 @@ export const getSigningCosmwasmClient = async ({
     defaultTypes
   });
   const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
-    registry,
+    registry: (registry as any),
     aminoTypes
   });
   return client;

package/src/codegen/cosmwasm/lcd.ts

@@ -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/cosmwasm/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/cosmwasm/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)
     }
   },
   cosmwasm: {