juno-network 0.5.3 → 0.6.0

package/src/codegen/cosmos/capability/v1beta1/genesis.ts

@@ -0,0 +1,168 @@
+import { CapabilityOwners } from "./capability";
+import * as _m0 from "protobufjs/minimal";
+import { Long, isSet, DeepPartial } from "@osmonauts/helpers";
+
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwners {
+  /** index is the index of the capability owner. */
+  index: Long;
+
+  /** index_owners are the owners at the given index. */
+  index_owners: CapabilityOwners;
+}
+
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisState {
+  /** index is the capability global index. */
+  index: Long;
+
+  /**
+   * owners represents a map from index to owners of the capability index
+   * index key is string to allow amino marshalling.
+   */
+  owners: GenesisOwners[];
+}
+
+function createBaseGenesisOwners(): GenesisOwners {
+  return {
+    index: Long.UZERO,
+    index_owners: undefined
+  };
+}
+
+export const GenesisOwners = {
+  encode(message: GenesisOwners, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): GenesisOwners {
+    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() as Long);
+          break;
+
+        case 2:
+          message.index_owners = CapabilityOwners.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): GenesisOwners {
+    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: GenesisOwners): unknown {
+    const obj: any = {};
+    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: DeepPartial<GenesisOwners>): GenesisOwners {
+    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(): GenesisState {
+  return {
+    index: Long.UZERO,
+    owners: []
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    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() as Long);
+          break;
+
+        case 2:
+          message.owners.push(GenesisOwners.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object: any): GenesisState {
+    return {
+      index: isSet(object.index) ? Long.fromString(object.index) : Long.UZERO,
+      owners: Array.isArray(object?.owners) ? object.owners.map((e: any) => GenesisOwners.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message: GenesisState): unknown {
+    const obj: any = {};
+    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: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.index = object.index !== undefined && object.index !== null ? Long.fromValue(object.index) : Long.UZERO;
+    message.owners = object.owners?.map(e => GenesisOwners.fromPartial(e)) || [];
+    return message;
+  }
+
+};

package/src/codegen/cosmos/client.ts

@@ -0,0 +1,51 @@
+import { OfflineSigner, GeneratedType, 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 = { ...cosmosBankV1beta1TxAmino.AminoConverter,
+  ...cosmosDistributionV1beta1TxAmino.AminoConverter,
+  ...cosmosGovV1TxAmino.AminoConverter,
+  ...cosmosGovV1beta1TxAmino.AminoConverter,
+  ...cosmosStakingV1beta1TxAmino.AminoConverter,
+  ...cosmosUpgradeV1beta1TxAmino.AminoConverter
+};
+export const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmosBankV1beta1TxRegistry.registry, ...cosmosDistributionV1beta1TxRegistry.registry, ...cosmosGovV1TxRegistry.registry, ...cosmosGovV1beta1TxRegistry.registry, ...cosmosStakingV1beta1TxRegistry.registry, ...cosmosUpgradeV1beta1TxRegistry.registry];
+export const getSigningCosmosClientOptions = (): {
+  registry: Registry;
+  aminoTypes: AminoTypes;
+} => {
+  const registry = new Registry([...cosmosProtoRegistry]);
+  const aminoTypes = new AminoTypes({ ...cosmosAminoConverters
+  });
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningCosmosClient = async ({
+  rpcEndpoint,
+  signer
+}: {
+  rpcEndpoint: string;
+  signer: OfflineSigner;
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningCosmosClientOptions();
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry,
+    aminoTypes
+  });
+  return client;
+};

package/src/codegen/cosmos/crisis/v1beta1/genesis.ts

@@ -0,0 +1,69 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { isSet, DeepPartial } from "@osmonauts/helpers";
+
+/** GenesisState defines the crisis module's genesis state. */
+export interface GenesisState {
+  /**
+   * constant_fee is the fee used to verify the invariant in the crisis
+   * module.
+   */
+  constant_fee: Coin;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    constant_fee: undefined
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.constant_fee !== undefined) {
+      Coin.encode(message.constant_fee, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    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: any): GenesisState {
+    return {
+      constant_fee: isSet(object.constant_fee) ? Coin.fromJSON(object.constant_fee) : undefined
+    };
+  },
+
+  toJSON(message: GenesisState): unknown {
+    const obj: any = {};
+    message.constant_fee !== undefined && (obj.constant_fee = message.constant_fee ? Coin.toJSON(message.constant_fee) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.constant_fee = object.constant_fee !== undefined && object.constant_fee !== null ? Coin.fromPartial(object.constant_fee) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/crisis/v1beta1/tx.amino.ts

@@ -0,0 +1,37 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgVerifyInvariant } from "./tx";
+export interface AminoMsgVerifyInvariant extends AminoMsg {
+  type: "cosmos-sdk/MsgVerifyInvariant";
+  value: {
+    sender: string;
+    invariant_module_name: string;
+    invariant_route: string;
+  };
+}
+export const AminoConverter = {
+  "/cosmos.crisis.v1beta1.MsgVerifyInvariant": {
+    aminoType: "cosmos-sdk/MsgVerifyInvariant",
+    toAmino: ({
+      sender,
+      invariant_module_name,
+      invariant_route
+    }: MsgVerifyInvariant): AminoMsgVerifyInvariant["value"] => {
+      return {
+        sender,
+        invariant_module_name,
+        invariant_route
+      };
+    },
+    fromAmino: ({
+      sender,
+      invariant_module_name,
+      invariant_route
+    }: AminoMsgVerifyInvariant["value"]): MsgVerifyInvariant => {
+      return {
+        sender,
+        invariant_module_name,
+        invariant_route
+      };
+    }
+  }
+};

package/src/codegen/cosmos/crisis/v1beta1/tx.registry.ts

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

package/src/codegen/cosmos/crisis/v1beta1/tx.rpc.msg.ts

@@ -0,0 +1,25 @@
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgVerifyInvariant, MsgVerifyInvariantResponse } from "./tx";
+
+/** Msg defines the RPC service */
+export interface Msg {
+  verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse>;
+  /*VerifyInvariant defines a method to verify a particular invariance.*/
+
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.verifyInvariant = this.verifyInvariant.bind(this);
+  }
+
+  verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse> {
+    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)));
+  }
+
+}

package/src/codegen/cosmos/crisis/v1beta1/tx.ts

@@ -0,0 +1,136 @@
+import * as _m0 from "protobufjs/minimal";
+import { isSet, DeepPartial } from "@osmonauts/helpers";
+
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+export interface MsgVerifyInvariant {
+  sender: string;
+  invariant_module_name: string;
+  invariant_route: string;
+}
+
+/** MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. */
+export interface MsgVerifyInvariantResponse {}
+
+function createBaseMsgVerifyInvariant(): MsgVerifyInvariant {
+  return {
+    sender: "",
+    invariant_module_name: "",
+    invariant_route: ""
+  };
+}
+
+export const MsgVerifyInvariant = {
+  encode(message: MsgVerifyInvariant, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): MsgVerifyInvariant {
+    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: any): MsgVerifyInvariant {
+    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: MsgVerifyInvariant): unknown {
+    const obj: any = {};
+    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: DeepPartial<MsgVerifyInvariant>): MsgVerifyInvariant {
+    const message = createBaseMsgVerifyInvariant();
+    message.sender = object.sender ?? "";
+    message.invariant_module_name = object.invariant_module_name ?? "";
+    message.invariant_route = object.invariant_route ?? "";
+    return message;
+  }
+
+};
+
+function createBaseMsgVerifyInvariantResponse(): MsgVerifyInvariantResponse {
+  return {};
+}
+
+export const MsgVerifyInvariantResponse = {
+  encode(_: MsgVerifyInvariantResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgVerifyInvariantResponse {
+    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(_: any): MsgVerifyInvariantResponse {
+    return {};
+  },
+
+  toJSON(_: MsgVerifyInvariantResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial(_: DeepPartial<MsgVerifyInvariantResponse>): MsgVerifyInvariantResponse {
+    const message = createBaseMsgVerifyInvariantResponse();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/crypto/ed25519/keys.ts

@@ -0,0 +1,130 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * PubKey is an ed25519 public key for handling Tendermint keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use ed25519 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ */
+
+export interface PubKey {
+  key: Uint8Array;
+}
+/**
+ * PubKey is an ed25519 public key for handling Tendermint keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use ed25519 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ */
+
+export interface PubKeySDKType {
+  key: Uint8Array;
+}
+/**
+ * Deprecated: PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+
+export interface PrivKey {
+  key: Uint8Array;
+}
+/**
+ * Deprecated: PrivKey defines a ed25519 private key.
+ * NOTE: ed25519 keys must not be used in SDK apps except in a tendermint validator context.
+ */
+
+export interface PrivKeySDKType {
+  key: Uint8Array;
+}
+
+function createBasePubKey(): PubKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+
+export const PubKey = {
+  encode(message: PubKey, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PubKey {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePubKey();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PubKey>): PubKey {
+    const message = createBasePubKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBasePrivKey(): PrivKey {
+  return {
+    key: new Uint8Array()
+  };
+}
+
+export const PrivKey = {
+  encode(message: PrivKey, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PrivKey {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePrivKey();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<PrivKey>): PrivKey {
+    const message = createBasePrivKey();
+    message.key = object.key ?? new Uint8Array();
+    return message;
+  }
+
+};