juno-network 0.0.2

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

@@ -0,0 +1,34 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import * as _m0 from "protobufjs/minimal";
+import { QueryParamsRequest, QueryParamsResponse, QuerySigningInfoRequest, QuerySigningInfoResponse, QuerySigningInfosRequest, QuerySigningInfosResponse } from "./query";
+/** Query defines the RPC service */
+
+export class QueryClientImpl {
+  constructor(rpc) {
+    _defineProperty(this, "rpc", void 0);
+
+    this.rpc = rpc;
+    this.params = this.params.bind(this);
+    this.signingInfo = this.signingInfo.bind(this);
+    this.signingInfos = this.signingInfos.bind(this);
+  }
+
+  params(request) {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  signingInfo(request) {
+    const data = QuerySigningInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfo", data);
+    return promise.then(data => QuerySigningInfoResponse.decode(new _m0.Reader(data)));
+  }
+
+  signingInfos(request) {
+    const data = QuerySigningInfosRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Query", "SigningInfos", data);
+    return promise.then(data => QuerySigningInfosResponse.decode(new _m0.Reader(data)));
+  }
+
+}

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

@@ -0,0 +1,234 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { Duration } from "../../../google/protobuf/duration";
+import * as _m0 from "protobufjs/minimal";
+import { toTimestamp, Long, fromTimestamp, isSet, fromJsonTimestamp, bytesFromBase64, base64FromBytes } from "@osmonauts/helpers";
+/**
+ * ValidatorSigningInfo defines a validator's signing info for monitoring their
+ * liveness activity.
+ */
+
+function createBaseValidatorSigningInfo() {
+  return {
+    address: "",
+    startHeight: Long.ZERO,
+    indexOffset: Long.ZERO,
+    jailedUntil: undefined,
+    tombstoned: false,
+    missedBlocksCounter: Long.ZERO
+  };
+}
+
+export const ValidatorSigningInfo = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+
+    if (!message.startHeight.isZero()) {
+      writer.uint32(16).int64(message.startHeight);
+    }
+
+    if (!message.indexOffset.isZero()) {
+      writer.uint32(24).int64(message.indexOffset);
+    }
+
+    if (message.jailedUntil !== undefined) {
+      Timestamp.encode(toTimestamp(message.jailedUntil), writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.tombstoned === true) {
+      writer.uint32(40).bool(message.tombstoned);
+    }
+
+    if (!message.missedBlocksCounter.isZero()) {
+      writer.uint32(48).int64(message.missedBlocksCounter);
+    }
+
+    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 = createBaseValidatorSigningInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+
+        case 2:
+          message.startHeight = reader.int64();
+          break;
+
+        case 3:
+          message.indexOffset = reader.int64();
+          break;
+
+        case 4:
+          message.jailedUntil = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        case 5:
+          message.tombstoned = reader.bool();
+          break;
+
+        case 6:
+          message.missedBlocksCounter = reader.int64();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      startHeight: isSet(object.startHeight) ? Long.fromString(object.startHeight) : Long.ZERO,
+      indexOffset: isSet(object.indexOffset) ? Long.fromString(object.indexOffset) : Long.ZERO,
+      jailedUntil: isSet(object.jailedUntil) ? fromJsonTimestamp(object.jailedUntil) : undefined,
+      tombstoned: isSet(object.tombstoned) ? Boolean(object.tombstoned) : false,
+      missedBlocksCounter: isSet(object.missedBlocksCounter) ? Long.fromString(object.missedBlocksCounter) : Long.ZERO
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.startHeight !== undefined && (obj.startHeight = (message.startHeight || Long.ZERO).toString());
+    message.indexOffset !== undefined && (obj.indexOffset = (message.indexOffset || Long.ZERO).toString());
+    message.jailedUntil !== undefined && (obj.jailedUntil = message.jailedUntil.toISOString());
+    message.tombstoned !== undefined && (obj.tombstoned = message.tombstoned);
+    message.missedBlocksCounter !== undefined && (obj.missedBlocksCounter = (message.missedBlocksCounter || Long.ZERO).toString());
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$address, _object$jailedUntil, _object$tombstoned;
+
+    const message = createBaseValidatorSigningInfo();
+    message.address = (_object$address = object.address) !== null && _object$address !== void 0 ? _object$address : "";
+    message.startHeight = object.startHeight !== undefined && object.startHeight !== null ? Long.fromValue(object.startHeight) : Long.ZERO;
+    message.indexOffset = object.indexOffset !== undefined && object.indexOffset !== null ? Long.fromValue(object.indexOffset) : Long.ZERO;
+    message.jailedUntil = (_object$jailedUntil = object.jailedUntil) !== null && _object$jailedUntil !== void 0 ? _object$jailedUntil : undefined;
+    message.tombstoned = (_object$tombstoned = object.tombstoned) !== null && _object$tombstoned !== void 0 ? _object$tombstoned : false;
+    message.missedBlocksCounter = object.missedBlocksCounter !== undefined && object.missedBlocksCounter !== null ? Long.fromValue(object.missedBlocksCounter) : Long.ZERO;
+    return message;
+  }
+
+};
+
+function createBaseParams() {
+  return {
+    signedBlocksWindow: Long.ZERO,
+    minSignedPerWindow: new Uint8Array(),
+    downtimeJailDuration: undefined,
+    slashFractionDoubleSign: new Uint8Array(),
+    slashFractionDowntime: new Uint8Array()
+  };
+}
+
+export const Params = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.signedBlocksWindow.isZero()) {
+      writer.uint32(8).int64(message.signedBlocksWindow);
+    }
+
+    if (message.minSignedPerWindow.length !== 0) {
+      writer.uint32(18).bytes(message.minSignedPerWindow);
+    }
+
+    if (message.downtimeJailDuration !== undefined) {
+      Duration.encode(message.downtimeJailDuration, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.slashFractionDoubleSign.length !== 0) {
+      writer.uint32(34).bytes(message.slashFractionDoubleSign);
+    }
+
+    if (message.slashFractionDowntime.length !== 0) {
+      writer.uint32(42).bytes(message.slashFractionDowntime);
+    }
+
+    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 = createBaseParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.signedBlocksWindow = reader.int64();
+          break;
+
+        case 2:
+          message.minSignedPerWindow = reader.bytes();
+          break;
+
+        case 3:
+          message.downtimeJailDuration = Duration.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.slashFractionDoubleSign = reader.bytes();
+          break;
+
+        case 5:
+          message.slashFractionDowntime = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      signedBlocksWindow: isSet(object.signedBlocksWindow) ? Long.fromString(object.signedBlocksWindow) : Long.ZERO,
+      minSignedPerWindow: isSet(object.minSignedPerWindow) ? bytesFromBase64(object.minSignedPerWindow) : new Uint8Array(),
+      downtimeJailDuration: isSet(object.downtimeJailDuration) ? Duration.fromJSON(object.downtimeJailDuration) : undefined,
+      slashFractionDoubleSign: isSet(object.slashFractionDoubleSign) ? bytesFromBase64(object.slashFractionDoubleSign) : new Uint8Array(),
+      slashFractionDowntime: isSet(object.slashFractionDowntime) ? bytesFromBase64(object.slashFractionDowntime) : new Uint8Array()
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.signedBlocksWindow !== undefined && (obj.signedBlocksWindow = (message.signedBlocksWindow || Long.ZERO).toString());
+    message.minSignedPerWindow !== undefined && (obj.minSignedPerWindow = base64FromBytes(message.minSignedPerWindow !== undefined ? message.minSignedPerWindow : new Uint8Array()));
+    message.downtimeJailDuration !== undefined && (obj.downtimeJailDuration = message.downtimeJailDuration);
+    message.slashFractionDoubleSign !== undefined && (obj.slashFractionDoubleSign = base64FromBytes(message.slashFractionDoubleSign !== undefined ? message.slashFractionDoubleSign : new Uint8Array()));
+    message.slashFractionDowntime !== undefined && (obj.slashFractionDowntime = base64FromBytes(message.slashFractionDowntime !== undefined ? message.slashFractionDowntime : new Uint8Array()));
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$minSignedPerW, _object$downtimeJailD, _object$slashFraction, _object$slashFraction2;
+
+    const message = createBaseParams();
+    message.signedBlocksWindow = object.signedBlocksWindow !== undefined && object.signedBlocksWindow !== null ? Long.fromValue(object.signedBlocksWindow) : Long.ZERO;
+    message.minSignedPerWindow = (_object$minSignedPerW = object.minSignedPerWindow) !== null && _object$minSignedPerW !== void 0 ? _object$minSignedPerW : new Uint8Array();
+    message.downtimeJailDuration = (_object$downtimeJailD = object.downtimeJailDuration) !== null && _object$downtimeJailD !== void 0 ? _object$downtimeJailD : undefined;
+    message.slashFractionDoubleSign = (_object$slashFraction = object.slashFractionDoubleSign) !== null && _object$slashFraction !== void 0 ? _object$slashFraction : new Uint8Array();
+    message.slashFractionDowntime = (_object$slashFraction2 = object.slashFractionDowntime) !== null && _object$slashFraction2 !== void 0 ? _object$slashFraction2 : new Uint8Array();
+    return message;
+  }
+
+};

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

@@ -0,0 +1,19 @@
+export const AminoConverter = {
+  "/cosmos.slashing.v1beta1.MsgUnjail": {
+    aminoType: "cosmos-sdk/MsgUnjail",
+    toAmino: ({
+      validatorAddr
+    }) => {
+      return {
+        validator_addr: validatorAddr
+      };
+    },
+    fromAmino: ({
+      validator_addr
+    }) => {
+      return {
+        validatorAddr: validator_addr
+      };
+    }
+  }
+};

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

@@ -0,0 +1,105 @@
+import * as _m0 from "protobufjs/minimal";
+import { isSet } from "@osmonauts/helpers";
+/** MsgUnjail defines the Msg/Unjail request type */
+
+function createBaseMsgUnjail() {
+  return {
+    validatorAddr: ""
+  };
+}
+
+export const MsgUnjail = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.validatorAddr !== "") {
+      writer.uint32(10).string(message.validatorAddr);
+    }
+
+    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 = createBaseMsgUnjail();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.validatorAddr = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      validatorAddr: isSet(object.validatorAddr) ? String(object.validatorAddr) : ""
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.validatorAddr !== undefined && (obj.validatorAddr = message.validatorAddr);
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$validatorAddr;
+
+    const message = createBaseMsgUnjail();
+    message.validatorAddr = (_object$validatorAddr = object.validatorAddr) !== null && _object$validatorAddr !== void 0 ? _object$validatorAddr : "";
+    return message;
+  }
+
+};
+
+function createBaseMsgUnjailResponse() {
+  return {};
+}
+
+export const MsgUnjailResponse = {
+  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 = createBaseMsgUnjailResponse();
+
+    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 = createBaseMsgUnjailResponse();
+    return message;
+  }
+
+};

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

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

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

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

package/module/codegen/cosmos/staking/v1beta1/authz.js

@@ -0,0 +1,226 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { isSet } from "@osmonauts/helpers";
+/**
+ * AuthorizationType defines the type of staking module authorization type
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+export let AuthorizationType;
+
+(function (AuthorizationType) {
+  AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNSPECIFIED"] = 0] = "AUTHORIZATION_TYPE_UNSPECIFIED";
+  AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_DELEGATE"] = 1] = "AUTHORIZATION_TYPE_DELEGATE";
+  AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_UNDELEGATE"] = 2] = "AUTHORIZATION_TYPE_UNDELEGATE";
+  AuthorizationType[AuthorizationType["AUTHORIZATION_TYPE_REDELEGATE"] = 3] = "AUTHORIZATION_TYPE_REDELEGATE";
+  AuthorizationType[AuthorizationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(AuthorizationType || (AuthorizationType = {}));
+
+export function authorizationTypeFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "AUTHORIZATION_TYPE_UNSPECIFIED":
+      return AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED;
+
+    case 1:
+    case "AUTHORIZATION_TYPE_DELEGATE":
+      return AuthorizationType.AUTHORIZATION_TYPE_DELEGATE;
+
+    case 2:
+    case "AUTHORIZATION_TYPE_UNDELEGATE":
+      return AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE;
+
+    case 3:
+    case "AUTHORIZATION_TYPE_REDELEGATE":
+      return AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AuthorizationType.UNRECOGNIZED;
+  }
+}
+export function authorizationTypeToJSON(object) {
+  switch (object) {
+    case AuthorizationType.AUTHORIZATION_TYPE_UNSPECIFIED:
+      return "AUTHORIZATION_TYPE_UNSPECIFIED";
+
+    case AuthorizationType.AUTHORIZATION_TYPE_DELEGATE:
+      return "AUTHORIZATION_TYPE_DELEGATE";
+
+    case AuthorizationType.AUTHORIZATION_TYPE_UNDELEGATE:
+      return "AUTHORIZATION_TYPE_UNDELEGATE";
+
+    case AuthorizationType.AUTHORIZATION_TYPE_REDELEGATE:
+      return "AUTHORIZATION_TYPE_REDELEGATE";
+
+    default:
+      return "UNKNOWN";
+  }
+}
+/**
+ * StakeAuthorization defines authorization for delegate/undelegate/redelegate.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+function createBaseStakeAuthorization() {
+  return {
+    maxTokens: undefined,
+    allowList: undefined,
+    denyList: undefined,
+    authorizationType: 0
+  };
+}
+
+export const StakeAuthorization = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.maxTokens !== undefined) {
+      Coin.encode(message.maxTokens, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.allowList !== undefined) {
+      StakeAuthorization_Validators.encode(message.allowList, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.denyList !== undefined) {
+      StakeAuthorization_Validators.encode(message.denyList, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.authorizationType !== 0) {
+      writer.uint32(32).int32(message.authorizationType);
+    }
+
+    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 = createBaseStakeAuthorization();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.maxTokens = Coin.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.allowList = StakeAuthorization_Validators.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.denyList = StakeAuthorization_Validators.decode(reader, reader.uint32());
+          break;
+
+        case 4:
+          message.authorizationType = reader.int32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      maxTokens: isSet(object.maxTokens) ? Coin.fromJSON(object.maxTokens) : undefined,
+      allowList: isSet(object.allowList) ? StakeAuthorization_Validators.fromJSON(object.allowList) : undefined,
+      denyList: isSet(object.denyList) ? StakeAuthorization_Validators.fromJSON(object.denyList) : undefined,
+      authorizationType: isSet(object.authorizationType) ? authorizationTypeFromJSON(object.authorizationType) : 0
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.maxTokens !== undefined && (obj.maxTokens = message.maxTokens ? Coin.toJSON(message.maxTokens) : undefined);
+    message.allowList !== undefined && (obj.allowList = message.allowList ? StakeAuthorization_Validators.toJSON(message.allowList) : undefined);
+    message.denyList !== undefined && (obj.denyList = message.denyList ? StakeAuthorization_Validators.toJSON(message.denyList) : undefined);
+    message.authorizationType !== undefined && (obj.authorizationType = authorizationTypeToJSON(message.authorizationType));
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$authorization;
+
+    const message = createBaseStakeAuthorization();
+    message.maxTokens = object.maxTokens !== undefined && object.maxTokens !== null ? Coin.fromPartial(object.maxTokens) : undefined;
+    message.allowList = object.allowList !== undefined && object.allowList !== null ? StakeAuthorization_Validators.fromPartial(object.allowList) : undefined;
+    message.denyList = object.denyList !== undefined && object.denyList !== null ? StakeAuthorization_Validators.fromPartial(object.denyList) : undefined;
+    message.authorizationType = (_object$authorization = object.authorizationType) !== null && _object$authorization !== void 0 ? _object$authorization : 0;
+    return message;
+  }
+
+};
+
+function createBaseStakeAuthorization_Validators() {
+  return {
+    address: []
+  };
+}
+
+export const StakeAuthorization_Validators = {
+  encode(message, writer = _m0.Writer.create()) {
+    for (const v of message.address) {
+      writer.uint32(10).string(v);
+    }
+
+    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 = createBaseStakeAuthorization_Validators();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.address.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      address: Array.isArray(object === null || object === void 0 ? void 0 : object.address) ? object.address.map(e => String(e)) : []
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+
+    if (message.address) {
+      obj.address = message.address.map(e => e);
+    } else {
+      obj.address = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _object$address;
+
+    const message = createBaseStakeAuthorization_Validators();
+    message.address = ((_object$address = object.address) === null || _object$address === void 0 ? void 0 : _object$address.map(e => e)) || [];
+    return message;
+  }
+
+};