juno-network 0.5.3 → 0.6.0

package/module/codegen/cosmos/capability/v1beta1/capability.js

@@ -0,0 +1,199 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long, isSet } from "@osmonauts/helpers";
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+
+function createBaseCapability() {
+  return {
+    index: Long.UZERO
+  };
+}
+
+export const Capability = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.index.isZero()) {
+      writer.uint32(8).uint64(message.index);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapability();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      index: isSet(object.index) ? Long.fromString(object.index) : Long.UZERO
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.index !== undefined && (obj.index = (message.index || Long.UZERO).toString());
+    return obj;
+  },
+
+  fromPartial(object) {
+    const message = createBaseCapability();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseOwner() {
+  return {
+    module: "",
+    name: ""
+  };
+}
+
+export const Owner = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.module !== "") {
+      writer.uint32(10).string(message.module);
+    }
+
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOwner();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.module = reader.string();
+          break;
+
+        case 2:
+          message.name = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      module: isSet(object.module) ? String(object.module) : "",
+      name: isSet(object.name) ? String(object.name) : ""
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.module !== undefined && (obj.module = message.module);
+    message.name !== undefined && (obj.name = message.name);
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$module, _object$name;
+
+    const message = createBaseOwner();
+    message.module = (_object$module = object.module) !== null && _object$module !== void 0 ? _object$module : "";
+    message.name = (_object$name = object.name) !== null && _object$name !== void 0 ? _object$name : "";
+    return message;
+  }
+
+};
+
+function createBaseCapabilityOwners() {
+  return {
+    owners: []
+  };
+}
+
+export const CapabilityOwners = {
+  encode(message, writer = _m0.Writer.create()) {
+    for (const v of message.owners) {
+      Owner.encode(v, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapabilityOwners();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.owners.push(Owner.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      owners: Array.isArray(object === null || object === void 0 ? void 0 : object.owners) ? object.owners.map(e => Owner.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? Owner.toJSON(e) : undefined);
+    } else {
+      obj.owners = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$owners;
+
+    const message = createBaseCapabilityOwners();
+    message.owners = ((_object$owners = object.owners) === null || _object$owners === void 0 ? void 0 : _object$owners.map(e => Owner.fromPartial(e))) || [];
+    return message;
+  }
+
+};

package/module/codegen/cosmos/capability/v1beta1/genesis.js

@@ -0,0 +1,150 @@
+import { CapabilityOwners } from "./capability";
+import * as _m0 from "protobufjs/minimal";
+import { Long, isSet } from "@osmonauts/helpers";
+/** GenesisOwners defines the capability owners with their corresponding index. */
+
+function createBaseGenesisOwners() {
+  return {
+    index: Long.UZERO,
+    index_owners: undefined
+  };
+}
+
+export const GenesisOwners = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.index.isZero()) {
+      writer.uint32(8).uint64(message.index);
+    }
+
+    if (message.index_owners !== undefined) {
+      CapabilityOwners.encode(message.index_owners, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisOwners();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+
+        case 2:
+          message.index_owners = CapabilityOwners.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      index: isSet(object.index) ? Long.fromString(object.index) : Long.UZERO,
+      index_owners: isSet(object.index_owners) ? CapabilityOwners.fromJSON(object.index_owners) : undefined
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.index !== undefined && (obj.index = (message.index || Long.UZERO).toString());
+    message.index_owners !== undefined && (obj.index_owners = message.index_owners ? CapabilityOwners.toJSON(message.index_owners) : undefined);
+    return obj;
+  },
+
+  fromPartial(object) {
+    const message = createBaseGenesisOwners();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.UZERO;
+    message.index_owners = object.index_owners !== undefined && object.index_owners !== null ? CapabilityOwners.fromPartial(object.index_owners) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseGenesisState() {
+  return {
+    index: Long.UZERO,
+    owners: []
+  };
+}
+
+export const GenesisState = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.index.isZero()) {
+      writer.uint32(8).uint64(message.index);
+    }
+
+    for (const v of message.owners) {
+      GenesisOwners.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+
+        case 2:
+          message.owners.push(GenesisOwners.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      index: isSet(object.index) ? Long.fromString(object.index) : Long.UZERO,
+      owners: Array.isArray(object === null || object === void 0 ? void 0 : object.owners) ? object.owners.map(e => GenesisOwners.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.index !== undefined && (obj.index = (message.index || Long.UZERO).toString());
+
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? GenesisOwners.toJSON(e) : undefined);
+    } else {
+      obj.owners = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$owners;
+
+    const message = createBaseGenesisState();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.UZERO;
+    message.owners = ((_object$owners = object.owners) === null || _object$owners === void 0 ? void 0 : _object$owners.map(e => GenesisOwners.fromPartial(e))) || [];
+    return message;
+  }
+
+};

package/module/codegen/cosmos/client.js

@@ -0,0 +1,44 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { Registry } from "@cosmjs/proto-signing";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import * as cosmosBankV1beta1TxRegistry from "./bank/v1beta1/tx.registry";
+import * as cosmosDistributionV1beta1TxRegistry from "./distribution/v1beta1/tx.registry";
+import * as cosmosGovV1TxRegistry from "./gov/v1/tx.registry";
+import * as cosmosGovV1beta1TxRegistry from "./gov/v1beta1/tx.registry";
+import * as cosmosStakingV1beta1TxRegistry from "./staking/v1beta1/tx.registry";
+import * as cosmosUpgradeV1beta1TxRegistry from "./upgrade/v1beta1/tx.registry";
+import * as cosmosBankV1beta1TxAmino from "./bank/v1beta1/tx.amino";
+import * as cosmosDistributionV1beta1TxAmino from "./distribution/v1beta1/tx.amino";
+import * as cosmosGovV1TxAmino from "./gov/v1/tx.amino";
+import * as cosmosGovV1beta1TxAmino from "./gov/v1beta1/tx.amino";
+import * as cosmosStakingV1beta1TxAmino from "./staking/v1beta1/tx.amino";
+import * as cosmosUpgradeV1beta1TxAmino from "./upgrade/v1beta1/tx.amino";
+export const cosmosAminoConverters = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, cosmosBankV1beta1TxAmino.AminoConverter), cosmosDistributionV1beta1TxAmino.AminoConverter), cosmosGovV1TxAmino.AminoConverter), cosmosGovV1beta1TxAmino.AminoConverter), cosmosStakingV1beta1TxAmino.AminoConverter), cosmosUpgradeV1beta1TxAmino.AminoConverter);
+export const cosmosProtoRegistry = [...cosmosBankV1beta1TxRegistry.registry, ...cosmosDistributionV1beta1TxRegistry.registry, ...cosmosGovV1TxRegistry.registry, ...cosmosGovV1beta1TxRegistry.registry, ...cosmosStakingV1beta1TxRegistry.registry, ...cosmosUpgradeV1beta1TxRegistry.registry];
+export const getSigningCosmosClientOptions = () => {
+  const registry = new Registry([...cosmosProtoRegistry]);
+  const aminoTypes = new AminoTypes(_objectSpread({}, cosmosAminoConverters));
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningCosmosClient = async ({
+  rpcEndpoint,
+  signer
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningCosmosClientOptions();
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry,
+    aminoTypes
+  });
+  return client;
+};

package/module/codegen/cosmos/crisis/v1beta1/genesis.js

@@ -0,0 +1,61 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { isSet } from "@osmonauts/helpers";
+/** GenesisState defines the crisis module's genesis state. */
+
+function createBaseGenesisState() {
+  return {
+    constant_fee: undefined
+  };
+}
+
+export const GenesisState = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.constant_fee !== undefined) {
+      Coin.encode(message.constant_fee, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 3:
+          message.constant_fee = Coin.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      constant_fee: isSet(object.constant_fee) ? Coin.fromJSON(object.constant_fee) : undefined
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.constant_fee !== undefined && (obj.constant_fee = message.constant_fee ? Coin.toJSON(message.constant_fee) : undefined);
+    return obj;
+  },
+
+  fromPartial(object) {
+    const message = createBaseGenesisState();
+    message.constant_fee = object.constant_fee !== undefined && object.constant_fee !== null ? Coin.fromPartial(object.constant_fee) : undefined;
+    return message;
+  }
+
+};

package/module/codegen/cosmos/crisis/v1beta1/tx.amino.js

@@ -0,0 +1,27 @@
+export const AminoConverter = {
+  "/cosmos.crisis.v1beta1.MsgVerifyInvariant": {
+    aminoType: "cosmos-sdk/MsgVerifyInvariant",
+    toAmino: ({
+      sender,
+      invariant_module_name,
+      invariant_route
+    }) => {
+      return {
+        sender,
+        invariant_module_name,
+        invariant_route
+      };
+    },
+    fromAmino: ({
+      sender,
+      invariant_module_name,
+      invariant_route
+    }) => {
+      return {
+        sender,
+        invariant_module_name,
+        invariant_route
+      };
+    }
+  }
+};

package/module/codegen/cosmos/crisis/v1beta1/tx.js

@@ -0,0 +1,129 @@
+import * as _m0 from "protobufjs/minimal";
+import { isSet } from "@osmonauts/helpers";
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+
+function createBaseMsgVerifyInvariant() {
+  return {
+    sender: "",
+    invariant_module_name: "",
+    invariant_route: ""
+  };
+}
+
+export const MsgVerifyInvariant = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+
+    if (message.invariant_module_name !== "") {
+      writer.uint32(18).string(message.invariant_module_name);
+    }
+
+    if (message.invariant_route !== "") {
+      writer.uint32(26).string(message.invariant_route);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVerifyInvariant();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sender = reader.string();
+          break;
+
+        case 2:
+          message.invariant_module_name = reader.string();
+          break;
+
+        case 3:
+          message.invariant_route = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      sender: isSet(object.sender) ? String(object.sender) : "",
+      invariant_module_name: isSet(object.invariant_module_name) ? String(object.invariant_module_name) : "",
+      invariant_route: isSet(object.invariant_route) ? String(object.invariant_route) : ""
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.sender !== undefined && (obj.sender = message.sender);
+    message.invariant_module_name !== undefined && (obj.invariant_module_name = message.invariant_module_name);
+    message.invariant_route !== undefined && (obj.invariant_route = message.invariant_route);
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$sender, _object$invariant_mod, _object$invariant_rou;
+
+    const message = createBaseMsgVerifyInvariant();
+    message.sender = (_object$sender = object.sender) !== null && _object$sender !== void 0 ? _object$sender : "";
+    message.invariant_module_name = (_object$invariant_mod = object.invariant_module_name) !== null && _object$invariant_mod !== void 0 ? _object$invariant_mod : "";
+    message.invariant_route = (_object$invariant_rou = object.invariant_route) !== null && _object$invariant_rou !== void 0 ? _object$invariant_rou : "";
+    return message;
+  }
+
+};
+
+function createBaseMsgVerifyInvariantResponse() {
+  return {};
+}
+
+export const MsgVerifyInvariantResponse = {
+  encode(_, writer = _m0.Writer.create()) {
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgVerifyInvariantResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(_) {
+    return {};
+  },
+
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+
+  fromPartial(_) {
+    const message = createBaseMsgVerifyInvariantResponse();
+    return message;
+  }
+
+};

package/module/codegen/cosmos/crisis/v1beta1/tx.registry.js

@@ -0,0 +1,54 @@
+import { MsgVerifyInvariant } from "./tx";
+export const registry = [["/cosmos.crisis.v1beta1.MsgVerifyInvariant", MsgVerifyInvariant]];
+export const load = protoRegistry => {
+  registry.forEach(([typeUrl, mod]) => {
+    protoRegistry.register(typeUrl, mod);
+  });
+};
+export const MessageComposer = {
+  encoded: {
+    verifyInvariant(value) {
+      return {
+        typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+        value: MsgVerifyInvariant.encode(value).finish()
+      };
+    }
+
+  },
+  withTypeUrl: {
+    verifyInvariant(value) {
+      return {
+        typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+        value
+      };
+    }
+
+  },
+  toJSON: {
+    verifyInvariant(value) {
+      return {
+        typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+        value: MsgVerifyInvariant.toJSON(value)
+      };
+    }
+
+  },
+  fromJSON: {
+    verifyInvariant(value) {
+      return {
+        typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+        value: MsgVerifyInvariant.fromJSON(value)
+      };
+    }
+
+  },
+  fromPartial: {
+    verifyInvariant(value) {
+      return {
+        typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
+        value: MsgVerifyInvariant.fromPartial(value)
+      };
+    }
+
+  }
+};

package/module/codegen/cosmos/crisis/v1beta1/tx.rpc.msg.js

@@ -0,0 +1,20 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import * as _m0 from "protobufjs/minimal";
+import { MsgVerifyInvariant, MsgVerifyInvariantResponse } from "./tx";
+/** Msg defines the RPC service */
+
+export class MsgClientImpl {
+  constructor(rpc) {
+    _defineProperty(this, "rpc", void 0);
+
+    this.rpc = rpc;
+    this.verifyInvariant = this.verifyInvariant.bind(this);
+  }
+
+  verifyInvariant(request) {
+    const data = MsgVerifyInvariant.encode(request).finish();
+    const promise = this.rpc.request("cosmos.crisis.v1beta1.Msg", "VerifyInvariant", data);
+    return promise.then(data => MsgVerifyInvariantResponse.decode(new _m0.Reader(data)));
+  }
+
+}