juno-network 0.5.3 → 0.6.0

package/src/codegen/cosmos_proto/cosmos.ts

@@ -0,0 +1,289 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+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 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:
+      return ScalarType.UNRECOGNIZED;
+  }
+}
+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";
+
+    default:
+      return "UNKNOWN";
+  }
+}
+/**
+ * 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
+   * 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;
+  /**
+   * description is a human-readable description of the interface and its
+   * purpose.
+   */
+
+  description: string;
+}
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+
+export interface InterfaceDescriptorSDKType {
+  /**
+   * 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;
+  /**
+   * description is a human-readable description of the interface and its
+   * purpose.
+   */
+
+  description: string;
+}
+/**
+ * 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 ScalarDescriptor {
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+
+  fieldType: ScalarType[];
+}
+/**
+ * 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 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;
+  /**
+   * 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;
+  /**
+   * 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[];
+}
+
+function createBaseInterfaceDescriptor(): InterfaceDescriptor {
+  return {
+    name: "",
+    description: ""
+  };
+}
+
+export const InterfaceDescriptor = {
+  encode(message: InterfaceDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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);
+    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 {
+    const message = createBaseInterfaceDescriptor();
+    message.name = object.name ?? "";
+    message.description = object.description ?? "";
+    return message;
+  }
+
+};
+
+function createBaseScalarDescriptor(): ScalarDescriptor {
+  return {
+    name: "",
+    description: "",
+    fieldType: []
+  };
+}
+
+export const ScalarDescriptor = {
+  encode(message: ScalarDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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);
+    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 {
+    const message = createBaseScalarDescriptor();
+    message.name = object.name ?? "";
+    message.description = object.description ?? "";
+    message.fieldType = object.fieldType?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmwasm/bundle.ts

@@ -0,0 +1,34 @@
+import * as _45 from "./wasm/v1/genesis";
+import * as _46 from "./wasm/v1/ibc";
+import * as _47 from "./wasm/v1/proposal";
+import * as _48 from "./wasm/v1/query";
+import * as _49 from "./wasm/v1/tx";
+import * as _50 from "./wasm/v1/types";
+import * as _131 from "./wasm/v1/tx.amino";
+import * as _132 from "./wasm/v1/tx.registry";
+import * as _133 from "./wasm/v1/query.lcd";
+import * as _134 from "./wasm/v1/query.rpc.query";
+import * as _135 from "./wasm/v1/tx.rpc.msg";
+import * as _161 from "./lcd";
+import * as _162 from "./rpc.query";
+import * as _163 from "./rpc.tx";
+export namespace cosmwasm {
+  export namespace wasm {
+    export const v1 = { ..._45,
+      ..._46,
+      ..._47,
+      ..._48,
+      ..._49,
+      ..._50,
+      ..._131,
+      ..._132,
+      ..._133,
+      ..._134,
+      ..._135
+    };
+  }
+  export const ClientFactory = { ..._161,
+    ..._162,
+    ..._163
+  };
+}

package/src/codegen/cosmwasm/client.ts

@@ -0,0 +1,44 @@
+import { OfflineSigner, GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import * as cosmwasmWasmV1TxRegistry from "./wasm/v1/tx.registry";
+import * as cosmwasmWasmV1TxAmino from "./wasm/v1/tx.amino";
+export const cosmwasmAminoConverters = { ...cosmwasmWasmV1TxAmino.AminoConverter
+};
+export const cosmwasmProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmwasmWasmV1TxRegistry.registry];
+export const getSigningCosmwasmClientOptions = ({
+  defaultTypes = defaultRegistryTypes
+}: {
+  defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+} = {}): {
+  registry: Registry;
+  aminoTypes: AminoTypes;
+} => {
+  const registry = new Registry([...defaultTypes, ...cosmwasmProtoRegistry]);
+  const aminoTypes = new AminoTypes({ ...cosmwasmAminoConverters
+  });
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningCosmwasmClient = async ({
+  rpcEndpoint,
+  signer,
+  defaultTypes = defaultRegistryTypes
+}: {
+  rpcEndpoint: string;
+  signer: OfflineSigner;
+  defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningCosmwasmClientOptions({
+    defaultTypes
+  });
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry,
+    aminoTypes
+  });
+  return client;
+};

package/src/codegen/cosmwasm/lcd.ts

@@ -0,0 +1,59 @@
+import { LCDClient } from "@osmonauts/lcd";
+export const createLCDClient = async ({
+  restEndpoint
+}: {
+  restEndpoint: string;
+}) => {
+  const requestClient = new LCDClient({
+    restEndpoint
+  });
+  return {
+    cosmos: {
+      authz: {
+        v1beta1: new (await import("../cosmos/authz/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      bank: {
+        v1beta1: new (await import("../cosmos/bank/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      distribution: {
+        v1beta1: new (await import("../cosmos/distribution/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      gov: {
+        v1: new (await import("../cosmos/gov/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        }),
+        v1beta1: new (await import("../cosmos/gov/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      staking: {
+        v1beta1: new (await import("../cosmos/staking/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      tx: {
+        v1beta1: new (await import("../cosmos/tx/v1beta1/service.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      upgrade: {
+        v1beta1: new (await import("../cosmos/upgrade/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    },
+    cosmwasm: {
+      wasm: {
+        v1: new (await import("./wasm/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    }
+  };
+};

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

@@ -0,0 +1,41 @@
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({
+  rpcEndpoint
+}: {
+  rpcEndpoint: string;
+}) => {
+  const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+  const client = new QueryClient(tmClient);
+  return {
+    cosmos: {
+      authz: {
+        v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("../cosmos/distribution/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)
+      },
+      staking: {
+        v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.svc")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      }
+    },
+    cosmwasm: {
+      wasm: {
+        v1: (await import("./wasm/v1/query.rpc.query")).createRpcQueryExtension(client)
+      }
+    }
+  };
+};

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

@@ -0,0 +1,33 @@
+import { Rpc } from "@osmonauts/helpers";
+export const createRPCMsgClient = async ({
+  rpc
+}: {
+  rpc: Rpc;
+}) => ({
+  cosmos: {
+    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)
+    },
+    distribution: {
+      v1beta1: new (await import("../cosmos/distribution/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)
+    },
+    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)
+    }
+  },
+  cosmwasm: {
+    wasm: {
+      v1: new (await import("./wasm/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  }
+});