@zoguxprotocol/proto 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+<p align="center"><img src="https://zogux.exchange/icon.svg?" width="256" /></p>
+
+<h1 align="center">proto-js</h1>
+
+<div align="center">
+  <a href='https://www.npmjs.com/package/@zoguxprotocol/proto'>
+    <img src='https://img.shields.io/npm/v/@zoguxprotocol/proto.svg' alt='npm'/>
+  </a>
+  <a href='https://github.com/zoguxprotocol/zogux-chain/blob/main/proto-js/LICENSE'>
+    <img src='https://img.shields.io/badge/License-AGPL_v3-blue.svg' alt='License' />
+  </a>
+</div>
+
+Generated Javascript package for Zogux Chain protobufs.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@zoguxprotocol/proto",
+  "version": "0.1.0",
+  "access": "public",
+  "description": "Protos for Zogux protocol",
+  "author": "Zogux Trading Inc.",
+  "homepage": "https://github.com/zoguxprotocol/zogux-chain",
+  "license": "AGPL-3.0",
+  "main": "main/index.js",
+  "module": "module/index.js",
+  "typings": "types/index.d.ts",
+  "directories": {
+    "lib": "src"
+  },
+  "files": [
+    "types",
+    "src",
+    "main",
+    "module"
+  ],
+  "scripts": {
+    "build": "tsc --project ./tsconfig.json",
+    "_comment": "In codegen we delete autocli because it has some proto map field code that doesn't compile in strict mode. We don't use autocli so this is okay for now.",
+    "transpile": "(cd .. && make proto-export-deps && rm -rf .proto-export-deps/cosmos/autocli) && rm -rf src/ && telescope transpile --protoDirs ../.proto-export-deps --outPath ./src/codegen --no-includeAminos --includeLCDClients --includeRPCClients"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zoguxprotocol/zogux-chain"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/zoguxprotocol/zogux-chain/issues"
+  },
+  "devDependencies": {
+    "@cosmjs/stargate": "^0.32.1",
+    "@dydxprotocol/node-service-base-dev": "^0.3.2",
+    "@osmonauts/lcd": "^0.6.0",
+    "@osmonauts/telescope": "0.86.0",
+    "long": "^4.0.0",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "protobufjs": "^6.11.2"
+  }
+}

package/src/codegen/amino/amino.ts

@@ -0,0 +1 @@
+export {}

package/src/codegen/amino/bundle.ts

@@ -0,0 +1,3 @@
+import * as _0 from "./amino";
+export const amino = { ..._0
+};

package/src/codegen/cosmos/app/runtime/v1alpha1/module.ts

@@ -0,0 +1,277 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object for the runtime module. */
+
+export interface Module {
+  /** app_name is the name of the app. */
+  appName: string;
+  /**
+   * begin_blockers specifies the module names of begin blockers
+   * to call in the order in which they should be called. If this is left empty
+   * no begin blocker will be registered.
+   */
+
+  beginBlockers: string[];
+  /**
+   * end_blockers specifies the module names of the end blockers
+   * to call in the order in which they should be called. If this is left empty
+   * no end blocker will be registered.
+   */
+
+  endBlockers: string[];
+  /**
+   * init_genesis specifies the module names of init genesis functions
+   * to call in the order in which they should be called. If this is left empty
+   * no init genesis function will be registered.
+   */
+
+  initGenesis: string[];
+  /**
+   * export_genesis specifies the order in which to export module genesis data.
+   * If this is left empty, the init_genesis order will be used for export genesis
+   * if it is specified.
+   */
+
+  exportGenesis: string[];
+  /**
+   * override_store_keys is an optional list of overrides for the module store keys
+   * to be used in keeper construction.
+   */
+
+  overrideStoreKeys: StoreKeyConfig[];
+  /**
+   * order_migrations defines the order in which module migrations are performed.
+   * If this is left empty, it uses the default migration order.
+   * https://pkg.go.dev/github.com/cosmos/cosmos-sdk@v0.47.0-alpha2/types/module#DefaultMigrationsOrder
+   */
+
+  orderMigrations: string[];
+  /**
+   * precommiters specifies the module names of the precommiters
+   * to call in the order in which they should be called. If this is left empty
+   * no precommit function will be registered.
+   */
+
+  precommiters: string[];
+  /**
+   * prepare_check_staters specifies the module names of the prepare_check_staters
+   * to call in the order in which they should be called. If this is left empty
+   * no preparecheckstate function will be registered.
+   */
+
+  prepareCheckStaters: string[];
+}
+/** Module is the config object for the runtime module. */
+
+export interface ModuleSDKType {
+  app_name: string;
+  begin_blockers: string[];
+  end_blockers: string[];
+  init_genesis: string[];
+  export_genesis: string[];
+  override_store_keys: StoreKeyConfigSDKType[];
+  order_migrations: string[];
+  precommiters: string[];
+  prepare_check_staters: string[];
+}
+/**
+ * StoreKeyConfig may be supplied to override the default module store key, which
+ * is the module name.
+ */
+
+export interface StoreKeyConfig {
+  /** name of the module to override the store key of */
+  moduleName: string;
+  /** the kv store key to use instead of the module name. */
+
+  kvStoreKey: string;
+}
+/**
+ * StoreKeyConfig may be supplied to override the default module store key, which
+ * is the module name.
+ */
+
+export interface StoreKeyConfigSDKType {
+  module_name: string;
+  kv_store_key: string;
+}
+
+function createBaseModule(): Module {
+  return {
+    appName: "",
+    beginBlockers: [],
+    endBlockers: [],
+    initGenesis: [],
+    exportGenesis: [],
+    overrideStoreKeys: [],
+    orderMigrations: [],
+    precommiters: [],
+    prepareCheckStaters: []
+  };
+}
+
+export const Module = {
+  encode(message: Module, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.appName !== "") {
+      writer.uint32(10).string(message.appName);
+    }
+
+    for (const v of message.beginBlockers) {
+      writer.uint32(18).string(v!);
+    }
+
+    for (const v of message.endBlockers) {
+      writer.uint32(26).string(v!);
+    }
+
+    for (const v of message.initGenesis) {
+      writer.uint32(34).string(v!);
+    }
+
+    for (const v of message.exportGenesis) {
+      writer.uint32(42).string(v!);
+    }
+
+    for (const v of message.overrideStoreKeys) {
+      StoreKeyConfig.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+
+    for (const v of message.orderMigrations) {
+      writer.uint32(58).string(v!);
+    }
+
+    for (const v of message.precommiters) {
+      writer.uint32(66).string(v!);
+    }
+
+    for (const v of message.prepareCheckStaters) {
+      writer.uint32(74).string(v!);
+    }
+
+    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) {
+        case 1:
+          message.appName = reader.string();
+          break;
+
+        case 2:
+          message.beginBlockers.push(reader.string());
+          break;
+
+        case 3:
+          message.endBlockers.push(reader.string());
+          break;
+
+        case 4:
+          message.initGenesis.push(reader.string());
+          break;
+
+        case 5:
+          message.exportGenesis.push(reader.string());
+          break;
+
+        case 6:
+          message.overrideStoreKeys.push(StoreKeyConfig.decode(reader, reader.uint32()));
+          break;
+
+        case 7:
+          message.orderMigrations.push(reader.string());
+          break;
+
+        case 8:
+          message.precommiters.push(reader.string());
+          break;
+
+        case 9:
+          message.prepareCheckStaters.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.appName = object.appName ?? "";
+    message.beginBlockers = object.beginBlockers?.map(e => e) || [];
+    message.endBlockers = object.endBlockers?.map(e => e) || [];
+    message.initGenesis = object.initGenesis?.map(e => e) || [];
+    message.exportGenesis = object.exportGenesis?.map(e => e) || [];
+    message.overrideStoreKeys = object.overrideStoreKeys?.map(e => StoreKeyConfig.fromPartial(e)) || [];
+    message.orderMigrations = object.orderMigrations?.map(e => e) || [];
+    message.precommiters = object.precommiters?.map(e => e) || [];
+    message.prepareCheckStaters = object.prepareCheckStaters?.map(e => e) || [];
+    return message;
+  }
+
+};
+
+function createBaseStoreKeyConfig(): StoreKeyConfig {
+  return {
+    moduleName: "",
+    kvStoreKey: ""
+  };
+}
+
+export const StoreKeyConfig = {
+  encode(message: StoreKeyConfig, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.moduleName !== "") {
+      writer.uint32(10).string(message.moduleName);
+    }
+
+    if (message.kvStoreKey !== "") {
+      writer.uint32(18).string(message.kvStoreKey);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StoreKeyConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStoreKeyConfig();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.moduleName = reader.string();
+          break;
+
+        case 2:
+          message.kvStoreKey = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StoreKeyConfig>): StoreKeyConfig {
+    const message = createBaseStoreKeyConfig();
+    message.moduleName = object.moduleName ?? "";
+    message.kvStoreKey = object.kvStoreKey ?? "";
+    return message;
+  }
+
+};

package/src/codegen/cosmos/app/v1alpha1/config.ts

@@ -0,0 +1,265 @@
+import { Any, AnySDKType } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Config represents the configuration for a Cosmos SDK ABCI app.
+ * It is intended that all state machine logic including the version of
+ * baseapp and tx handlers (and possibly even Tendermint) that an app needs
+ * can be described in a config object. For compatibility, the framework should
+ * allow a mixture of declarative and imperative app wiring, however, apps
+ * that strive for the maximum ease of maintainability should be able to describe
+ * their state machine with a config object alone.
+ */
+
+export interface Config {
+  /** modules are the module configurations for the app. */
+  modules: ModuleConfig[];
+  /**
+   * golang_bindings specifies explicit interface to implementation type bindings which
+   * depinject uses to resolve interface inputs to provider functions.  The scope of this
+   * field's configuration is global (not module specific).
+   */
+
+  golangBindings: GolangBinding[];
+}
+/**
+ * Config represents the configuration for a Cosmos SDK ABCI app.
+ * It is intended that all state machine logic including the version of
+ * baseapp and tx handlers (and possibly even Tendermint) that an app needs
+ * can be described in a config object. For compatibility, the framework should
+ * allow a mixture of declarative and imperative app wiring, however, apps
+ * that strive for the maximum ease of maintainability should be able to describe
+ * their state machine with a config object alone.
+ */
+
+export interface ConfigSDKType {
+  modules: ModuleConfigSDKType[];
+  golang_bindings: GolangBindingSDKType[];
+}
+/** ModuleConfig is a module configuration for an app. */
+
+export interface ModuleConfig {
+  /**
+   * name is the unique name of the module within the app. It should be a name
+   * that persists between different versions of a module so that modules
+   * can be smoothly upgraded to new versions.
+   * 
+   * For example, for the module cosmos.bank.module.v1.Module, we may chose
+   * to simply name the module "bank" in the app. When we upgrade to
+   * cosmos.bank.module.v2.Module, the app-specific name "bank" stays the same
+   * and the framework knows that the v2 module should receive all the same state
+   * that the v1 module had. Note: modules should provide info on which versions
+   * they can migrate from in the ModuleDescriptor.can_migration_from field.
+   */
+  name: string;
+  /**
+   * config is the config object for the module. Module config messages should
+   * define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension.
+   */
+
+  config?: Any;
+  /**
+   * golang_bindings specifies explicit interface to implementation type bindings which
+   * depinject uses to resolve interface inputs to provider functions.  The scope of this
+   * field's configuration is module specific.
+   */
+
+  golangBindings: GolangBinding[];
+}
+/** ModuleConfig is a module configuration for an app. */
+
+export interface ModuleConfigSDKType {
+  name: string;
+  config?: AnySDKType;
+  golang_bindings: GolangBindingSDKType[];
+}
+/** GolangBinding is an explicit interface type to implementing type binding for dependency injection. */
+
+export interface GolangBinding {
+  /** interface_type is the interface type which will be bound to a specific implementation type */
+  interfaceType: string;
+  /** implementation is the implementing type which will be supplied when an input of type interface is requested */
+
+  implementation: string;
+}
+/** GolangBinding is an explicit interface type to implementing type binding for dependency injection. */
+
+export interface GolangBindingSDKType {
+  interface_type: string;
+  implementation: string;
+}
+
+function createBaseConfig(): Config {
+  return {
+    modules: [],
+    golangBindings: []
+  };
+}
+
+export const Config = {
+  encode(message: Config, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.modules) {
+      ModuleConfig.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.golangBindings) {
+      GolangBinding.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Config {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfig();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.modules.push(ModuleConfig.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.golangBindings.push(GolangBinding.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Config>): Config {
+    const message = createBaseConfig();
+    message.modules = object.modules?.map(e => ModuleConfig.fromPartial(e)) || [];
+    message.golangBindings = object.golangBindings?.map(e => GolangBinding.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseModuleConfig(): ModuleConfig {
+  return {
+    name: "",
+    config: undefined,
+    golangBindings: []
+  };
+}
+
+export const ModuleConfig = {
+  encode(message: ModuleConfig, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+
+    if (message.config !== undefined) {
+      Any.encode(message.config, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.golangBindings) {
+      GolangBinding.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ModuleConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModuleConfig();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+
+        case 2:
+          message.config = Any.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.golangBindings.push(GolangBinding.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ModuleConfig>): ModuleConfig {
+    const message = createBaseModuleConfig();
+    message.name = object.name ?? "";
+    message.config = object.config !== undefined && object.config !== null ? Any.fromPartial(object.config) : undefined;
+    message.golangBindings = object.golangBindings?.map(e => GolangBinding.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseGolangBinding(): GolangBinding {
+  return {
+    interfaceType: "",
+    implementation: ""
+  };
+}
+
+export const GolangBinding = {
+  encode(message: GolangBinding, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.interfaceType !== "") {
+      writer.uint32(10).string(message.interfaceType);
+    }
+
+    if (message.implementation !== "") {
+      writer.uint32(18).string(message.implementation);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GolangBinding {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGolangBinding();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.interfaceType = reader.string();
+          break;
+
+        case 2:
+          message.implementation = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GolangBinding>): GolangBinding {
+    const message = createBaseGolangBinding();
+    message.interfaceType = object.interfaceType ?? "";
+    message.implementation = object.implementation ?? "";
+    return message;
+  }
+
+};