Variable epochConst

Type declaration

• Epoch: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): Epoch;
      encode(message: Epoch, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: EpochAmino): Epoch;
      fromAminoMsg(object: EpochAminoMsg): Epoch;
      fromPartial(object: {
          currentEpoch?: bigint;
          currentEpochHeight?: bigint;
          currentEpochStartTime?: Date;
          epochDuration?: {
              nanos?: number;
              seconds?: bigint;
          };
          genesisTime?: Date;
      }): Epoch;
      fromProtoMsg(message: EpochProtoMsg): Epoch;
      toAmino(message: Epoch): EpochAmino;
      toProto(message: Epoch): Uint8Array;
      toProtoMsg(message: Epoch): EpochProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): Epoch

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns Epoch

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: Epoch
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): Epoch

    • Parameters

      • object: EpochAmino

      Returns Epoch

  • fromAminoMsg:function

    • fromAminoMsg(object): Epoch

    • Parameters

      • object: EpochAminoMsg

      Returns Epoch

  • fromPartial:function

    • fromPartial(object): Epoch

    • Parameters

      • object: {
            currentEpoch?: bigint;
            currentEpochHeight?: bigint;
            currentEpochStartTime?: Date;
            epochDuration?: {
                nanos?: number;
                seconds?: bigint;
            };
            genesisTime?: Date;
        }

        • OptionalcurrentEpoch?: bigint

        • OptionalcurrentEpochHeight?: bigint

        • OptionalcurrentEpochStartTime?: Date

        • OptionalepochDuration?: {
              nanos?: number;
              seconds?: bigint;
          }

          • Optionalnanos?: number

            Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

          • Optionalseconds?: bigint

            Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

        • OptionalgenesisTime?: Date

      Returns Epoch

  • fromProtoMsg:function

    • fromProtoMsg(message): Epoch

    • Parameters

      • message: EpochProtoMsg

      Returns Epoch

  • toAmino:function

    • toAmino(message): EpochAmino

    • Parameters

      • message: Epoch

      Returns EpochAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: Epoch

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): EpochProtoMsg

    • Parameters

      • message: Epoch

      Returns EpochProtoMsg

• GenesisState: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): GenesisState;
      encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: GenesisStateAmino): GenesisState;
      fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
      fromPartial(object: {
          epoch?: {
              currentEpoch?: bigint;
              currentEpochHeight?: bigint;
              currentEpochStartTime?: Date;
              epochDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              };
              genesisTime?: Date;
          };
          params?: {};
      }): GenesisState;
      fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
      toAmino(message: GenesisState): GenesisStateAmino;
      toProto(message: GenesisState): Uint8Array;
      toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): GenesisState

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns GenesisState

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: GenesisState
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): GenesisState

    • Parameters

      • object: GenesisStateAmino

      Returns GenesisState

  • fromAminoMsg:function

    • fromAminoMsg(object): GenesisState

    • Parameters

      • object: GenesisStateAminoMsg

      Returns GenesisState

  • fromPartial:function

    • fromPartial(object): GenesisState

    • Parameters

      • object: {
            epoch?: {
                currentEpoch?: bigint;
                currentEpochHeight?: bigint;
                currentEpochStartTime?: Date;
                epochDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                genesisTime?: Date;
            };
            params?: {};
        }

        • Optionalepoch?: {
              currentEpoch?: bigint;
              currentEpochHeight?: bigint;
              currentEpochStartTime?: Date;
              epochDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              };
              genesisTime?: Date;
          }

          • OptionalcurrentEpoch?: bigint

          • OptionalcurrentEpochHeight?: bigint

          • OptionalcurrentEpochStartTime?: Date

          • OptionalepochDuration?: {
                nanos?: number;
                seconds?: bigint;
            }

            • Optionalnanos?: number

              Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

            • Optionalseconds?: bigint

              Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

          • OptionalgenesisTime?: Date

        • Optionalparams?: {}

      Returns GenesisState

  • fromProtoMsg:function

    • fromProtoMsg(message): GenesisState

    • Parameters

      • message: GenesisStateProtoMsg

      Returns GenesisState

  • toAmino:function

    • toAmino(message): GenesisStateAmino

    • Parameters

      • message: GenesisState

      Returns GenesisStateAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: GenesisState

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): GenesisStateProtoMsg

    • Parameters

      • message: GenesisState

      Returns GenesisStateProtoMsg

• Params: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): Params;
      encode(_: Params, writer?: BinaryWriter): BinaryWriter;
      fromAmino(_: ParamsAmino): Params;
      fromAminoMsg(object: ParamsAminoMsg): Params;
      fromPartial(_: {}): Params;
      fromProtoMsg(message: ParamsProtoMsg): Params;
      toAmino(_: Params): ParamsAmino;
      toProto(message: Params): Uint8Array;
      toProtoMsg(message: Params): ParamsProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): Params

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns Params

  • encode:function

    • encode(_, writer?): BinaryWriter

    • Parameters

      • _: Params
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(_): Params

    • Parameters

      • _: ParamsAmino

      Returns Params

  • fromAminoMsg:function

    • fromAminoMsg(object): Params

    • Parameters

      • object: ParamsAminoMsg

      Returns Params

  • fromPartial:function

    • fromPartial(_): Params

    • Parameters

      • _: {}

      Returns Params

  • fromProtoMsg:function

    • fromProtoMsg(message): Params

    • Parameters

      • message: ParamsProtoMsg

      Returns Params

  • toAmino:function

    • toAmino(_): ParamsAmino

    • Parameters

      • _: Params

      Returns ParamsAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: Params

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ParamsProtoMsg

    • Parameters

      • message: Params

      Returns ParamsProtoMsg

• QueryEpochRequest: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryEpochRequest;
      encode(_: QueryEpochRequest, writer?: BinaryWriter): BinaryWriter;
      fromAmino(_: QueryEpochRequestAmino): QueryEpochRequest;
      fromAminoMsg(object: QueryEpochRequestAminoMsg): QueryEpochRequest;
      fromPartial(_: {}): QueryEpochRequest;
      fromProtoMsg(message: QueryEpochRequestProtoMsg): QueryEpochRequest;
      toAmino(_: QueryEpochRequest): QueryEpochRequestAmino;
      toProto(message: QueryEpochRequest): Uint8Array;
      toProtoMsg(message: QueryEpochRequest): QueryEpochRequestProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryEpochRequest

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryEpochRequest

  • encode:function

    • encode(_, writer?): BinaryWriter

    • Parameters

      • _: QueryEpochRequest
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(_): QueryEpochRequest

    • Parameters

      • _: QueryEpochRequestAmino

      Returns QueryEpochRequest

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryEpochRequest

    • Parameters

      • object: QueryEpochRequestAminoMsg

      Returns QueryEpochRequest

  • fromPartial:function

    • fromPartial(_): QueryEpochRequest

    • Parameters

      • _: {}

      Returns QueryEpochRequest

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryEpochRequest

    • Parameters

      • message: QueryEpochRequestProtoMsg

      Returns QueryEpochRequest

  • toAmino:function

    • toAmino(_): QueryEpochRequestAmino

    • Parameters

      • _: QueryEpochRequest

      Returns QueryEpochRequestAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryEpochRequest

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryEpochRequestProtoMsg

    • Parameters

      • message: QueryEpochRequest

      Returns QueryEpochRequestProtoMsg

• QueryEpochResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryEpochResponse;
      encode(message: QueryEpochResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryEpochResponseAmino): QueryEpochResponse;
      fromAminoMsg(object: QueryEpochResponseAminoMsg): QueryEpochResponse;
      fromPartial(object: {
          epoch?: {
              currentEpoch?: bigint;
              currentEpochHeight?: bigint;
              currentEpochStartTime?: Date;
              epochDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              };
              genesisTime?: Date;
          };
      }): QueryEpochResponse;
      fromProtoMsg(message: QueryEpochResponseProtoMsg): QueryEpochResponse;
      toAmino(message: QueryEpochResponse): QueryEpochResponseAmino;
      toProto(message: QueryEpochResponse): Uint8Array;
      toProtoMsg(message: QueryEpochResponse): QueryEpochResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryEpochResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryEpochResponse

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryEpochResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryEpochResponse

    • Parameters

      • object: QueryEpochResponseAmino

      Returns QueryEpochResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryEpochResponse

    • Parameters

      • object: QueryEpochResponseAminoMsg

      Returns QueryEpochResponse

  • fromPartial:function

    • fromPartial(object): QueryEpochResponse

    • Parameters

      • object: {
            epoch?: {
                currentEpoch?: bigint;
                currentEpochHeight?: bigint;
                currentEpochStartTime?: Date;
                epochDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                genesisTime?: Date;
            };
        }

        • Optionalepoch?: {
              currentEpoch?: bigint;
              currentEpochHeight?: bigint;
              currentEpochStartTime?: Date;
              epochDuration?: {
                  nanos?: number;
                  seconds?: bigint;
              };
              genesisTime?: Date;
          }

          • OptionalcurrentEpoch?: bigint

          • OptionalcurrentEpochHeight?: bigint

          • OptionalcurrentEpochStartTime?: Date

          • OptionalepochDuration?: {
                nanos?: number;
                seconds?: bigint;
            }

            • Optionalnanos?: number

              Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

            • Optionalseconds?: bigint

              Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

          • OptionalgenesisTime?: Date

      Returns QueryEpochResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryEpochResponse

    • Parameters

      • message: QueryEpochResponseProtoMsg

      Returns QueryEpochResponse

  • toAmino:function

    • toAmino(message): QueryEpochResponseAmino

    • Parameters

      • message: QueryEpochResponse

      Returns QueryEpochResponseAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryEpochResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryEpochResponseProtoMsg

    • Parameters

      • message: QueryEpochResponse

      Returns QueryEpochResponseProtoMsg

• QueryParamsRequest: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsRequest;
      encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
      fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
      fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
      fromPartial(_: {}): QueryParamsRequest;
      fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
      toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
      toProto(message: QueryParamsRequest): Uint8Array;
      toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryParamsRequest

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryParamsRequest

  • encode:function

    • encode(_, writer?): BinaryWriter

    • Parameters

      • _: QueryParamsRequest
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(_): QueryParamsRequest

    • Parameters

      • _: QueryParamsRequestAmino

      Returns QueryParamsRequest

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryParamsRequest

    • Parameters

      • object: QueryParamsRequestAminoMsg

      Returns QueryParamsRequest

  • fromPartial:function

    • fromPartial(_): QueryParamsRequest

    • Parameters

      • _: {}

      Returns QueryParamsRequest

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryParamsRequest

    • Parameters

      • message: QueryParamsRequestProtoMsg

      Returns QueryParamsRequest

  • toAmino:function

    • toAmino(_): QueryParamsRequestAmino

    • Parameters

      • _: QueryParamsRequest

      Returns QueryParamsRequestAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryParamsRequest

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryParamsRequestProtoMsg

    • Parameters

      • message: QueryParamsRequest

      Returns QueryParamsRequestProtoMsg

• QueryParamsResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsResponse;
      encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
      fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
      fromPartial(object: {
          params?: {};
      }): QueryParamsResponse;
      fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
      toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
      toProto(message: QueryParamsResponse): Uint8Array;
      toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryParamsResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryParamsResponse

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryParamsResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryParamsResponse

    • Parameters

      • object: QueryParamsResponseAmino

      Returns QueryParamsResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryParamsResponse

    • Parameters

      • object: QueryParamsResponseAminoMsg

      Returns QueryParamsResponse

  • fromPartial:function

    • fromPartial(object): QueryParamsResponse

    • Parameters

      • object: {
            params?: {};
        }

        • Optionalparams?: {}

          params holds all the parameters of this module.

      Returns QueryParamsResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryParamsResponse

    • Parameters

      • message: QueryParamsResponseProtoMsg

      Returns QueryParamsResponse

  • toAmino:function

    • toAmino(message): QueryParamsResponseAmino

    • Parameters

      • message: QueryParamsResponse

      Returns QueryParamsResponseAmino

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryParamsResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryParamsResponseProtoMsg

    • Parameters

      • message: QueryParamsResponse

      Returns QueryParamsResponseProtoMsg

• createRpcQueryExtension: ((base: QueryClient) => {
      epoch(request?: QueryEpochRequest): Promise<QueryEpochResponse>;
      params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
  })

  • • (base): {
          epoch(request?: QueryEpochRequest): Promise<QueryEpochResponse>;
          params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
      }

    • Parameters

      • base: QueryClient

      Returns {
          epoch(request?: QueryEpochRequest): Promise<QueryEpochResponse>;
          params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
      }

      • epoch:function

        • epoch(request?): Promise<QueryEpochResponse>

        • Parameters

          • Optionalrequest: QueryEpochRequest

          Returns Promise<QueryEpochResponse>

      • params:function

        • params(request?): Promise<QueryParamsResponse>

        • Parameters

          • Optionalrequest: QueryParamsRequest

          Returns Promise<QueryParamsResponse>