@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/orm/v1/orm.ts

@@ -0,0 +1,356 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** TableDescriptor describes an ORM table. */
+
+export interface TableDescriptor {
+  /** primary_key defines the primary key for the table. */
+  primaryKey?: PrimaryKeyDescriptor;
+  /** index defines one or more secondary indexes. */
+
+  index: SecondaryIndexDescriptor[];
+  /**
+   * id is a non-zero integer ID that must be unique within the
+   * tables and singletons in this file. It may be deprecated in the future when this
+   * can be auto-generated.
+   */
+
+  id: number;
+}
+/** TableDescriptor describes an ORM table. */
+
+export interface TableDescriptorSDKType {
+  primary_key?: PrimaryKeyDescriptorSDKType;
+  index: SecondaryIndexDescriptorSDKType[];
+  id: number;
+}
+/** PrimaryKeyDescriptor describes a table primary key. */
+
+export interface PrimaryKeyDescriptor {
+  /**
+   * fields is a comma-separated list of fields in the primary key. Spaces are
+   * not allowed. Supported field types, their encodings, and any applicable constraints
+   * are described below.
+   *   - uint32 are encoded as 2,3,4 or 5 bytes using a compact encoding that
+   *     is suitable for sorted iteration (not varint encoding). This type is
+   *     well-suited for small integers.
+   *   - uint64 are encoded as 2,4,6 or 9 bytes using a compact encoding that
+   *     is suitable for sorted iteration (not varint encoding). This type is
+   *     well-suited for small integers such as auto-incrementing sequences.
+   *   - fixed32, fixed64 are encoded as big-endian fixed width bytes and support
+   *   sorted iteration. These types are well-suited for encoding fixed with
+   *   decimals as integers.
+   *   - string's are encoded as raw bytes in terminal key segments and null-terminated
+   *   in non-terminal segments. Null characters are thus forbidden in strings.
+   *   string fields support sorted iteration.
+   *   - bytes are encoded as raw bytes in terminal segments and length-prefixed
+   *   with a 32-bit unsigned varint in non-terminal segments.
+   *   - int32, sint32, int64, sint64, sfixed32, sfixed64 are encoded as fixed width bytes with
+   *   an encoding that enables sorted iteration.
+   *   - google.protobuf.Timestamp is encoded such that values with only seconds occupy 6 bytes,
+   *   values including nanos occupy 9 bytes, and nil values occupy 1 byte. When iterating, nil
+   *   values will always be ordered last. Seconds and nanos values must conform to the officially
+   *   specified ranges of 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z and 0 to 999,999,999 respectively.
+   *   - google.protobuf.Duration is encoded as 12 bytes using an encoding that enables sorted iteration.
+   *   - enum fields are encoded using varint encoding and do not support sorted
+   *   iteration.
+   *   - bool fields are encoded as a single byte 0 or 1.
+   * 
+   * All other fields types are unsupported in keys including repeated and
+   * oneof fields.
+   * 
+   * Primary keys are prefixed by the varint encoded table id and the byte 0x0
+   * plus any additional prefix specified by the schema.
+   */
+  fields: string;
+  /**
+   * auto_increment specifies that the primary key is generated by an
+   * auto-incrementing integer. If this is set to true fields must only
+   * contain one field of that is of type uint64.
+   */
+
+  autoIncrement: boolean;
+}
+/** PrimaryKeyDescriptor describes a table primary key. */
+
+export interface PrimaryKeyDescriptorSDKType {
+  fields: string;
+  auto_increment: boolean;
+}
+/** PrimaryKeyDescriptor describes a table secondary index. */
+
+export interface SecondaryIndexDescriptor {
+  /**
+   * fields is a comma-separated list of fields in the index. The supported
+   * field types are the same as those for PrimaryKeyDescriptor.fields.
+   * Index keys are prefixed by the varint encoded table id and the varint
+   * encoded index id plus any additional prefix specified by the schema.
+   * 
+   * In addition the field segments, non-unique index keys are suffixed with
+   * any additional primary key fields not present in the index fields so that the
+   * primary key can be reconstructed. Unique indexes instead of being suffixed
+   * store the remaining primary key fields in the value..
+   */
+  fields: string;
+  /**
+   * id is a non-zero integer ID that must be unique within the indexes for this
+   * table and less than 32768. It may be deprecated in the future when this can
+   * be auto-generated.
+   */
+
+  id: number;
+  /** unique specifies that this an unique index. */
+
+  unique: boolean;
+}
+/** PrimaryKeyDescriptor describes a table secondary index. */
+
+export interface SecondaryIndexDescriptorSDKType {
+  fields: string;
+  id: number;
+  unique: boolean;
+}
+/** TableDescriptor describes an ORM singleton table which has at most one instance. */
+
+export interface SingletonDescriptor {
+  /**
+   * id is a non-zero integer ID that must be unique within the
+   * tables and singletons in this file. It may be deprecated in the future when this
+   * can be auto-generated.
+   */
+  id: number;
+}
+/** TableDescriptor describes an ORM singleton table which has at most one instance. */
+
+export interface SingletonDescriptorSDKType {
+  id: number;
+}
+
+function createBaseTableDescriptor(): TableDescriptor {
+  return {
+    primaryKey: undefined,
+    index: [],
+    id: 0
+  };
+}
+
+export const TableDescriptor = {
+  encode(message: TableDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.primaryKey !== undefined) {
+      PrimaryKeyDescriptor.encode(message.primaryKey, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.index) {
+      SecondaryIndexDescriptor.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.id !== 0) {
+      writer.uint32(24).uint32(message.id);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TableDescriptor {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTableDescriptor();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.primaryKey = PrimaryKeyDescriptor.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.index.push(SecondaryIndexDescriptor.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.id = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<TableDescriptor>): TableDescriptor {
+    const message = createBaseTableDescriptor();
+    message.primaryKey = object.primaryKey !== undefined && object.primaryKey !== null ? PrimaryKeyDescriptor.fromPartial(object.primaryKey) : undefined;
+    message.index = object.index?.map(e => SecondaryIndexDescriptor.fromPartial(e)) || [];
+    message.id = object.id ?? 0;
+    return message;
+  }
+
+};
+
+function createBasePrimaryKeyDescriptor(): PrimaryKeyDescriptor {
+  return {
+    fields: "",
+    autoIncrement: false
+  };
+}
+
+export const PrimaryKeyDescriptor = {
+  encode(message: PrimaryKeyDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.fields !== "") {
+      writer.uint32(10).string(message.fields);
+    }
+
+    if (message.autoIncrement === true) {
+      writer.uint32(16).bool(message.autoIncrement);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PrimaryKeyDescriptor {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrimaryKeyDescriptor();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.fields = reader.string();
+          break;
+
+        case 2:
+          message.autoIncrement = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PrimaryKeyDescriptor>): PrimaryKeyDescriptor {
+    const message = createBasePrimaryKeyDescriptor();
+    message.fields = object.fields ?? "";
+    message.autoIncrement = object.autoIncrement ?? false;
+    return message;
+  }
+
+};
+
+function createBaseSecondaryIndexDescriptor(): SecondaryIndexDescriptor {
+  return {
+    fields: "",
+    id: 0,
+    unique: false
+  };
+}
+
+export const SecondaryIndexDescriptor = {
+  encode(message: SecondaryIndexDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.fields !== "") {
+      writer.uint32(10).string(message.fields);
+    }
+
+    if (message.id !== 0) {
+      writer.uint32(16).uint32(message.id);
+    }
+
+    if (message.unique === true) {
+      writer.uint32(24).bool(message.unique);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SecondaryIndexDescriptor {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSecondaryIndexDescriptor();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.fields = reader.string();
+          break;
+
+        case 2:
+          message.id = reader.uint32();
+          break;
+
+        case 3:
+          message.unique = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SecondaryIndexDescriptor>): SecondaryIndexDescriptor {
+    const message = createBaseSecondaryIndexDescriptor();
+    message.fields = object.fields ?? "";
+    message.id = object.id ?? 0;
+    message.unique = object.unique ?? false;
+    return message;
+  }
+
+};
+
+function createBaseSingletonDescriptor(): SingletonDescriptor {
+  return {
+    id: 0
+  };
+}
+
+export const SingletonDescriptor = {
+  encode(message: SingletonDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SingletonDescriptor {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSingletonDescriptor();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<SingletonDescriptor>): SingletonDescriptor {
+    const message = createBaseSingletonDescriptor();
+    message.id = object.id ?? 0;
+    return message;
+  }
+
+};

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

@@ -0,0 +1,232 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** StorageType */
+
+export enum StorageType {
+  /**
+   * STORAGE_TYPE_DEFAULT_UNSPECIFIED - STORAGE_TYPE_DEFAULT_UNSPECIFIED indicates the persistent storage where all
+   * data is stored in the regular Merkle-tree backed KV-store.
+   */
+  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,
+  UNRECOGNIZED = -1,
+}
+export const StorageTypeSDKType = StorageType;
+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 -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.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+
+export interface ModuleSchemaDescriptor {
+  schemaFile: ModuleSchemaDescriptor_FileEntry[];
+  /**
+   * prefix is an optional prefix that precedes all keys in this module's
+   * store.
+   */
+
+  prefix: Uint8Array;
+}
+/** ModuleSchemaDescriptor describe's a module's ORM schema. */
+
+export interface ModuleSchemaDescriptorSDKType {
+  schema_file: ModuleSchemaDescriptor_FileEntrySDKType[];
+  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.
+   */
+
+  protoFileName: 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.
+   */
+
+  storageType: StorageType;
+}
+/** FileEntry describes an ORM file used in a module. */
+
+export interface ModuleSchemaDescriptor_FileEntrySDKType {
+  id: number;
+  proto_file_name: string;
+  storage_type: StorageType;
+}
+
+function createBaseModuleSchemaDescriptor(): ModuleSchemaDescriptor {
+  return {
+    schemaFile: [],
+    prefix: new Uint8Array()
+  };
+}
+
+export const ModuleSchemaDescriptor = {
+  encode(message: ModuleSchemaDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.schemaFile) {
+      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.schemaFile.push(ModuleSchemaDescriptor_FileEntry.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.prefix = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ModuleSchemaDescriptor>): ModuleSchemaDescriptor {
+    const message = createBaseModuleSchemaDescriptor();
+    message.schemaFile = object.schemaFile?.map(e => ModuleSchemaDescriptor_FileEntry.fromPartial(e)) || [];
+    message.prefix = object.prefix ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseModuleSchemaDescriptor_FileEntry(): ModuleSchemaDescriptor_FileEntry {
+  return {
+    id: 0,
+    protoFileName: "",
+    storageType: 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.protoFileName !== "") {
+      writer.uint32(18).string(message.protoFileName);
+    }
+
+    if (message.storageType !== 0) {
+      writer.uint32(24).int32(message.storageType);
+    }
+
+    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.protoFileName = reader.string();
+          break;
+
+        case 3:
+          message.storageType = (reader.int32() as any);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ModuleSchemaDescriptor_FileEntry>): ModuleSchemaDescriptor_FileEntry {
+    const message = createBaseModuleSchemaDescriptor_FileEntry();
+    message.id = object.id ?? 0;
+    message.protoFileName = object.protoFileName ?? "";
+    message.storageType = object.storageType ?? 0;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/params/module/v1/module.ts

@@ -0,0 +1,42 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the params module. */
+
+export interface Module {}
+/** Module is the config object of the params module. */
+
+export interface ModuleSDKType {}
+
+function createBaseModule(): Module {
+  return {};
+}
+
+export const Module = {
+  encode(_: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Module {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    return message;
+  }
+
+};