@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/slashing/v1beta1/query.ts

@@ -0,0 +1,358 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { Params, ParamsSDKType, ValidatorSigningInfo, ValidatorSigningInfoSDKType } from "./slashing";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method */
+
+export interface QueryParamsRequest {}
+/** QueryParamsRequest is the request type for the Query/Params RPC method */
+
+export interface QueryParamsRequestSDKType {}
+/** QueryParamsResponse is the response type for the Query/Params RPC method */
+
+export interface QueryParamsResponse {
+  params?: Params;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method */
+
+export interface QueryParamsResponseSDKType {
+  params?: ParamsSDKType;
+}
+/**
+ * QuerySigningInfoRequest is the request type for the Query/SigningInfo RPC
+ * method
+ */
+
+export interface QuerySigningInfoRequest {
+  /** cons_address is the address to query signing info of */
+  consAddress: string;
+}
+/**
+ * QuerySigningInfoRequest is the request type for the Query/SigningInfo RPC
+ * method
+ */
+
+export interface QuerySigningInfoRequestSDKType {
+  cons_address: string;
+}
+/**
+ * QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC
+ * method
+ */
+
+export interface QuerySigningInfoResponse {
+  /** val_signing_info is the signing info of requested val cons address */
+  valSigningInfo?: ValidatorSigningInfo;
+}
+/**
+ * QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC
+ * method
+ */
+
+export interface QuerySigningInfoResponseSDKType {
+  val_signing_info?: ValidatorSigningInfoSDKType;
+}
+/**
+ * QuerySigningInfosRequest is the request type for the Query/SigningInfos RPC
+ * method
+ */
+
+export interface QuerySigningInfosRequest {
+  pagination?: PageRequest;
+}
+/**
+ * QuerySigningInfosRequest is the request type for the Query/SigningInfos RPC
+ * method
+ */
+
+export interface QuerySigningInfosRequestSDKType {
+  pagination?: PageRequestSDKType;
+}
+/**
+ * QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC
+ * method
+ */
+
+export interface QuerySigningInfosResponse {
+  /** info is the signing info of all validators */
+  info: ValidatorSigningInfo[];
+  pagination?: PageResponse;
+}
+/**
+ * QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC
+ * method
+ */
+
+export interface QuerySigningInfosResponseSDKType {
+  info: ValidatorSigningInfoSDKType[];
+  pagination?: PageResponseSDKType;
+}
+
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+
+export const QueryParamsRequest = {
+  encode(_: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  }
+
+};
+
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: undefined
+  };
+}
+
+export const QueryParamsResponse = {
+  encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQuerySigningInfoRequest(): QuerySigningInfoRequest {
+  return {
+    consAddress: ""
+  };
+}
+
+export const QuerySigningInfoRequest = {
+  encode(message: QuerySigningInfoRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.consAddress !== "") {
+      writer.uint32(10).string(message.consAddress);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySigningInfoRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySigningInfoRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.consAddress = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QuerySigningInfoRequest>): QuerySigningInfoRequest {
+    const message = createBaseQuerySigningInfoRequest();
+    message.consAddress = object.consAddress ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQuerySigningInfoResponse(): QuerySigningInfoResponse {
+  return {
+    valSigningInfo: undefined
+  };
+}
+
+export const QuerySigningInfoResponse = {
+  encode(message: QuerySigningInfoResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.valSigningInfo !== undefined) {
+      ValidatorSigningInfo.encode(message.valSigningInfo, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySigningInfoResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySigningInfoResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.valSigningInfo = ValidatorSigningInfo.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QuerySigningInfoResponse>): QuerySigningInfoResponse {
+    const message = createBaseQuerySigningInfoResponse();
+    message.valSigningInfo = object.valSigningInfo !== undefined && object.valSigningInfo !== null ? ValidatorSigningInfo.fromPartial(object.valSigningInfo) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQuerySigningInfosRequest(): QuerySigningInfosRequest {
+  return {
+    pagination: undefined
+  };
+}
+
+export const QuerySigningInfosRequest = {
+  encode(message: QuerySigningInfosRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySigningInfosRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySigningInfosRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QuerySigningInfosRequest>): QuerySigningInfosRequest {
+    const message = createBaseQuerySigningInfosRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQuerySigningInfosResponse(): QuerySigningInfosResponse {
+  return {
+    info: [],
+    pagination: undefined
+  };
+}
+
+export const QuerySigningInfosResponse = {
+  encode(message: QuerySigningInfosResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.info) {
+      ValidatorSigningInfo.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QuerySigningInfosResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQuerySigningInfosResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.info.push(ValidatorSigningInfo.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QuerySigningInfosResponse>): QuerySigningInfosResponse {
+    const message = createBaseQuerySigningInfosResponse();
+    message.info = object.info?.map(e => ValidatorSigningInfo.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/cosmos/slashing/v1beta1/slashing.ts

@@ -0,0 +1,249 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { Duration, DurationSDKType } from "../../../google/protobuf/duration";
+import { Long, toTimestamp, fromTimestamp, DeepPartial } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * ValidatorSigningInfo defines a validator's signing info for monitoring their
+ * liveness activity.
+ */
+
+export interface ValidatorSigningInfo {
+  address: string;
+  /** Height at which validator was first a candidate OR was un-jailed */
+
+  startHeight: Long;
+  /**
+   * Index which is incremented every time a validator is bonded in a block and
+   * _may_ have signed a pre-commit or not. This in conjunction with the
+   * signed_blocks_window param determines the index in the missed block bitmap.
+   */
+
+  indexOffset: Long;
+  /** Timestamp until which the validator is jailed due to liveness downtime. */
+
+  jailedUntil?: Date;
+  /**
+   * Whether or not a validator has been tombstoned (killed out of validator
+   * set). It is set once the validator commits an equivocation or for any other
+   * configured misbehavior.
+   */
+
+  tombstoned: boolean;
+  /**
+   * A counter of missed (unsigned) blocks. It is used to avoid unnecessary
+   * reads in the missed block bitmap.
+   */
+
+  missedBlocksCounter: Long;
+}
+/**
+ * ValidatorSigningInfo defines a validator's signing info for monitoring their
+ * liveness activity.
+ */
+
+export interface ValidatorSigningInfoSDKType {
+  address: string;
+  start_height: Long;
+  index_offset: Long;
+  jailed_until?: Date;
+  tombstoned: boolean;
+  missed_blocks_counter: Long;
+}
+/** Params represents the parameters used for by the slashing module. */
+
+export interface Params {
+  signedBlocksWindow: Long;
+  minSignedPerWindow: Uint8Array;
+  downtimeJailDuration?: Duration;
+  slashFractionDoubleSign: Uint8Array;
+  slashFractionDowntime: Uint8Array;
+}
+/** Params represents the parameters used for by the slashing module. */
+
+export interface ParamsSDKType {
+  signed_blocks_window: Long;
+  min_signed_per_window: Uint8Array;
+  downtime_jail_duration?: DurationSDKType;
+  slash_fraction_double_sign: Uint8Array;
+  slash_fraction_downtime: Uint8Array;
+}
+
+function createBaseValidatorSigningInfo(): ValidatorSigningInfo {
+  return {
+    address: "",
+    startHeight: Long.ZERO,
+    indexOffset: Long.ZERO,
+    jailedUntil: undefined,
+    tombstoned: false,
+    missedBlocksCounter: Long.ZERO
+  };
+}
+
+export const ValidatorSigningInfo = {
+  encode(message: ValidatorSigningInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): ValidatorSigningInfo {
+    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() as Long);
+          break;
+
+        case 3:
+          message.indexOffset = (reader.int64() as Long);
+          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() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ValidatorSigningInfo>): ValidatorSigningInfo {
+    const message = createBaseValidatorSigningInfo();
+    message.address = 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 ?? undefined;
+    message.tombstoned = object.tombstoned ?? false;
+    message.missedBlocksCounter = object.missedBlocksCounter !== undefined && object.missedBlocksCounter !== null ? Long.fromValue(object.missedBlocksCounter) : Long.ZERO;
+    return message;
+  }
+
+};
+
+function createBaseParams(): Params {
+  return {
+    signedBlocksWindow: Long.ZERO,
+    minSignedPerWindow: new Uint8Array(),
+    downtimeJailDuration: undefined,
+    slashFractionDoubleSign: new Uint8Array(),
+    slashFractionDowntime: new Uint8Array()
+  };
+}
+
+export const Params = {
+  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    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: _m0.Reader | Uint8Array, length?: number): Params {
+    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() as Long);
+          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;
+  },
+
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.signedBlocksWindow = object.signedBlocksWindow !== undefined && object.signedBlocksWindow !== null ? Long.fromValue(object.signedBlocksWindow) : Long.ZERO;
+    message.minSignedPerWindow = object.minSignedPerWindow ?? new Uint8Array();
+    message.downtimeJailDuration = object.downtimeJailDuration !== undefined && object.downtimeJailDuration !== null ? Duration.fromPartial(object.downtimeJailDuration) : undefined;
+    message.slashFractionDoubleSign = object.slashFractionDoubleSign ?? new Uint8Array();
+    message.slashFractionDowntime = object.slashFractionDowntime ?? new Uint8Array();
+    return message;
+  }
+
+};

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

@@ -0,0 +1,43 @@
+import { Rpc } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgUnjail, MsgUnjailResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+/** Msg defines the slashing Msg service. */
+
+export interface Msg {
+  /**
+   * Unjail defines a method for unjailing a jailed validator, thus returning
+   * them into the bonded validator set, so they can begin receiving provisions
+   * and rewards again.
+   */
+  unjail(request: MsgUnjail): Promise<MsgUnjailResponse>;
+  /**
+   * UpdateParams defines a governance operation for updating the x/slashing module
+   * parameters. The authority defaults to the x/gov module account.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.unjail = this.unjail.bind(this);
+    this.updateParams = this.updateParams.bind(this);
+  }
+
+  unjail(request: MsgUnjail): Promise<MsgUnjailResponse> {
+    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)));
+  }
+
+  updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse> {
+    const data = MsgUpdateParams.encode(request).finish();
+    const promise = this.rpc.request("cosmos.slashing.v1beta1.Msg", "UpdateParams", data);
+    return promise.then(data => MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+}