@xpla/xplajs 1.7.0-beta.0

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

@@ -0,0 +1,357 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { Duration, DurationAmino } from "../../../google/protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp, DeepPartial, bytesFromBase64, base64FromBytes } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * 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: bigint;
+  /**
+   * 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: bigint;
+  /** 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: bigint;
+}
+export interface ValidatorSigningInfoProtoMsg {
+  typeUrl: "/cosmos.slashing.v1beta1.ValidatorSigningInfo";
+  value: Uint8Array;
+}
+/**
+ * ValidatorSigningInfo defines a validator's signing info for monitoring their
+ * liveness activity.
+ */
+export interface ValidatorSigningInfoAmino {
+  address: string;
+  /** Height at which validator was first a candidate OR was un-jailed */
+  start_height: string;
+  /**
+   * 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.
+   */
+  index_offset: string;
+  /** Timestamp until which the validator is jailed due to liveness downtime. */
+  jailed_until: string;
+  /**
+   * 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.
+   */
+  missed_blocks_counter: string;
+}
+export interface ValidatorSigningInfoAminoMsg {
+  type: "cosmos-sdk/ValidatorSigningInfo";
+  value: ValidatorSigningInfoAmino;
+}
+/** Params represents the parameters used for by the slashing module. */
+export interface Params {
+  signedBlocksWindow: bigint;
+  minSignedPerWindow: Uint8Array;
+  downtimeJailDuration: Duration;
+  slashFractionDoubleSign: Uint8Array;
+  slashFractionDowntime: Uint8Array;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/cosmos.slashing.v1beta1.Params";
+  value: Uint8Array;
+}
+/** Params represents the parameters used for by the slashing module. */
+export interface ParamsAmino {
+  signed_blocks_window: string;
+  min_signed_per_window: string;
+  downtime_jail_duration: DurationAmino;
+  slash_fraction_double_sign: string;
+  slash_fraction_downtime: string;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/x/slashing/Params";
+  value: ParamsAmino;
+}
+function createBaseValidatorSigningInfo(): ValidatorSigningInfo {
+  return {
+    address: "",
+    startHeight: BigInt(0),
+    indexOffset: BigInt(0),
+    jailedUntil: new Date(),
+    tombstoned: false,
+    missedBlocksCounter: BigInt(0)
+  };
+}
+export const ValidatorSigningInfo = {
+  typeUrl: "/cosmos.slashing.v1beta1.ValidatorSigningInfo",
+  aminoType: "cosmos-sdk/ValidatorSigningInfo",
+  is(o: any): o is ValidatorSigningInfo {
+    return o && (o.$typeUrl === ValidatorSigningInfo.typeUrl || typeof o.address === "string" && typeof o.startHeight === "bigint" && typeof o.indexOffset === "bigint" && Timestamp.is(o.jailedUntil) && typeof o.tombstoned === "boolean" && typeof o.missedBlocksCounter === "bigint");
+  },
+  isAmino(o: any): o is ValidatorSigningInfoAmino {
+    return o && (o.$typeUrl === ValidatorSigningInfo.typeUrl || typeof o.address === "string" && typeof o.start_height === "bigint" && typeof o.index_offset === "bigint" && Timestamp.isAmino(o.jailed_until) && typeof o.tombstoned === "boolean" && typeof o.missed_blocks_counter === "bigint");
+  },
+  encode(message: ValidatorSigningInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.startHeight !== BigInt(0)) {
+      writer.uint32(16).int64(message.startHeight);
+    }
+    if (message.indexOffset !== BigInt(0)) {
+      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 !== BigInt(0)) {
+      writer.uint32(48).int64(message.missedBlocksCounter);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ValidatorSigningInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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;
+  },
+  fromPartial(object: DeepPartial<ValidatorSigningInfo>): ValidatorSigningInfo {
+    const message = createBaseValidatorSigningInfo();
+    message.address = object.address ?? "";
+    message.startHeight = object.startHeight !== undefined && object.startHeight !== null ? BigInt(object.startHeight.toString()) : BigInt(0);
+    message.indexOffset = object.indexOffset !== undefined && object.indexOffset !== null ? BigInt(object.indexOffset.toString()) : BigInt(0);
+    message.jailedUntil = object.jailedUntil ?? undefined;
+    message.tombstoned = object.tombstoned ?? false;
+    message.missedBlocksCounter = object.missedBlocksCounter !== undefined && object.missedBlocksCounter !== null ? BigInt(object.missedBlocksCounter.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: ValidatorSigningInfoAmino): ValidatorSigningInfo {
+    const message = createBaseValidatorSigningInfo();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.start_height !== undefined && object.start_height !== null) {
+      message.startHeight = BigInt(object.start_height);
+    }
+    if (object.index_offset !== undefined && object.index_offset !== null) {
+      message.indexOffset = BigInt(object.index_offset);
+    }
+    if (object.jailed_until !== undefined && object.jailed_until !== null) {
+      message.jailedUntil = fromTimestamp(Timestamp.fromAmino(object.jailed_until));
+    }
+    if (object.tombstoned !== undefined && object.tombstoned !== null) {
+      message.tombstoned = object.tombstoned;
+    }
+    if (object.missed_blocks_counter !== undefined && object.missed_blocks_counter !== null) {
+      message.missedBlocksCounter = BigInt(object.missed_blocks_counter);
+    }
+    return message;
+  },
+  toAmino(message: ValidatorSigningInfo): ValidatorSigningInfoAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    obj.start_height = message.startHeight !== BigInt(0) ? message.startHeight?.toString() : undefined;
+    obj.index_offset = message.indexOffset !== BigInt(0) ? message.indexOffset?.toString() : undefined;
+    obj.jailed_until = message.jailedUntil ? Timestamp.toAmino(toTimestamp(message.jailedUntil)) : new Date();
+    obj.tombstoned = message.tombstoned === false ? undefined : message.tombstoned;
+    obj.missed_blocks_counter = message.missedBlocksCounter !== BigInt(0) ? message.missedBlocksCounter?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: ValidatorSigningInfoAminoMsg): ValidatorSigningInfo {
+    return ValidatorSigningInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message: ValidatorSigningInfo): ValidatorSigningInfoAminoMsg {
+    return {
+      type: "cosmos-sdk/ValidatorSigningInfo",
+      value: ValidatorSigningInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ValidatorSigningInfoProtoMsg): ValidatorSigningInfo {
+    return ValidatorSigningInfo.decode(message.value);
+  },
+  toProto(message: ValidatorSigningInfo): Uint8Array {
+    return ValidatorSigningInfo.encode(message).finish();
+  },
+  toProtoMsg(message: ValidatorSigningInfo): ValidatorSigningInfoProtoMsg {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.ValidatorSigningInfo",
+      value: ValidatorSigningInfo.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ValidatorSigningInfo.typeUrl, ValidatorSigningInfo);
+GlobalDecoderRegistry.registerAminoProtoMapping(ValidatorSigningInfo.aminoType, ValidatorSigningInfo.typeUrl);
+function createBaseParams(): Params {
+  return {
+    signedBlocksWindow: BigInt(0),
+    minSignedPerWindow: new Uint8Array(),
+    downtimeJailDuration: Duration.fromPartial({}),
+    slashFractionDoubleSign: new Uint8Array(),
+    slashFractionDowntime: new Uint8Array()
+  };
+}
+export const Params = {
+  typeUrl: "/cosmos.slashing.v1beta1.Params",
+  aminoType: "cosmos-sdk/x/slashing/Params",
+  is(o: any): o is Params {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.signedBlocksWindow === "bigint" && (o.minSignedPerWindow instanceof Uint8Array || typeof o.minSignedPerWindow === "string") && Duration.is(o.downtimeJailDuration) && (o.slashFractionDoubleSign instanceof Uint8Array || typeof o.slashFractionDoubleSign === "string") && (o.slashFractionDowntime instanceof Uint8Array || typeof o.slashFractionDowntime === "string"));
+  },
+  isAmino(o: any): o is ParamsAmino {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.signed_blocks_window === "bigint" && (o.min_signed_per_window instanceof Uint8Array || typeof o.min_signed_per_window === "string") && Duration.isAmino(o.downtime_jail_duration) && (o.slash_fraction_double_sign instanceof Uint8Array || typeof o.slash_fraction_double_sign === "string") && (o.slash_fraction_downtime instanceof Uint8Array || typeof o.slash_fraction_downtime === "string"));
+  },
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.signedBlocksWindow !== BigInt(0)) {
+      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: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(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;
+  },
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.signedBlocksWindow = object.signedBlocksWindow !== undefined && object.signedBlocksWindow !== null ? BigInt(object.signedBlocksWindow.toString()) : BigInt(0);
+    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;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (object.signed_blocks_window !== undefined && object.signed_blocks_window !== null) {
+      message.signedBlocksWindow = BigInt(object.signed_blocks_window);
+    }
+    if (object.min_signed_per_window !== undefined && object.min_signed_per_window !== null) {
+      message.minSignedPerWindow = bytesFromBase64(object.min_signed_per_window);
+    }
+    if (object.downtime_jail_duration !== undefined && object.downtime_jail_duration !== null) {
+      message.downtimeJailDuration = Duration.fromAmino(object.downtime_jail_duration);
+    }
+    if (object.slash_fraction_double_sign !== undefined && object.slash_fraction_double_sign !== null) {
+      message.slashFractionDoubleSign = bytesFromBase64(object.slash_fraction_double_sign);
+    }
+    if (object.slash_fraction_downtime !== undefined && object.slash_fraction_downtime !== null) {
+      message.slashFractionDowntime = bytesFromBase64(object.slash_fraction_downtime);
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.signed_blocks_window = message.signedBlocksWindow !== BigInt(0) ? message.signedBlocksWindow?.toString() : undefined;
+    obj.min_signed_per_window = message.minSignedPerWindow ? base64FromBytes(message.minSignedPerWindow) : "";
+    obj.downtime_jail_duration = message.downtimeJailDuration ? Duration.toAmino(message.downtimeJailDuration) : Duration.toAmino(Duration.fromPartial({}));
+    obj.slash_fraction_double_sign = message.slashFractionDoubleSign ? base64FromBytes(message.slashFractionDoubleSign) : "";
+    obj.slash_fraction_downtime = message.slashFractionDowntime ? base64FromBytes(message.slashFractionDowntime) : "";
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "cosmos-sdk/x/slashing/Params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/cosmos.slashing.v1beta1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Params.typeUrl, Params);
+GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

package/src/cosmos/slashing/v1beta1/tx.amino.ts

@@ -0,0 +1,13 @@
+import { MsgUnjail, MsgUpdateParams } from "./tx";
+export const AminoConverter = {
+  "/cosmos.slashing.v1beta1.MsgUnjail": {
+    aminoType: "cosmos-sdk/MsgUnjail",
+    toAmino: MsgUnjail.toAmino,
+    fromAmino: MsgUnjail.fromAmino
+  },
+  "/cosmos.slashing.v1beta1.MsgUpdateParams": {
+    aminoType: "cosmos-sdk/x/slashing/MsgUpdateParams",
+    toAmino: MsgUpdateParams.toAmino,
+    fromAmino: MsgUpdateParams.fromAmino
+  }
+};

package/src/cosmos/slashing/v1beta1/tx.registry.ts

@@ -0,0 +1,3 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgUnjail, MsgUpdateParams } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/cosmos.slashing.v1beta1.MsgUnjail", MsgUnjail], ["/cosmos.slashing.v1beta1.MsgUpdateParams", MsgUpdateParams]];

package/src/cosmos/slashing/v1beta1/tx.rpc.func.ts

@@ -0,0 +1,15 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgUnjail, MsgUpdateParams } from "./tx";
+export const createUnjail = (clientResolver?: SigningClientResolver) => buildTx<MsgUnjail>({
+  clientResolver,
+  typeUrl: MsgUnjail.typeUrl,
+  encoders: toEncoders(MsgUnjail),
+  converters: toConverters(MsgUnjail)
+});
+export const createUpdateParams = (clientResolver?: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
+  typeUrl: MsgUpdateParams.typeUrl,
+  encoders: toEncoders(MsgUpdateParams),
+  converters: toConverters(MsgUpdateParams)
+});

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

@@ -0,0 +1,45 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+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: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* 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 = async (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 BinaryReader(data)));
+  };
+  /* 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 = async (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 BinaryReader(data)));
+  };
+}
+export const createClientImpl = (rpc: TxRpc) => {
+  return new MsgClientImpl(rpc);
+};