juno-network 0.5.3 → 0.6.0

package/src/codegen/cosmos/orm/v1alpha1/schema.ts

@@ -0,0 +1,289 @@
+import * as _m0 from "protobufjs/minimal";
+import { isSet, bytesFromBase64, base64FromBytes, DeepPartial } from "@osmonauts/helpers";
+
+/** StorageType */
+export enum StorageType {
+  /**
+   * STORAGE_TYPE_DEFAULT_UNSPECIFIED - STORAGE_TYPE_DEFAULT_UNSPECIFIED indicates the persistent
+   * KV-storage where primary key entries are stored in merkle-tree
+   * backed commitment storage and indexes and seqs are stored in
+   * fast index storage. Note that the Cosmos SDK before store/v2alpha1
+   * does not support this.
+   */
+  STORAGE_TYPE_DEFAULT_UNSPECIFIED = 0,
+
+  /**
+   * STORAGE_TYPE_MEMORY - STORAGE_TYPE_MEMORY indicates in-memory storage that will be
+   * reloaded every time an app restarts. Tables with this type of storage
+   * will by default be ignored when importing and exporting a module's
+   * state from JSON.
+   */
+  STORAGE_TYPE_MEMORY = 1,
+
+  /**
+   * STORAGE_TYPE_TRANSIENT - STORAGE_TYPE_TRANSIENT indicates transient storage that is reset
+   * at the end of every block. Tables with this type of storage
+   * will by default be ignored when importing and exporting a module's
+   * state from JSON.
+   */
+  STORAGE_TYPE_TRANSIENT = 2,
+
+  /**
+   * STORAGE_TYPE_INDEX - STORAGE_TYPE_INDEX indicates persistent storage which is not backed
+   * by a merkle-tree and won't affect the app hash. Note that the Cosmos SDK
+   * before store/v2alpha1 does not support this.
+   */
+  STORAGE_TYPE_INDEX = 3,
+
+  /**
+   * STORAGE_TYPE_COMMITMENT - STORAGE_TYPE_INDEX indicates persistent storage which is backed by
+   * a merkle-tree. With this type of storage, both primary and index keys
+   * will affect the app hash and this is generally less efficient
+   * than using STORAGE_TYPE_DEFAULT_UNSPECIFIED which separates index
+   * keys into index storage. Note that modules built with the
+   * Cosmos SDK before store/v2alpha1 must specify STORAGE_TYPE_COMMITMENT
+   * instead of STORAGE_TYPE_DEFAULT_UNSPECIFIED or STORAGE_TYPE_INDEX
+   * because this is the only type of persistent storage available.
+   */
+  STORAGE_TYPE_COMMITMENT = 4,
+  UNRECOGNIZED = -1,
+}
+export function storageTypeFromJSON(object: any): StorageType {
+  switch (object) {
+    case 0:
+    case "STORAGE_TYPE_DEFAULT_UNSPECIFIED":
+      return StorageType.STORAGE_TYPE_DEFAULT_UNSPECIFIED;
+
+    case 1:
+    case "STORAGE_TYPE_MEMORY":
+      return StorageType.STORAGE_TYPE_MEMORY;
+
+    case 2:
+    case "STORAGE_TYPE_TRANSIENT":
+      return StorageType.STORAGE_TYPE_TRANSIENT;
+
+    case 3:
+    case "STORAGE_TYPE_INDEX":
+      return StorageType.STORAGE_TYPE_INDEX;
+
+    case 4:
+    case "STORAGE_TYPE_COMMITMENT":
+      return StorageType.STORAGE_TYPE_COMMITMENT;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return StorageType.UNRECOGNIZED;
+  }
+}
+export function storageTypeToJSON(object: StorageType): string {
+  switch (object) {
+    case StorageType.STORAGE_TYPE_DEFAULT_UNSPECIFIED:
+      return "STORAGE_TYPE_DEFAULT_UNSPECIFIED";
+
+    case StorageType.STORAGE_TYPE_MEMORY:
+      return "STORAGE_TYPE_MEMORY";
+
+    case StorageType.STORAGE_TYPE_TRANSIENT:
+      return "STORAGE_TYPE_TRANSIENT";
+
+    case StorageType.STORAGE_TYPE_INDEX:
+      return "STORAGE_TYPE_INDEX";
+
+    case StorageType.STORAGE_TYPE_COMMITMENT:
+      return "STORAGE_TYPE_COMMITMENT";
+
+    default:
+      return "UNKNOWN";
+  }
+}
+
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+export interface ModuleSchemaDescriptor {
+  schema_file: ModuleSchemaDescriptor_FileEntry[];
+
+  /**
+   * prefix is an optional prefix that precedes all keys in this module's
+   * store.
+   */
+  prefix: Uint8Array;
+}
+
+/** FileEntry describes an ORM file used in a module. */
+export interface ModuleSchemaDescriptor_FileEntry {
+  /**
+   * id is a prefix that will be varint encoded and prepended to all the
+   * table keys specified in the file's tables.
+   */
+  id: number;
+
+  /**
+   * proto_file_name is the name of a file .proto in that contains
+   * table definitions. The .proto file must be in a package that the
+   * module has referenced using cosmos.app.v1.ModuleDescriptor.use_package.
+   */
+  proto_file_name: string;
+
+  /**
+   * storage_type optionally indicates the type of storage this file's
+   * tables should used. If it is left unspecified, the default KV-storage
+   * of the app will be used.
+   */
+  storage_type: StorageType;
+}
+
+function createBaseModuleSchemaDescriptor(): ModuleSchemaDescriptor {
+  return {
+    schema_file: [],
+    prefix: new Uint8Array()
+  };
+}
+
+export const ModuleSchemaDescriptor = {
+  encode(message: ModuleSchemaDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.schema_file) {
+      ModuleSchemaDescriptor_FileEntry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.prefix.length !== 0) {
+      writer.uint32(18).bytes(message.prefix);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ModuleSchemaDescriptor {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleSchemaDescriptor();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.schema_file.push(ModuleSchemaDescriptor_FileEntry.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.prefix = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ModuleSchemaDescriptor {
+    return {
+      schema_file: Array.isArray(object?.schema_file) ? object.schema_file.map((e: any) => ModuleSchemaDescriptor_FileEntry.fromJSON(e)) : [],
+      prefix: isSet(object.prefix) ? bytesFromBase64(object.prefix) : new Uint8Array()
+    };
+  },
+
+  toJSON(message: ModuleSchemaDescriptor): unknown {
+    const obj: any = {};
+
+    if (message.schema_file) {
+      obj.schema_file = message.schema_file.map(e => e ? ModuleSchemaDescriptor_FileEntry.toJSON(e) : undefined);
+    } else {
+      obj.schema_file = [];
+    }
+
+    message.prefix !== undefined && (obj.prefix = base64FromBytes(message.prefix !== undefined ? message.prefix : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<ModuleSchemaDescriptor>): ModuleSchemaDescriptor {
+    const message = createBaseModuleSchemaDescriptor();
+    message.schema_file = object.schema_file?.map(e => ModuleSchemaDescriptor_FileEntry.fromPartial(e)) || [];
+    message.prefix = object.prefix ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseModuleSchemaDescriptor_FileEntry(): ModuleSchemaDescriptor_FileEntry {
+  return {
+    id: 0,
+    proto_file_name: "",
+    storage_type: 0
+  };
+}
+
+export const ModuleSchemaDescriptor_FileEntry = {
+  encode(message: ModuleSchemaDescriptor_FileEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    if (message.proto_file_name !== "") {
+      writer.uint32(18).string(message.proto_file_name);
+    }
+
+    if (message.storage_type !== 0) {
+      writer.uint32(24).int32(message.storage_type);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ModuleSchemaDescriptor_FileEntry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        case 2:
+          message.proto_file_name = reader.string();
+          break;
+
+        case 3:
+          message.storage_type = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ModuleSchemaDescriptor_FileEntry {
+    return {
+      id: isSet(object.id) ? Number(object.id) : 0,
+      proto_file_name: isSet(object.proto_file_name) ? String(object.proto_file_name) : "",
+      storage_type: isSet(object.storage_type) ? storageTypeFromJSON(object.storage_type) : 0
+    };
+  },
+
+  toJSON(message: ModuleSchemaDescriptor_FileEntry): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = Math.round(message.id));
+    message.proto_file_name !== undefined && (obj.proto_file_name = message.proto_file_name);
+    message.storage_type !== undefined && (obj.storage_type = storageTypeToJSON(message.storage_type));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<ModuleSchemaDescriptor_FileEntry>): ModuleSchemaDescriptor_FileEntry {
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+    message.id = object.id ?? 0;
+    message.proto_file_name = object.proto_file_name ?? "";
+    message.storage_type = object.storage_type ?? 0;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/params/v1beta1/params.ts

@@ -0,0 +1,187 @@
+import * as _m0 from "protobufjs/minimal";
+import { isSet, DeepPartial } from "@osmonauts/helpers";
+
+/** ParameterChangeProposal defines a proposal to change one or more parameters. */
+export interface ParameterChangeProposal {
+  title: string;
+  description: string;
+  changes: ParamChange[];
+}
+
+/**
+ * ParamChange defines an individual parameter change, for use in
+ * ParameterChangeProposal.
+ */
+export interface ParamChange {
+  subspace: string;
+  key: string;
+  value: string;
+}
+
+function createBaseParameterChangeProposal(): ParameterChangeProposal {
+  return {
+    title: "",
+    description: "",
+    changes: []
+  };
+}
+
+export const ParameterChangeProposal = {
+  encode(message: ParameterChangeProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.title !== "") {
+      writer.uint32(10).string(message.title);
+    }
+
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+
+    for (const v of message.changes) {
+      ParamChange.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ParameterChangeProposal {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParameterChangeProposal();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.title = reader.string();
+          break;
+
+        case 2:
+          message.description = reader.string();
+          break;
+
+        case 3:
+          message.changes.push(ParamChange.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ParameterChangeProposal {
+    return {
+      title: isSet(object.title) ? String(object.title) : "",
+      description: isSet(object.description) ? String(object.description) : "",
+      changes: Array.isArray(object?.changes) ? object.changes.map((e: any) => ParamChange.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message: ParameterChangeProposal): unknown {
+    const obj: any = {};
+    message.title !== undefined && (obj.title = message.title);
+    message.description !== undefined && (obj.description = message.description);
+
+    if (message.changes) {
+      obj.changes = message.changes.map(e => e ? ParamChange.toJSON(e) : undefined);
+    } else {
+      obj.changes = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<ParameterChangeProposal>): ParameterChangeProposal {
+    const message = createBaseParameterChangeProposal();
+    message.title = object.title ?? "";
+    message.description = object.description ?? "";
+    message.changes = object.changes?.map(e => ParamChange.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseParamChange(): ParamChange {
+  return {
+    subspace: "",
+    key: "",
+    value: ""
+  };
+}
+
+export const ParamChange = {
+  encode(message: ParamChange, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subspace !== "") {
+      writer.uint32(10).string(message.subspace);
+    }
+
+    if (message.key !== "") {
+      writer.uint32(18).string(message.key);
+    }
+
+    if (message.value !== "") {
+      writer.uint32(26).string(message.value);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ParamChange {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParamChange();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subspace = reader.string();
+          break;
+
+        case 2:
+          message.key = reader.string();
+          break;
+
+        case 3:
+          message.value = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): ParamChange {
+    return {
+      subspace: isSet(object.subspace) ? String(object.subspace) : "",
+      key: isSet(object.key) ? String(object.key) : "",
+      value: isSet(object.value) ? String(object.value) : ""
+    };
+  },
+
+  toJSON(message: ParamChange): unknown {
+    const obj: any = {};
+    message.subspace !== undefined && (obj.subspace = message.subspace);
+    message.key !== undefined && (obj.key = message.key);
+    message.value !== undefined && (obj.value = message.value);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<ParamChange>): ParamChange {
+    const message = createBaseParamChange();
+    message.subspace = object.subspace ?? "";
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+
+};

package/src/codegen/cosmos/params/v1beta1/query.lcd.ts

@@ -0,0 +1,40 @@
+import { ParamChange } from "./params";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QuerySubspacesRequest, QuerySubspacesResponse } from "./query";
+export class LCDQueryClient extends LCDClient {
+  constructor({
+    restEndpoint
+  }: {
+    restEndpoint: string;
+  }) {
+    super({
+      restEndpoint
+    });
+  }
+
+  /* Params queries a specific parameter of a module, given its subspace and
+  key. */
+  async params(params: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.subspace !== "undefined") {
+      options.params.subspace = params.subspace;
+    }
+
+    if (typeof params?.key !== "undefined") {
+      options.params.key = params.key;
+    }
+
+    const endpoint = `cosmos/params/v1beta1/params`;
+    return await this.get<QueryParamsResponse>(endpoint, options);
+  }
+
+  /* Subspaces queries for all registered subspaces and all keys for a subspace. */
+  async subspaces(_params: QuerySubspacesRequest = {}): Promise<QuerySubspacesResponse> {
+    const endpoint = `cosmos/params/v1beta1/subspaces`;
+    return await this.get<QuerySubspacesResponse>(endpoint);
+  }
+
+}

package/src/codegen/cosmos/params/v1beta1/query.rpc.query.ts

@@ -0,0 +1,37 @@
+import { ParamChange } from "./params";
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryParamsRequest, QueryParamsResponse, QuerySubspacesRequest, QuerySubspacesResponse } from "./query";
+
+/** Query defines the RPC service */
+export interface Query {
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /*Params queries a specific parameter of a module, given its subspace and
+  key.*/
+
+  subspaces(request: QuerySubspacesRequest): Promise<QuerySubspacesResponse>;
+  /*Subspaces queries for all registered subspaces and all keys for a subspace.*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.subspaces = this.subspaces.bind(this);
+  }
+
+  params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  subspaces(request: QuerySubspacesRequest): Promise<QuerySubspacesResponse> {
+    const data = QuerySubspacesRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.params.v1beta1.Query", "Subspaces", data);
+    return promise.then(data => QuerySubspacesResponse.decode(new _m0.Reader(data)));
+  }
+
+}