juno-network 0.15.1 → 0.18.0

package/module/codegen/cosmos/rpc.query.js

@@ -7,19 +7,51 @@ export const createRPCQueryClient = async ({
   const client = new QueryClient(tmClient);
   return {
     cosmos: {
+      app: {
+        v1alpha1: (await import("./app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      auth: {
+        v1beta1: (await import("./auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       authz: {
         v1beta1: (await import("./authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
       bank: {
         v1beta1: (await import("./bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
+      base: {
+        tendermint: {
+          v1beta1: (await import("./base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
       distribution: {
         v1beta1: (await import("./distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
+      evidence: {
+        v1beta1: (await import("./evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feegrant: {
+        v1beta1: (await import("./feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       gov: {
         v1: (await import("./gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
         v1beta1: (await import("./gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },
+      group: {
+        v1: (await import("./group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      mint: {
+        v1beta1: (await import("./mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      nft: {
+        v1beta1: (await import("./nft/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      params: {
+        v1beta1: (await import("./params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      slashing: {
+        v1beta1: (await import("./slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
       staking: {
         v1beta1: (await import("./staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
       },

package/module/codegen/cosmos/rpc.tx.js

@@ -8,18 +8,39 @@ export const createRPCMsgClient = async ({
     bank: {
       v1beta1: new (await import("./bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
     },
+    crisis: {
+      v1beta1: new (await import("./crisis/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
     distribution: {
       v1beta1: new (await import("./distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
     },
+    evidence: {
+      v1beta1: new (await import("./evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feegrant: {
+      v1beta1: new (await import("./feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
     gov: {
       v1: new (await import("./gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
       v1beta1: new (await import("./gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
     },
+    group: {
+      v1: new (await import("./group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    nft: {
+      v1beta1: new (await import("./nft/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    slashing: {
+      v1beta1: new (await import("./slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
     staking: {
       v1beta1: new (await import("./staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
     },
     upgrade: {
       v1beta1: new (await import("./upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    vesting: {
+      v1beta1: new (await import("./vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
     }
   }
 });

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

@@ -0,0 +1,383 @@
+import { Params, ValidatorSigningInfo } from "./slashing";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the slashing module's genesis state. */
+
+/** GenesisState defines the slashing module's genesis state. */
+
+/** GenesisState defines the slashing module's genesis state. */
+
+/** SigningInfo stores validator signing info of corresponding address. */
+
+/** SigningInfo stores validator signing info of corresponding address. */
+
+/** SigningInfo stores validator signing info of corresponding address. */
+
+/**
+ * ValidatorMissedBlocks contains array of missed blocks of corresponding
+ * address.
+ */
+
+/**
+ * ValidatorMissedBlocks contains array of missed blocks of corresponding
+ * address.
+ */
+
+/**
+ * ValidatorMissedBlocks contains array of missed blocks of corresponding
+ * address.
+ */
+
+/** MissedBlock contains height and missed status as boolean. */
+
+/** MissedBlock contains height and missed status as boolean. */
+
+/** MissedBlock contains height and missed status as boolean. */
+
+function createBaseGenesisState() {
+  return {
+    params: Params.fromPartial({}),
+    signingInfos: [],
+    missedBlocks: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.slashing.v1beta1.GenesisState",
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.signingInfos) {
+      SigningInfo.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.missedBlocks) {
+      ValidatorMissedBlocks.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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.params = Params.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.signingInfos.push(SigningInfo.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.missedBlocks.push(ValidatorMissedBlocks.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    var _object$signingInfos, _object$missedBlocks;
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.signingInfos = ((_object$signingInfos = object.signingInfos) === null || _object$signingInfos === void 0 ? void 0 : _object$signingInfos.map(e => SigningInfo.fromPartial(e))) || [];
+    message.missedBlocks = ((_object$missedBlocks = object.missedBlocks) === null || _object$missedBlocks === void 0 ? void 0 : _object$missedBlocks.map(e => ValidatorMissedBlocks.fromPartial(e))) || [];
+    return message;
+  },
+  fromAmino(object) {
+    var _object$signing_infos, _object$missed_blocks;
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    message.signingInfos = ((_object$signing_infos = object.signing_infos) === null || _object$signing_infos === void 0 ? void 0 : _object$signing_infos.map(e => SigningInfo.fromAmino(e))) || [];
+    message.missedBlocks = ((_object$missed_blocks = object.missed_blocks) === null || _object$missed_blocks === void 0 ? void 0 : _object$missed_blocks.map(e => ValidatorMissedBlocks.fromAmino(e))) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.params = message.params ? Params.toAmino(message.params) : undefined;
+    if (message.signingInfos) {
+      obj.signing_infos = message.signingInfos.map(e => e ? SigningInfo.toAmino(e) : undefined);
+    } else {
+      obj.signing_infos = [];
+    }
+    if (message.missedBlocks) {
+      obj.missed_blocks = message.missedBlocks.map(e => e ? ValidatorMissedBlocks.toAmino(e) : undefined);
+    } else {
+      obj.missed_blocks = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message) {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+function createBaseSigningInfo() {
+  return {
+    address: "",
+    validatorSigningInfo: ValidatorSigningInfo.fromPartial({})
+  };
+}
+export const SigningInfo = {
+  typeUrl: "/cosmos.slashing.v1beta1.SigningInfo",
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.validatorSigningInfo !== undefined) {
+      ValidatorSigningInfo.encode(message.validatorSigningInfo, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSigningInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.validatorSigningInfo = ValidatorSigningInfo.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    var _object$address;
+    const message = createBaseSigningInfo();
+    message.address = (_object$address = object.address) !== null && _object$address !== void 0 ? _object$address : "";
+    message.validatorSigningInfo = object.validatorSigningInfo !== undefined && object.validatorSigningInfo !== null ? ValidatorSigningInfo.fromPartial(object.validatorSigningInfo) : undefined;
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseSigningInfo();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.validator_signing_info !== undefined && object.validator_signing_info !== null) {
+      message.validatorSigningInfo = ValidatorSigningInfo.fromAmino(object.validator_signing_info);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.address = message.address;
+    obj.validator_signing_info = message.validatorSigningInfo ? ValidatorSigningInfo.toAmino(message.validatorSigningInfo) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return SigningInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "cosmos-sdk/SigningInfo",
+      value: SigningInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return SigningInfo.decode(message.value);
+  },
+  toProto(message) {
+    return SigningInfo.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.SigningInfo",
+      value: SigningInfo.encode(message).finish()
+    };
+  }
+};
+function createBaseValidatorMissedBlocks() {
+  return {
+    address: "",
+    missedBlocks: []
+  };
+}
+export const ValidatorMissedBlocks = {
+  typeUrl: "/cosmos.slashing.v1beta1.ValidatorMissedBlocks",
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    for (const v of message.missedBlocks) {
+      MissedBlock.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidatorMissedBlocks();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.missedBlocks.push(MissedBlock.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    var _object$address2, _object$missedBlocks2;
+    const message = createBaseValidatorMissedBlocks();
+    message.address = (_object$address2 = object.address) !== null && _object$address2 !== void 0 ? _object$address2 : "";
+    message.missedBlocks = ((_object$missedBlocks2 = object.missedBlocks) === null || _object$missedBlocks2 === void 0 ? void 0 : _object$missedBlocks2.map(e => MissedBlock.fromPartial(e))) || [];
+    return message;
+  },
+  fromAmino(object) {
+    var _object$missed_blocks2;
+    const message = createBaseValidatorMissedBlocks();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.missedBlocks = ((_object$missed_blocks2 = object.missed_blocks) === null || _object$missed_blocks2 === void 0 ? void 0 : _object$missed_blocks2.map(e => MissedBlock.fromAmino(e))) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.address = message.address;
+    if (message.missedBlocks) {
+      obj.missed_blocks = message.missedBlocks.map(e => e ? MissedBlock.toAmino(e) : undefined);
+    } else {
+      obj.missed_blocks = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return ValidatorMissedBlocks.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "cosmos-sdk/ValidatorMissedBlocks",
+      value: ValidatorMissedBlocks.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return ValidatorMissedBlocks.decode(message.value);
+  },
+  toProto(message) {
+    return ValidatorMissedBlocks.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.ValidatorMissedBlocks",
+      value: ValidatorMissedBlocks.encode(message).finish()
+    };
+  }
+};
+function createBaseMissedBlock() {
+  return {
+    index: BigInt(0),
+    missed: false
+  };
+}
+export const MissedBlock = {
+  typeUrl: "/cosmos.slashing.v1beta1.MissedBlock",
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).int64(message.index);
+    }
+    if (message.missed === true) {
+      writer.uint32(16).bool(message.missed);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMissedBlock();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.int64();
+          break;
+        case 2:
+          message.missed = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object) {
+    var _object$missed;
+    const message = createBaseMissedBlock();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    message.missed = (_object$missed = object.missed) !== null && _object$missed !== void 0 ? _object$missed : false;
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseMissedBlock();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    if (object.missed !== undefined && object.missed !== null) {
+      message.missed = object.missed;
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.index = message.index ? message.index.toString() : undefined;
+    obj.missed = message.missed;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return MissedBlock.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "cosmos-sdk/MissedBlock",
+      value: MissedBlock.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return MissedBlock.decode(message.value);
+  },
+  toProto(message) {
+    return MissedBlock.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.MissedBlock",
+      value: MissedBlock.encode(message).finish()
+    };
+  }
+};