// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.11.4
//   protoc               unknown
// source: cheqd/oracle/v2/query.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { DecCoin } from "../../../cosmos/base/v1beta1/coin.js";
import {
  AggregateExchangeRatePrevote,
  AggregateExchangeRateVote,
  Params,
  PriceStamp,
  ValidatorRewardSet,
} from "./oracle.js";

/**
 * QueryExchangeRates is the request type for the Query/ExchangeRate RPC
 * method.
 */
export interface QueryExchangeRates {
  /** denom defines the denomination to query for. */
  denom: string;
}

/**
 * QueryExchangeRatesResponse is response type for the
 * Query/ExchangeRates RPC method.
 */
export interface QueryExchangeRatesResponse {
  /**
   * exchange_rates defines a list of the exchange rate for all whitelisted
   * denoms.
   */
  exchangeRates: DecCoin[];
}

/**
 * QueryActiveExchangeRates is the request type for the
 * Query/ActiveExchangeRates RPC method.
 */
export interface QueryActiveExchangeRates {
}

/**
 * QueryActiveExchangeRatesResponse is response type for the
 * Query/ActiveExchangeRates RPC method.
 */
export interface QueryActiveExchangeRatesResponse {
  /**
   * activeRates defines a list of the denomination which oracle prices aggreed
   * upon.
   */
  activeRates: string[];
}

/**
 * QueryFeederDelegation is the request type for the
 * Query/FeederDelegation RPC method.
 */
export interface QueryFeederDelegation {
  /** validator defines the validator address to query for. */
  validatorAddr: string;
}

/**
 * QueryFeederDelegationResponse is response type for the
 * Query/FeederDelegation RPC method.
 */
export interface QueryFeederDelegationResponse {
  /** feeder_addr defines the feeder delegation of a validator */
  feederAddr: string;
}

/**
 * QueryMissCounter is the request type for the Query/MissCounter RPC
 * method.
 */
export interface QueryMissCounter {
  /** validator defines the validator address to query for. */
  validatorAddr: string;
}

/**
 * QueryMissCounterResponse is response type for the
 * Query/MissCounter RPC method.
 */
export interface QueryMissCounterResponse {
  /** miss_counter defines the oracle miss counter of a validator */
  missCounter: bigint;
}

/**
 * QuerySlashWindow is the request type for the
 * Query/SlashWindow RPC method.
 */
export interface QuerySlashWindow {
}

/**
 * QuerySlashWindowResponse is response type for the
 * Query/SlashWindow RPC method.
 */
export interface QuerySlashWindowResponse {
  /**
   * window_progress defines the number of voting periods
   * since the last slashing event would have taken place.
   */
  windowProgress: bigint;
}

/**
 * QueryAggregatePrevote is the request type for the
 * Query/AggregatePrevote RPC method.
 */
export interface QueryAggregatePrevote {
  /** validator defines the validator address to query for. */
  validatorAddr: string;
}

/**
 * QueryAggregatePrevoteResponse is response type for the
 * Query/AggregatePrevote RPC method.
 */
export interface QueryAggregatePrevoteResponse {
  /**
   * aggregate_prevote defines oracle aggregate prevote submitted by a validator
   * in the current vote period
   */
  aggregatePrevote: AggregateExchangeRatePrevote | undefined;
}

/**
 * QueryAggregatePrevotes is the request type for the
 * Query/AggregatePrevotes RPC method.
 */
export interface QueryAggregatePrevotes {
}

/**
 * QueryAggregatePrevotesResponse is response type for the
 * Query/AggregatePrevotes RPC method.
 */
export interface QueryAggregatePrevotesResponse {
  /**
   * aggregate_prevotes defines all oracle aggregate prevotes submitted in the
   * current vote period
   */
  aggregatePrevotes: AggregateExchangeRatePrevote[];
}

/**
 * QueryAggregateVote is the request type for the Query/AggregateVote RPC
 * method.
 */
export interface QueryAggregateVote {
  /** validator defines the validator address to query for. */
  validatorAddr: string;
}

/**
 * QueryAggregateVoteResponse is response type for the
 * Query/AggregateVote RPC method.
 */
export interface QueryAggregateVoteResponse {
  /**
   * aggregate_vote defines oracle aggregate vote submitted by a validator in
   * the current vote period
   */
  aggregateVote: AggregateExchangeRateVote | undefined;
}

/**
 * QueryAggregateVotes is the request type for the Query/AggregateVotes
 * RPC method.
 */
export interface QueryAggregateVotes {
}

/**
 * QueryAggregateVotesResponse is response type for the
 * Query/AggregateVotes RPC method.
 */
export interface QueryAggregateVotesResponse {
  /**
   * aggregate_votes defines all oracle aggregate votes submitted in the current
   * vote period
   */
  aggregateVotes: AggregateExchangeRateVote[];
}

/** QueryParams is the request type for the Query/Params RPC method. */
export interface QueryParams {
}

/** QueryParamsResponse is the response type for the Query/Params RPC method. */
export interface QueryParamsResponse {
  /** params defines the parameters of the module. */
  params: Params | undefined;
}

/** QueryMedians is the request type for the Query/Medians RPC Response. */
export interface QueryMedians {
  /** denom defines the denomination to query for. */
  denom: string;
  /**
   * numStamps defines the number of median stamps to query for. numStamps
   * must be greater than 0.
   */
  numStamps: number;
}

/**
 * QueryMediansResponse is response type for the
 * Query/Medians RPC method.
 */
export interface QueryMediansResponse {
  /** medians defines a list of the medians for all stamped denoms. */
  medians: PriceStamp[];
}

/**
 * QueryMedianDeviations is the request type for the Query/MedianDeviations RPC
 * Response.
 */
export interface QueryMedianDeviations {
  /** denom defines the denomination to query for. */
  denom: string;
}

/**
 * QueryMedianDeviationsResponse is response type for the
 * Query/MedianDeviations RPC method.
 */
export interface QueryMedianDeviationsResponse {
  /** medians defines a list of the median deviations for all stamped denoms. */
  medianDeviations: PriceStamp[];
}

/** QueryValidatorRewardSet is the request type for the Query/ValidatorRewardSet RPC method. */
export interface QueryValidatorRewardSet {
}

/** QueryValidatorRewardSetResponse is the response type for the Query/ValidatorRewardSet RPC method. */
export interface QueryValidatorRewardSetResponse {
  validators: ValidatorRewardSet | undefined;
}

export interface QueryEMARequest {
  denom: string;
}

export interface QueryEMAResponse {
  price: string;
}

export interface QueryWMARequest {
  denom: string;
  /** "BALANCED", "RECENT", etc. */
  strategy: string;
  /** Only used if strategy == "CUSTOM" */
  customWeights: bigint[];
}

export interface QueryWMAResponse {
  price: string;
}

export interface QuerySMARequest {
  denom: string;
}

export interface QuerySMAResponse {
  price: string;
}

export interface ConvertUSDCtoCHEQRequest {
  /** e.g., "1000000usdc" */
  amount: string;
  /** "sma", "ema", or "wma" */
  maType: string;
  /** "daily", "hourly", "custom" (optional unless wma is chosen) */
  wmaStrategy: string;
  /** only used if strategy == custom */
  customWeights: number[];
}

export interface ConvertUSDCtoCHEQResponse {
  /** e.g., "25000000ncheq" */
  amount: string;
}

function createBaseQueryExchangeRates(): QueryExchangeRates {
  return { denom: "" };
}

export const QueryExchangeRates: MessageFns<QueryExchangeRates> = {
  encode(message: QueryExchangeRates, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryExchangeRates {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryExchangeRates();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryExchangeRates {
    return { denom: isSet(object.denom) ? globalThis.String(object.denom) : "" };
  },

  toJSON(message: QueryExchangeRates): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryExchangeRates>, I>>(base?: I): QueryExchangeRates {
    return QueryExchangeRates.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryExchangeRates>, I>>(object: I): QueryExchangeRates {
    const message = createBaseQueryExchangeRates();
    message.denom = object.denom ?? "";
    return message;
  },
};

function createBaseQueryExchangeRatesResponse(): QueryExchangeRatesResponse {
  return { exchangeRates: [] };
}

export const QueryExchangeRatesResponse: MessageFns<QueryExchangeRatesResponse> = {
  encode(message: QueryExchangeRatesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.exchangeRates) {
      DecCoin.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryExchangeRatesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryExchangeRatesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.exchangeRates.push(DecCoin.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryExchangeRatesResponse {
    return {
      exchangeRates: globalThis.Array.isArray(object?.exchangeRates)
        ? object.exchangeRates.map((e: any) => DecCoin.fromJSON(e))
        : globalThis.Array.isArray(object?.exchange_rates)
        ? object.exchange_rates.map((e: any) => DecCoin.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryExchangeRatesResponse): unknown {
    const obj: any = {};
    if (message.exchangeRates?.length) {
      obj.exchangeRates = message.exchangeRates.map((e) => DecCoin.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryExchangeRatesResponse>, I>>(base?: I): QueryExchangeRatesResponse {
    return QueryExchangeRatesResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryExchangeRatesResponse>, I>>(object: I): QueryExchangeRatesResponse {
    const message = createBaseQueryExchangeRatesResponse();
    message.exchangeRates = object.exchangeRates?.map((e) => DecCoin.fromPartial(e)) || [];
    return message;
  },
};

function createBaseQueryActiveExchangeRates(): QueryActiveExchangeRates {
  return {};
}

export const QueryActiveExchangeRates: MessageFns<QueryActiveExchangeRates> = {
  encode(_: QueryActiveExchangeRates, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryActiveExchangeRates {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryActiveExchangeRates();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryActiveExchangeRates {
    return {};
  },

  toJSON(_: QueryActiveExchangeRates): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryActiveExchangeRates>, I>>(base?: I): QueryActiveExchangeRates {
    return QueryActiveExchangeRates.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryActiveExchangeRates>, I>>(_: I): QueryActiveExchangeRates {
    const message = createBaseQueryActiveExchangeRates();
    return message;
  },
};

function createBaseQueryActiveExchangeRatesResponse(): QueryActiveExchangeRatesResponse {
  return { activeRates: [] };
}

export const QueryActiveExchangeRatesResponse: MessageFns<QueryActiveExchangeRatesResponse> = {
  encode(message: QueryActiveExchangeRatesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.activeRates) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryActiveExchangeRatesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryActiveExchangeRatesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.activeRates.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryActiveExchangeRatesResponse {
    return {
      activeRates: globalThis.Array.isArray(object?.activeRates)
        ? object.activeRates.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.active_rates)
        ? object.active_rates.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: QueryActiveExchangeRatesResponse): unknown {
    const obj: any = {};
    if (message.activeRates?.length) {
      obj.activeRates = message.activeRates;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryActiveExchangeRatesResponse>, I>>(
    base?: I,
  ): QueryActiveExchangeRatesResponse {
    return QueryActiveExchangeRatesResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryActiveExchangeRatesResponse>, I>>(
    object: I,
  ): QueryActiveExchangeRatesResponse {
    const message = createBaseQueryActiveExchangeRatesResponse();
    message.activeRates = object.activeRates?.map((e) => e) || [];
    return message;
  },
};

function createBaseQueryFeederDelegation(): QueryFeederDelegation {
  return { validatorAddr: "" };
}

export const QueryFeederDelegation: MessageFns<QueryFeederDelegation> = {
  encode(message: QueryFeederDelegation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.validatorAddr !== "") {
      writer.uint32(10).string(message.validatorAddr);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryFeederDelegation {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryFeederDelegation();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.validatorAddr = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryFeederDelegation {
    return {
      validatorAddr: isSet(object.validatorAddr)
        ? globalThis.String(object.validatorAddr)
        : isSet(object.validator_addr)
        ? globalThis.String(object.validator_addr)
        : "",
    };
  },

  toJSON(message: QueryFeederDelegation): unknown {
    const obj: any = {};
    if (message.validatorAddr !== "") {
      obj.validatorAddr = message.validatorAddr;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryFeederDelegation>, I>>(base?: I): QueryFeederDelegation {
    return QueryFeederDelegation.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryFeederDelegation>, I>>(object: I): QueryFeederDelegation {
    const message = createBaseQueryFeederDelegation();
    message.validatorAddr = object.validatorAddr ?? "";
    return message;
  },
};

function createBaseQueryFeederDelegationResponse(): QueryFeederDelegationResponse {
  return { feederAddr: "" };
}

export const QueryFeederDelegationResponse: MessageFns<QueryFeederDelegationResponse> = {
  encode(message: QueryFeederDelegationResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.feederAddr !== "") {
      writer.uint32(10).string(message.feederAddr);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryFeederDelegationResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryFeederDelegationResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.feederAddr = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryFeederDelegationResponse {
    return {
      feederAddr: isSet(object.feederAddr)
        ? globalThis.String(object.feederAddr)
        : isSet(object.feeder_addr)
        ? globalThis.String(object.feeder_addr)
        : "",
    };
  },

  toJSON(message: QueryFeederDelegationResponse): unknown {
    const obj: any = {};
    if (message.feederAddr !== "") {
      obj.feederAddr = message.feederAddr;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryFeederDelegationResponse>, I>>(base?: I): QueryFeederDelegationResponse {
    return QueryFeederDelegationResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryFeederDelegationResponse>, I>>(
    object: I,
  ): QueryFeederDelegationResponse {
    const message = createBaseQueryFeederDelegationResponse();
    message.feederAddr = object.feederAddr ?? "";
    return message;
  },
};

function createBaseQueryMissCounter(): QueryMissCounter {
  return { validatorAddr: "" };
}

export const QueryMissCounter: MessageFns<QueryMissCounter> = {
  encode(message: QueryMissCounter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.validatorAddr !== "") {
      writer.uint32(10).string(message.validatorAddr);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMissCounter {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMissCounter();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.validatorAddr = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMissCounter {
    return {
      validatorAddr: isSet(object.validatorAddr)
        ? globalThis.String(object.validatorAddr)
        : isSet(object.validator_addr)
        ? globalThis.String(object.validator_addr)
        : "",
    };
  },

  toJSON(message: QueryMissCounter): unknown {
    const obj: any = {};
    if (message.validatorAddr !== "") {
      obj.validatorAddr = message.validatorAddr;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMissCounter>, I>>(base?: I): QueryMissCounter {
    return QueryMissCounter.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMissCounter>, I>>(object: I): QueryMissCounter {
    const message = createBaseQueryMissCounter();
    message.validatorAddr = object.validatorAddr ?? "";
    return message;
  },
};

function createBaseQueryMissCounterResponse(): QueryMissCounterResponse {
  return { missCounter: 0n };
}

export const QueryMissCounterResponse: MessageFns<QueryMissCounterResponse> = {
  encode(message: QueryMissCounterResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.missCounter !== 0n) {
      if (BigInt.asUintN(64, message.missCounter) !== message.missCounter) {
        throw new globalThis.Error("value provided for field message.missCounter of type uint64 too large");
      }
      writer.uint32(8).uint64(message.missCounter);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMissCounterResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMissCounterResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.missCounter = reader.uint64() as bigint;
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMissCounterResponse {
    return {
      missCounter: isSet(object.missCounter)
        ? BigInt(object.missCounter)
        : isSet(object.miss_counter)
        ? BigInt(object.miss_counter)
        : 0n,
    };
  },

  toJSON(message: QueryMissCounterResponse): unknown {
    const obj: any = {};
    if (message.missCounter !== 0n) {
      obj.missCounter = message.missCounter.toString();
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMissCounterResponse>, I>>(base?: I): QueryMissCounterResponse {
    return QueryMissCounterResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMissCounterResponse>, I>>(object: I): QueryMissCounterResponse {
    const message = createBaseQueryMissCounterResponse();
    message.missCounter = object.missCounter ?? 0n;
    return message;
  },
};

function createBaseQuerySlashWindow(): QuerySlashWindow {
  return {};
}

export const QuerySlashWindow: MessageFns<QuerySlashWindow> = {
  encode(_: QuerySlashWindow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QuerySlashWindow {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQuerySlashWindow();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QuerySlashWindow {
    return {};
  },

  toJSON(_: QuerySlashWindow): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QuerySlashWindow>, I>>(base?: I): QuerySlashWindow {
    return QuerySlashWindow.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QuerySlashWindow>, I>>(_: I): QuerySlashWindow {
    const message = createBaseQuerySlashWindow();
    return message;
  },
};

function createBaseQuerySlashWindowResponse(): QuerySlashWindowResponse {
  return { windowProgress: 0n };
}

export const QuerySlashWindowResponse: MessageFns<QuerySlashWindowResponse> = {
  encode(message: QuerySlashWindowResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.windowProgress !== 0n) {
      if (BigInt.asUintN(64, message.windowProgress) !== message.windowProgress) {
        throw new globalThis.Error("value provided for field message.windowProgress of type uint64 too large");
      }
      writer.uint32(8).uint64(message.windowProgress);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QuerySlashWindowResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQuerySlashWindowResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.windowProgress = reader.uint64() as bigint;
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QuerySlashWindowResponse {
    return {
      windowProgress: isSet(object.windowProgress)
        ? BigInt(object.windowProgress)
        : isSet(object.window_progress)
        ? BigInt(object.window_progress)
        : 0n,
    };
  },

  toJSON(message: QuerySlashWindowResponse): unknown {
    const obj: any = {};
    if (message.windowProgress !== 0n) {
      obj.windowProgress = message.windowProgress.toString();
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QuerySlashWindowResponse>, I>>(base?: I): QuerySlashWindowResponse {
    return QuerySlashWindowResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QuerySlashWindowResponse>, I>>(object: I): QuerySlashWindowResponse {
    const message = createBaseQuerySlashWindowResponse();
    message.windowProgress = object.windowProgress ?? 0n;
    return message;
  },
};

function createBaseQueryAggregatePrevote(): QueryAggregatePrevote {
  return { validatorAddr: "" };
}

export const QueryAggregatePrevote: MessageFns<QueryAggregatePrevote> = {
  encode(message: QueryAggregatePrevote, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.validatorAddr !== "") {
      writer.uint32(10).string(message.validatorAddr);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatePrevote {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregatePrevote();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.validatorAddr = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregatePrevote {
    return {
      validatorAddr: isSet(object.validatorAddr)
        ? globalThis.String(object.validatorAddr)
        : isSet(object.validator_addr)
        ? globalThis.String(object.validator_addr)
        : "",
    };
  },

  toJSON(message: QueryAggregatePrevote): unknown {
    const obj: any = {};
    if (message.validatorAddr !== "") {
      obj.validatorAddr = message.validatorAddr;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregatePrevote>, I>>(base?: I): QueryAggregatePrevote {
    return QueryAggregatePrevote.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregatePrevote>, I>>(object: I): QueryAggregatePrevote {
    const message = createBaseQueryAggregatePrevote();
    message.validatorAddr = object.validatorAddr ?? "";
    return message;
  },
};

function createBaseQueryAggregatePrevoteResponse(): QueryAggregatePrevoteResponse {
  return { aggregatePrevote: undefined };
}

export const QueryAggregatePrevoteResponse: MessageFns<QueryAggregatePrevoteResponse> = {
  encode(message: QueryAggregatePrevoteResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.aggregatePrevote !== undefined) {
      AggregateExchangeRatePrevote.encode(message.aggregatePrevote, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatePrevoteResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregatePrevoteResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.aggregatePrevote = AggregateExchangeRatePrevote.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregatePrevoteResponse {
    return {
      aggregatePrevote: isSet(object.aggregatePrevote)
        ? AggregateExchangeRatePrevote.fromJSON(object.aggregatePrevote)
        : isSet(object.aggregate_prevote)
        ? AggregateExchangeRatePrevote.fromJSON(object.aggregate_prevote)
        : undefined,
    };
  },

  toJSON(message: QueryAggregatePrevoteResponse): unknown {
    const obj: any = {};
    if (message.aggregatePrevote !== undefined) {
      obj.aggregatePrevote = AggregateExchangeRatePrevote.toJSON(message.aggregatePrevote);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregatePrevoteResponse>, I>>(base?: I): QueryAggregatePrevoteResponse {
    return QueryAggregatePrevoteResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregatePrevoteResponse>, I>>(
    object: I,
  ): QueryAggregatePrevoteResponse {
    const message = createBaseQueryAggregatePrevoteResponse();
    message.aggregatePrevote = (object.aggregatePrevote !== undefined && object.aggregatePrevote !== null)
      ? AggregateExchangeRatePrevote.fromPartial(object.aggregatePrevote)
      : undefined;
    return message;
  },
};

function createBaseQueryAggregatePrevotes(): QueryAggregatePrevotes {
  return {};
}

export const QueryAggregatePrevotes: MessageFns<QueryAggregatePrevotes> = {
  encode(_: QueryAggregatePrevotes, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatePrevotes {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregatePrevotes();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryAggregatePrevotes {
    return {};
  },

  toJSON(_: QueryAggregatePrevotes): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregatePrevotes>, I>>(base?: I): QueryAggregatePrevotes {
    return QueryAggregatePrevotes.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregatePrevotes>, I>>(_: I): QueryAggregatePrevotes {
    const message = createBaseQueryAggregatePrevotes();
    return message;
  },
};

function createBaseQueryAggregatePrevotesResponse(): QueryAggregatePrevotesResponse {
  return { aggregatePrevotes: [] };
}

export const QueryAggregatePrevotesResponse: MessageFns<QueryAggregatePrevotesResponse> = {
  encode(message: QueryAggregatePrevotesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.aggregatePrevotes) {
      AggregateExchangeRatePrevote.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregatePrevotesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregatePrevotesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.aggregatePrevotes.push(AggregateExchangeRatePrevote.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregatePrevotesResponse {
    return {
      aggregatePrevotes: globalThis.Array.isArray(object?.aggregatePrevotes)
        ? object.aggregatePrevotes.map((e: any) => AggregateExchangeRatePrevote.fromJSON(e))
        : globalThis.Array.isArray(object?.aggregate_prevotes)
        ? object.aggregate_prevotes.map((e: any) => AggregateExchangeRatePrevote.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryAggregatePrevotesResponse): unknown {
    const obj: any = {};
    if (message.aggregatePrevotes?.length) {
      obj.aggregatePrevotes = message.aggregatePrevotes.map((e) => AggregateExchangeRatePrevote.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregatePrevotesResponse>, I>>(base?: I): QueryAggregatePrevotesResponse {
    return QueryAggregatePrevotesResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregatePrevotesResponse>, I>>(
    object: I,
  ): QueryAggregatePrevotesResponse {
    const message = createBaseQueryAggregatePrevotesResponse();
    message.aggregatePrevotes = object.aggregatePrevotes?.map((e) => AggregateExchangeRatePrevote.fromPartial(e)) || [];
    return message;
  },
};

function createBaseQueryAggregateVote(): QueryAggregateVote {
  return { validatorAddr: "" };
}

export const QueryAggregateVote: MessageFns<QueryAggregateVote> = {
  encode(message: QueryAggregateVote, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.validatorAddr !== "") {
      writer.uint32(10).string(message.validatorAddr);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregateVote {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregateVote();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.validatorAddr = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregateVote {
    return {
      validatorAddr: isSet(object.validatorAddr)
        ? globalThis.String(object.validatorAddr)
        : isSet(object.validator_addr)
        ? globalThis.String(object.validator_addr)
        : "",
    };
  },

  toJSON(message: QueryAggregateVote): unknown {
    const obj: any = {};
    if (message.validatorAddr !== "") {
      obj.validatorAddr = message.validatorAddr;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregateVote>, I>>(base?: I): QueryAggregateVote {
    return QueryAggregateVote.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregateVote>, I>>(object: I): QueryAggregateVote {
    const message = createBaseQueryAggregateVote();
    message.validatorAddr = object.validatorAddr ?? "";
    return message;
  },
};

function createBaseQueryAggregateVoteResponse(): QueryAggregateVoteResponse {
  return { aggregateVote: undefined };
}

export const QueryAggregateVoteResponse: MessageFns<QueryAggregateVoteResponse> = {
  encode(message: QueryAggregateVoteResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.aggregateVote !== undefined) {
      AggregateExchangeRateVote.encode(message.aggregateVote, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregateVoteResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregateVoteResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.aggregateVote = AggregateExchangeRateVote.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregateVoteResponse {
    return {
      aggregateVote: isSet(object.aggregateVote)
        ? AggregateExchangeRateVote.fromJSON(object.aggregateVote)
        : isSet(object.aggregate_vote)
        ? AggregateExchangeRateVote.fromJSON(object.aggregate_vote)
        : undefined,
    };
  },

  toJSON(message: QueryAggregateVoteResponse): unknown {
    const obj: any = {};
    if (message.aggregateVote !== undefined) {
      obj.aggregateVote = AggregateExchangeRateVote.toJSON(message.aggregateVote);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregateVoteResponse>, I>>(base?: I): QueryAggregateVoteResponse {
    return QueryAggregateVoteResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregateVoteResponse>, I>>(object: I): QueryAggregateVoteResponse {
    const message = createBaseQueryAggregateVoteResponse();
    message.aggregateVote = (object.aggregateVote !== undefined && object.aggregateVote !== null)
      ? AggregateExchangeRateVote.fromPartial(object.aggregateVote)
      : undefined;
    return message;
  },
};

function createBaseQueryAggregateVotes(): QueryAggregateVotes {
  return {};
}

export const QueryAggregateVotes: MessageFns<QueryAggregateVotes> = {
  encode(_: QueryAggregateVotes, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregateVotes {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregateVotes();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryAggregateVotes {
    return {};
  },

  toJSON(_: QueryAggregateVotes): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregateVotes>, I>>(base?: I): QueryAggregateVotes {
    return QueryAggregateVotes.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregateVotes>, I>>(_: I): QueryAggregateVotes {
    const message = createBaseQueryAggregateVotes();
    return message;
  },
};

function createBaseQueryAggregateVotesResponse(): QueryAggregateVotesResponse {
  return { aggregateVotes: [] };
}

export const QueryAggregateVotesResponse: MessageFns<QueryAggregateVotesResponse> = {
  encode(message: QueryAggregateVotesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.aggregateVotes) {
      AggregateExchangeRateVote.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAggregateVotesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAggregateVotesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.aggregateVotes.push(AggregateExchangeRateVote.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAggregateVotesResponse {
    return {
      aggregateVotes: globalThis.Array.isArray(object?.aggregateVotes)
        ? object.aggregateVotes.map((e: any) => AggregateExchangeRateVote.fromJSON(e))
        : globalThis.Array.isArray(object?.aggregate_votes)
        ? object.aggregate_votes.map((e: any) => AggregateExchangeRateVote.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryAggregateVotesResponse): unknown {
    const obj: any = {};
    if (message.aggregateVotes?.length) {
      obj.aggregateVotes = message.aggregateVotes.map((e) => AggregateExchangeRateVote.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAggregateVotesResponse>, I>>(base?: I): QueryAggregateVotesResponse {
    return QueryAggregateVotesResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAggregateVotesResponse>, I>>(object: I): QueryAggregateVotesResponse {
    const message = createBaseQueryAggregateVotesResponse();
    message.aggregateVotes = object.aggregateVotes?.map((e) => AggregateExchangeRateVote.fromPartial(e)) || [];
    return message;
  },
};

function createBaseQueryParams(): QueryParams {
  return {};
}

export const QueryParams: MessageFns<QueryParams> = {
  encode(_: QueryParams, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryParams {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryParams();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryParams {
    return {};
  },

  toJSON(_: QueryParams): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryParams>, I>>(base?: I): QueryParams {
    return QueryParams.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryParams>, I>>(_: I): QueryParams {
    const message = createBaseQueryParams();
    return message;
  },
};

function createBaseQueryParamsResponse(): QueryParamsResponse {
  return { params: undefined };
}

export const QueryParamsResponse: MessageFns<QueryParamsResponse> = {
  encode(message: QueryParamsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.params !== undefined) {
      Params.encode(message.params, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryParamsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.params = Params.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryParamsResponse {
    return { params: isSet(object.params) ? Params.fromJSON(object.params) : undefined };
  },

  toJSON(message: QueryParamsResponse): unknown {
    const obj: any = {};
    if (message.params !== undefined) {
      obj.params = Params.toJSON(message.params);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryParamsResponse>, I>>(base?: I): QueryParamsResponse {
    return QueryParamsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryParamsResponse>, I>>(object: I): QueryParamsResponse {
    const message = createBaseQueryParamsResponse();
    message.params = (object.params !== undefined && object.params !== null)
      ? Params.fromPartial(object.params)
      : undefined;
    return message;
  },
};

function createBaseQueryMedians(): QueryMedians {
  return { denom: "", numStamps: 0 };
}

export const QueryMedians: MessageFns<QueryMedians> = {
  encode(message: QueryMedians, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    if (message.numStamps !== 0) {
      writer.uint32(16).uint32(message.numStamps);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMedians {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMedians();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.numStamps = reader.uint32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMedians {
    return {
      denom: isSet(object.denom) ? globalThis.String(object.denom) : "",
      numStamps: isSet(object.numStamps)
        ? globalThis.Number(object.numStamps)
        : isSet(object.num_stamps)
        ? globalThis.Number(object.num_stamps)
        : 0,
    };
  },

  toJSON(message: QueryMedians): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    if (message.numStamps !== 0) {
      obj.numStamps = Math.round(message.numStamps);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMedians>, I>>(base?: I): QueryMedians {
    return QueryMedians.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMedians>, I>>(object: I): QueryMedians {
    const message = createBaseQueryMedians();
    message.denom = object.denom ?? "";
    message.numStamps = object.numStamps ?? 0;
    return message;
  },
};

function createBaseQueryMediansResponse(): QueryMediansResponse {
  return { medians: [] };
}

export const QueryMediansResponse: MessageFns<QueryMediansResponse> = {
  encode(message: QueryMediansResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.medians) {
      PriceStamp.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMediansResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMediansResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.medians.push(PriceStamp.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMediansResponse {
    return {
      medians: globalThis.Array.isArray(object?.medians) ? object.medians.map((e: any) => PriceStamp.fromJSON(e)) : [],
    };
  },

  toJSON(message: QueryMediansResponse): unknown {
    const obj: any = {};
    if (message.medians?.length) {
      obj.medians = message.medians.map((e) => PriceStamp.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMediansResponse>, I>>(base?: I): QueryMediansResponse {
    return QueryMediansResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMediansResponse>, I>>(object: I): QueryMediansResponse {
    const message = createBaseQueryMediansResponse();
    message.medians = object.medians?.map((e) => PriceStamp.fromPartial(e)) || [];
    return message;
  },
};

function createBaseQueryMedianDeviations(): QueryMedianDeviations {
  return { denom: "" };
}

export const QueryMedianDeviations: MessageFns<QueryMedianDeviations> = {
  encode(message: QueryMedianDeviations, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMedianDeviations {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMedianDeviations();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMedianDeviations {
    return { denom: isSet(object.denom) ? globalThis.String(object.denom) : "" };
  },

  toJSON(message: QueryMedianDeviations): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMedianDeviations>, I>>(base?: I): QueryMedianDeviations {
    return QueryMedianDeviations.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMedianDeviations>, I>>(object: I): QueryMedianDeviations {
    const message = createBaseQueryMedianDeviations();
    message.denom = object.denom ?? "";
    return message;
  },
};

function createBaseQueryMedianDeviationsResponse(): QueryMedianDeviationsResponse {
  return { medianDeviations: [] };
}

export const QueryMedianDeviationsResponse: MessageFns<QueryMedianDeviationsResponse> = {
  encode(message: QueryMedianDeviationsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.medianDeviations) {
      PriceStamp.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryMedianDeviationsResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryMedianDeviationsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.medianDeviations.push(PriceStamp.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryMedianDeviationsResponse {
    return {
      medianDeviations: globalThis.Array.isArray(object?.medianDeviations)
        ? object.medianDeviations.map((e: any) => PriceStamp.fromJSON(e))
        : globalThis.Array.isArray(object?.median_deviations)
        ? object.median_deviations.map((e: any) => PriceStamp.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryMedianDeviationsResponse): unknown {
    const obj: any = {};
    if (message.medianDeviations?.length) {
      obj.medianDeviations = message.medianDeviations.map((e) => PriceStamp.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryMedianDeviationsResponse>, I>>(base?: I): QueryMedianDeviationsResponse {
    return QueryMedianDeviationsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryMedianDeviationsResponse>, I>>(
    object: I,
  ): QueryMedianDeviationsResponse {
    const message = createBaseQueryMedianDeviationsResponse();
    message.medianDeviations = object.medianDeviations?.map((e) => PriceStamp.fromPartial(e)) || [];
    return message;
  },
};

function createBaseQueryValidatorRewardSet(): QueryValidatorRewardSet {
  return {};
}

export const QueryValidatorRewardSet: MessageFns<QueryValidatorRewardSet> = {
  encode(_: QueryValidatorRewardSet, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryValidatorRewardSet {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryValidatorRewardSet();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryValidatorRewardSet {
    return {};
  },

  toJSON(_: QueryValidatorRewardSet): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryValidatorRewardSet>, I>>(base?: I): QueryValidatorRewardSet {
    return QueryValidatorRewardSet.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryValidatorRewardSet>, I>>(_: I): QueryValidatorRewardSet {
    const message = createBaseQueryValidatorRewardSet();
    return message;
  },
};

function createBaseQueryValidatorRewardSetResponse(): QueryValidatorRewardSetResponse {
  return { validators: undefined };
}

export const QueryValidatorRewardSetResponse: MessageFns<QueryValidatorRewardSetResponse> = {
  encode(message: QueryValidatorRewardSetResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.validators !== undefined) {
      ValidatorRewardSet.encode(message.validators, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryValidatorRewardSetResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryValidatorRewardSetResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.validators = ValidatorRewardSet.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryValidatorRewardSetResponse {
    return { validators: isSet(object.validators) ? ValidatorRewardSet.fromJSON(object.validators) : undefined };
  },

  toJSON(message: QueryValidatorRewardSetResponse): unknown {
    const obj: any = {};
    if (message.validators !== undefined) {
      obj.validators = ValidatorRewardSet.toJSON(message.validators);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryValidatorRewardSetResponse>, I>>(base?: I): QueryValidatorRewardSetResponse {
    return QueryValidatorRewardSetResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryValidatorRewardSetResponse>, I>>(
    object: I,
  ): QueryValidatorRewardSetResponse {
    const message = createBaseQueryValidatorRewardSetResponse();
    message.validators = (object.validators !== undefined && object.validators !== null)
      ? ValidatorRewardSet.fromPartial(object.validators)
      : undefined;
    return message;
  },
};

function createBaseQueryEMARequest(): QueryEMARequest {
  return { denom: "" };
}

export const QueryEMARequest: MessageFns<QueryEMARequest> = {
  encode(message: QueryEMARequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryEMARequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryEMARequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryEMARequest {
    return { denom: isSet(object.denom) ? globalThis.String(object.denom) : "" };
  },

  toJSON(message: QueryEMARequest): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryEMARequest>, I>>(base?: I): QueryEMARequest {
    return QueryEMARequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryEMARequest>, I>>(object: I): QueryEMARequest {
    const message = createBaseQueryEMARequest();
    message.denom = object.denom ?? "";
    return message;
  },
};

function createBaseQueryEMAResponse(): QueryEMAResponse {
  return { price: "" };
}

export const QueryEMAResponse: MessageFns<QueryEMAResponse> = {
  encode(message: QueryEMAResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.price !== "") {
      writer.uint32(10).string(message.price);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryEMAResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryEMAResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.price = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryEMAResponse {
    return { price: isSet(object.price) ? globalThis.String(object.price) : "" };
  },

  toJSON(message: QueryEMAResponse): unknown {
    const obj: any = {};
    if (message.price !== "") {
      obj.price = message.price;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryEMAResponse>, I>>(base?: I): QueryEMAResponse {
    return QueryEMAResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryEMAResponse>, I>>(object: I): QueryEMAResponse {
    const message = createBaseQueryEMAResponse();
    message.price = object.price ?? "";
    return message;
  },
};

function createBaseQueryWMARequest(): QueryWMARequest {
  return { denom: "", strategy: "", customWeights: [] };
}

export const QueryWMARequest: MessageFns<QueryWMARequest> = {
  encode(message: QueryWMARequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    if (message.strategy !== "") {
      writer.uint32(18).string(message.strategy);
    }
    writer.uint32(26).fork();
    for (const v of message.customWeights) {
      if (BigInt.asIntN(64, v) !== v) {
        throw new globalThis.Error("a value provided in array field customWeights of type int64 is too large");
      }
      writer.int64(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryWMARequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryWMARequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.strategy = reader.string();
          continue;
        }
        case 3: {
          if (tag === 24) {
            message.customWeights.push(reader.int64() as bigint);

            continue;
          }

          if (tag === 26) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.customWeights.push(reader.int64() as bigint);
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryWMARequest {
    return {
      denom: isSet(object.denom) ? globalThis.String(object.denom) : "",
      strategy: isSet(object.strategy) ? globalThis.String(object.strategy) : "",
      customWeights: globalThis.Array.isArray(object?.customWeights)
        ? object.customWeights.map((e: any) => BigInt(e))
        : globalThis.Array.isArray(object?.custom_weights)
        ? object.custom_weights.map((e: any) => BigInt(e))
        : [],
    };
  },

  toJSON(message: QueryWMARequest): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    if (message.strategy !== "") {
      obj.strategy = message.strategy;
    }
    if (message.customWeights?.length) {
      obj.customWeights = message.customWeights.map((e) => e.toString());
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryWMARequest>, I>>(base?: I): QueryWMARequest {
    return QueryWMARequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryWMARequest>, I>>(object: I): QueryWMARequest {
    const message = createBaseQueryWMARequest();
    message.denom = object.denom ?? "";
    message.strategy = object.strategy ?? "";
    message.customWeights = object.customWeights?.map((e) => e) || [];
    return message;
  },
};

function createBaseQueryWMAResponse(): QueryWMAResponse {
  return { price: "" };
}

export const QueryWMAResponse: MessageFns<QueryWMAResponse> = {
  encode(message: QueryWMAResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.price !== "") {
      writer.uint32(10).string(message.price);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryWMAResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryWMAResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.price = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryWMAResponse {
    return { price: isSet(object.price) ? globalThis.String(object.price) : "" };
  },

  toJSON(message: QueryWMAResponse): unknown {
    const obj: any = {};
    if (message.price !== "") {
      obj.price = message.price;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryWMAResponse>, I>>(base?: I): QueryWMAResponse {
    return QueryWMAResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryWMAResponse>, I>>(object: I): QueryWMAResponse {
    const message = createBaseQueryWMAResponse();
    message.price = object.price ?? "";
    return message;
  },
};

function createBaseQuerySMARequest(): QuerySMARequest {
  return { denom: "" };
}

export const QuerySMARequest: MessageFns<QuerySMARequest> = {
  encode(message: QuerySMARequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.denom !== "") {
      writer.uint32(10).string(message.denom);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QuerySMARequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQuerySMARequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.denom = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QuerySMARequest {
    return { denom: isSet(object.denom) ? globalThis.String(object.denom) : "" };
  },

  toJSON(message: QuerySMARequest): unknown {
    const obj: any = {};
    if (message.denom !== "") {
      obj.denom = message.denom;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QuerySMARequest>, I>>(base?: I): QuerySMARequest {
    return QuerySMARequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QuerySMARequest>, I>>(object: I): QuerySMARequest {
    const message = createBaseQuerySMARequest();
    message.denom = object.denom ?? "";
    return message;
  },
};

function createBaseQuerySMAResponse(): QuerySMAResponse {
  return { price: "" };
}

export const QuerySMAResponse: MessageFns<QuerySMAResponse> = {
  encode(message: QuerySMAResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.price !== "") {
      writer.uint32(10).string(message.price);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QuerySMAResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQuerySMAResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.price = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QuerySMAResponse {
    return { price: isSet(object.price) ? globalThis.String(object.price) : "" };
  },

  toJSON(message: QuerySMAResponse): unknown {
    const obj: any = {};
    if (message.price !== "") {
      obj.price = message.price;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QuerySMAResponse>, I>>(base?: I): QuerySMAResponse {
    return QuerySMAResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QuerySMAResponse>, I>>(object: I): QuerySMAResponse {
    const message = createBaseQuerySMAResponse();
    message.price = object.price ?? "";
    return message;
  },
};

function createBaseConvertUSDCtoCHEQRequest(): ConvertUSDCtoCHEQRequest {
  return { amount: "", maType: "", wmaStrategy: "", customWeights: [] };
}

export const ConvertUSDCtoCHEQRequest: MessageFns<ConvertUSDCtoCHEQRequest> = {
  encode(message: ConvertUSDCtoCHEQRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.amount !== "") {
      writer.uint32(10).string(message.amount);
    }
    if (message.maType !== "") {
      writer.uint32(18).string(message.maType);
    }
    if (message.wmaStrategy !== "") {
      writer.uint32(26).string(message.wmaStrategy);
    }
    writer.uint32(34).fork();
    for (const v of message.customWeights) {
      writer.int32(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ConvertUSDCtoCHEQRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseConvertUSDCtoCHEQRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.amount = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.maType = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.wmaStrategy = reader.string();
          continue;
        }
        case 4: {
          if (tag === 32) {
            message.customWeights.push(reader.int32());

            continue;
          }

          if (tag === 34) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.customWeights.push(reader.int32());
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ConvertUSDCtoCHEQRequest {
    return {
      amount: isSet(object.amount) ? globalThis.String(object.amount) : "",
      maType: isSet(object.maType)
        ? globalThis.String(object.maType)
        : isSet(object.ma_type)
        ? globalThis.String(object.ma_type)
        : "",
      wmaStrategy: isSet(object.wmaStrategy)
        ? globalThis.String(object.wmaStrategy)
        : isSet(object.wma_strategy)
        ? globalThis.String(object.wma_strategy)
        : "",
      customWeights: globalThis.Array.isArray(object?.customWeights)
        ? object.customWeights.map((e: any) => globalThis.Number(e))
        : globalThis.Array.isArray(object?.custom_weights)
        ? object.custom_weights.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: ConvertUSDCtoCHEQRequest): unknown {
    const obj: any = {};
    if (message.amount !== "") {
      obj.amount = message.amount;
    }
    if (message.maType !== "") {
      obj.maType = message.maType;
    }
    if (message.wmaStrategy !== "") {
      obj.wmaStrategy = message.wmaStrategy;
    }
    if (message.customWeights?.length) {
      obj.customWeights = message.customWeights.map((e) => Math.round(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ConvertUSDCtoCHEQRequest>, I>>(base?: I): ConvertUSDCtoCHEQRequest {
    return ConvertUSDCtoCHEQRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ConvertUSDCtoCHEQRequest>, I>>(object: I): ConvertUSDCtoCHEQRequest {
    const message = createBaseConvertUSDCtoCHEQRequest();
    message.amount = object.amount ?? "";
    message.maType = object.maType ?? "";
    message.wmaStrategy = object.wmaStrategy ?? "";
    message.customWeights = object.customWeights?.map((e) => e) || [];
    return message;
  },
};

function createBaseConvertUSDCtoCHEQResponse(): ConvertUSDCtoCHEQResponse {
  return { amount: "" };
}

export const ConvertUSDCtoCHEQResponse: MessageFns<ConvertUSDCtoCHEQResponse> = {
  encode(message: ConvertUSDCtoCHEQResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.amount !== "") {
      writer.uint32(10).string(message.amount);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ConvertUSDCtoCHEQResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseConvertUSDCtoCHEQResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.amount = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ConvertUSDCtoCHEQResponse {
    return { amount: isSet(object.amount) ? globalThis.String(object.amount) : "" };
  },

  toJSON(message: ConvertUSDCtoCHEQResponse): unknown {
    const obj: any = {};
    if (message.amount !== "") {
      obj.amount = message.amount;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ConvertUSDCtoCHEQResponse>, I>>(base?: I): ConvertUSDCtoCHEQResponse {
    return ConvertUSDCtoCHEQResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ConvertUSDCtoCHEQResponse>, I>>(object: I): ConvertUSDCtoCHEQResponse {
    const message = createBaseConvertUSDCtoCHEQResponse();
    message.amount = object.amount ?? "";
    return message;
  },
};

/** Query defines the gRPC querier service. */
export interface Query {
  /**
   * ExchangeRates returns exchange rates of all denoms,
   * or, if specified, returns a single denom
   */
  ExchangeRates(request: QueryExchangeRates): Promise<QueryExchangeRatesResponse>;
  /** ActiveExchangeRates returns all active denoms */
  ActiveExchangeRates(request: QueryActiveExchangeRates): Promise<QueryActiveExchangeRatesResponse>;
  /** FeederDelegation returns feeder delegation of a validator */
  FeederDelegation(request: QueryFeederDelegation): Promise<QueryFeederDelegationResponse>;
  /** MissCounter returns oracle miss counter of a validator */
  MissCounter(request: QueryMissCounter): Promise<QueryMissCounterResponse>;
  /** SlashWindow returns slash window information */
  SlashWindow(request: QuerySlashWindow): Promise<QuerySlashWindowResponse>;
  /** AggregatePrevote returns an aggregate prevote of a validator */
  AggregatePrevote(request: QueryAggregatePrevote): Promise<QueryAggregatePrevoteResponse>;
  /** AggregatePrevotes returns aggregate prevotes of all validators */
  AggregatePrevotes(request: QueryAggregatePrevotes): Promise<QueryAggregatePrevotesResponse>;
  /** AggregateVote returns an aggregate vote of a validator */
  AggregateVote(request: QueryAggregateVote): Promise<QueryAggregateVoteResponse>;
  /** AggregateVotes returns aggregate votes of all validators */
  AggregateVotes(request: QueryAggregateVotes): Promise<QueryAggregateVotesResponse>;
  /** Params queries all parameters. */
  Params(request: QueryParams): Promise<QueryParamsResponse>;
  /**
   * Medians returns medians of all denoms,
   * or, if specified, returns a single median
   */
  Medians(request: QueryMedians): Promise<QueryMediansResponse>;
  /**
   * MedianDeviations returns median deviations of all denoms,
   * or, if specified, returns a single median deviation
   */
  MedianDeviations(request: QueryMedianDeviations): Promise<QueryMedianDeviationsResponse>;
  /**
   * ValidatorRewardSet returns the set of validators that is
   * earning rewards for voting on exchange rates based on their
   * misscounter in a given Slash Window
   */
  ValidatorRewardSet(request: QueryValidatorRewardSet): Promise<QueryValidatorRewardSetResponse>;
  EMA(request: QueryEMARequest): Promise<QueryEMAResponse>;
  WMA(request: QueryWMARequest): Promise<QueryWMAResponse>;
  SMA(request: QuerySMARequest): Promise<QuerySMAResponse>;
  ConvertUSDCtoCHEQ(request: ConvertUSDCtoCHEQRequest): Promise<ConvertUSDCtoCHEQResponse>;
}

export const QueryServiceName = "cheqd.oracle.v2.Query";
export class QueryClientImpl implements Query {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || QueryServiceName;
    this.rpc = rpc;
    this.ExchangeRates = this.ExchangeRates.bind(this);
    this.ActiveExchangeRates = this.ActiveExchangeRates.bind(this);
    this.FeederDelegation = this.FeederDelegation.bind(this);
    this.MissCounter = this.MissCounter.bind(this);
    this.SlashWindow = this.SlashWindow.bind(this);
    this.AggregatePrevote = this.AggregatePrevote.bind(this);
    this.AggregatePrevotes = this.AggregatePrevotes.bind(this);
    this.AggregateVote = this.AggregateVote.bind(this);
    this.AggregateVotes = this.AggregateVotes.bind(this);
    this.Params = this.Params.bind(this);
    this.Medians = this.Medians.bind(this);
    this.MedianDeviations = this.MedianDeviations.bind(this);
    this.ValidatorRewardSet = this.ValidatorRewardSet.bind(this);
    this.EMA = this.EMA.bind(this);
    this.WMA = this.WMA.bind(this);
    this.SMA = this.SMA.bind(this);
    this.ConvertUSDCtoCHEQ = this.ConvertUSDCtoCHEQ.bind(this);
  }
  ExchangeRates(request: QueryExchangeRates): Promise<QueryExchangeRatesResponse> {
    const data = QueryExchangeRates.encode(request).finish();
    const promise = this.rpc.request(this.service, "ExchangeRates", data);
    return promise.then((data) => QueryExchangeRatesResponse.decode(new BinaryReader(data)));
  }

  ActiveExchangeRates(request: QueryActiveExchangeRates): Promise<QueryActiveExchangeRatesResponse> {
    const data = QueryActiveExchangeRates.encode(request).finish();
    const promise = this.rpc.request(this.service, "ActiveExchangeRates", data);
    return promise.then((data) => QueryActiveExchangeRatesResponse.decode(new BinaryReader(data)));
  }

  FeederDelegation(request: QueryFeederDelegation): Promise<QueryFeederDelegationResponse> {
    const data = QueryFeederDelegation.encode(request).finish();
    const promise = this.rpc.request(this.service, "FeederDelegation", data);
    return promise.then((data) => QueryFeederDelegationResponse.decode(new BinaryReader(data)));
  }

  MissCounter(request: QueryMissCounter): Promise<QueryMissCounterResponse> {
    const data = QueryMissCounter.encode(request).finish();
    const promise = this.rpc.request(this.service, "MissCounter", data);
    return promise.then((data) => QueryMissCounterResponse.decode(new BinaryReader(data)));
  }

  SlashWindow(request: QuerySlashWindow): Promise<QuerySlashWindowResponse> {
    const data = QuerySlashWindow.encode(request).finish();
    const promise = this.rpc.request(this.service, "SlashWindow", data);
    return promise.then((data) => QuerySlashWindowResponse.decode(new BinaryReader(data)));
  }

  AggregatePrevote(request: QueryAggregatePrevote): Promise<QueryAggregatePrevoteResponse> {
    const data = QueryAggregatePrevote.encode(request).finish();
    const promise = this.rpc.request(this.service, "AggregatePrevote", data);
    return promise.then((data) => QueryAggregatePrevoteResponse.decode(new BinaryReader(data)));
  }

  AggregatePrevotes(request: QueryAggregatePrevotes): Promise<QueryAggregatePrevotesResponse> {
    const data = QueryAggregatePrevotes.encode(request).finish();
    const promise = this.rpc.request(this.service, "AggregatePrevotes", data);
    return promise.then((data) => QueryAggregatePrevotesResponse.decode(new BinaryReader(data)));
  }

  AggregateVote(request: QueryAggregateVote): Promise<QueryAggregateVoteResponse> {
    const data = QueryAggregateVote.encode(request).finish();
    const promise = this.rpc.request(this.service, "AggregateVote", data);
    return promise.then((data) => QueryAggregateVoteResponse.decode(new BinaryReader(data)));
  }

  AggregateVotes(request: QueryAggregateVotes): Promise<QueryAggregateVotesResponse> {
    const data = QueryAggregateVotes.encode(request).finish();
    const promise = this.rpc.request(this.service, "AggregateVotes", data);
    return promise.then((data) => QueryAggregateVotesResponse.decode(new BinaryReader(data)));
  }

  Params(request: QueryParams): Promise<QueryParamsResponse> {
    const data = QueryParams.encode(request).finish();
    const promise = this.rpc.request(this.service, "Params", data);
    return promise.then((data) => QueryParamsResponse.decode(new BinaryReader(data)));
  }

  Medians(request: QueryMedians): Promise<QueryMediansResponse> {
    const data = QueryMedians.encode(request).finish();
    const promise = this.rpc.request(this.service, "Medians", data);
    return promise.then((data) => QueryMediansResponse.decode(new BinaryReader(data)));
  }

  MedianDeviations(request: QueryMedianDeviations): Promise<QueryMedianDeviationsResponse> {
    const data = QueryMedianDeviations.encode(request).finish();
    const promise = this.rpc.request(this.service, "MedianDeviations", data);
    return promise.then((data) => QueryMedianDeviationsResponse.decode(new BinaryReader(data)));
  }

  ValidatorRewardSet(request: QueryValidatorRewardSet): Promise<QueryValidatorRewardSetResponse> {
    const data = QueryValidatorRewardSet.encode(request).finish();
    const promise = this.rpc.request(this.service, "ValidatorRewardSet", data);
    return promise.then((data) => QueryValidatorRewardSetResponse.decode(new BinaryReader(data)));
  }

  EMA(request: QueryEMARequest): Promise<QueryEMAResponse> {
    const data = QueryEMARequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "EMA", data);
    return promise.then((data) => QueryEMAResponse.decode(new BinaryReader(data)));
  }

  WMA(request: QueryWMARequest): Promise<QueryWMAResponse> {
    const data = QueryWMARequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "WMA", data);
    return promise.then((data) => QueryWMAResponse.decode(new BinaryReader(data)));
  }

  SMA(request: QuerySMARequest): Promise<QuerySMAResponse> {
    const data = QuerySMARequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "SMA", data);
    return promise.then((data) => QuerySMAResponse.decode(new BinaryReader(data)));
  }

  ConvertUSDCtoCHEQ(request: ConvertUSDCtoCHEQRequest): Promise<ConvertUSDCtoCHEQResponse> {
    const data = ConvertUSDCtoCHEQRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "ConvertUSDCtoCHEQ", data);
    return promise.then((data) => ConvertUSDCtoCHEQResponse.decode(new BinaryReader(data)));
  }
}

interface Rpc {
  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;

type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}