@cheqd/ts-proto/cheqd/oracle/v2/oracle.ts

A TypeScript package for all transpiled cheqd ProtoBuf definitions.

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

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

/** Params defines the parameters for the oracle module. */
export interface Params {
  votePeriod: bigint;
  voteThreshold: string;
  rewardBands: RewardBand[];
  rewardDistributionWindow: bigint;
  acceptList: Denom[];
  slashFraction: string;
  slashWindow: bigint;
  minValidPerWindow: string;
  mandatoryList: Denom[];
  /**
   * Historic Stamp Period represents the amount of blocks the oracle
   * module waits before recording a new historic price.
   */
  historicStampPeriod: bigint;
  /**
   * Median Stamp Period represents the amount blocks the oracle module
   * waits between calculating and stamping a new median and standard
   * deviation of that median.
   */
  medianStampPeriod: bigint;
  /**
   * Maximum Price Stamps represents the maximum amount of historic prices
   * the oracle module will store before pruning via FIFO.
   */
  maximumPriceStamps: bigint;
  /**
   * Maximum Median Stamps represents the maximum amount of medians the
   * oracle module will store before pruning via FIFO.
   */
  maximumMedianStamps: bigint;
  /**
   * Currency Pair Providers defines the currency provider pairs the
   * price feeder uses upon start up for pricing data.
   */
  currencyPairProviders: CurrencyPairProviders[];
  /**
   * Currency Deviation Thresholds defines the deviation thresholds
   * for each base currency the price feeder uses upon start up.
   */
  currencyDeviationThresholds: CurrencyDeviationThreshold[];
  /** usdc ibc denom */
  usdcIbcDenom: string;
  slashingEnabled: boolean;
  averagingWindow: bigint;
}

/** Denom - the object to hold configurations of each denom */
export interface Denom {
  baseDenom: string;
  symbolDenom: string;
  exponent: number;
}

/** RewardBand - the object to hold the reward band configuration for a given denom. */
export interface RewardBand {
  symbolDenom: string;
  rewardBand: string;
}

/**
 * AggregateExchangeRatePrevote -
 * struct for aggregate prevoting on the ExchangeRateVote.
 * The purpose of aggregate prevote is to hide vote exchange rates with hash
 * which is formatted as hex string in SHA256("{salt}:{exchange
 * rate}{denom},...,{exchange rate}{denom}:{voter}")
 */
export interface AggregateExchangeRatePrevote {
  hash: string;
  voter: string;
  submitBlock: bigint;
}

/**
 * AggregateExchangeRateVote - struct for voting on
 * the exchange rates of USD denominated in various assets.
 */
export interface AggregateExchangeRateVote {
  exchangeRates: DecCoin[];
  voter: string;
}

/**
 * PriceStamp defines a stamp of a denom's exchange rate
 * at the block number it was calculated in.
 */
export interface PriceStamp {
  exchangeRate: DecCoin | undefined;
  blockNum: bigint;
}

/**
 * ValidatorRewardSet is the set of validators that is earning
 * rewards for voting on exchange rates based on their misscounter
 * in a given Slash Window. This set gets updated every Slash Window.
 */
export interface ValidatorRewardSet {
  validatorSet: string[];
}

/**
 * CurrencyPairProviders defines a list of currency providers for the
 * currency pair defined by base and quote.
 */
export interface CurrencyPairProviders {
  baseDenom: string;
  quoteDenom: string;
  pairAddress: PairAddressProvider[];
  providers: string[];
}

/**
 * PairAddressProvider defines the uniswap pair address and provider
 * for uniswap currency pair.
 */
export interface PairAddressProvider {
  address: string;
  addressProvider: string;
}

/**
 * CurrencyDeviationThreshold defines a deviation theshold for a
 * base denom.
 */
export interface CurrencyDeviationThreshold {
  baseDenom: string;
  threshold: string;
}

/**
 * ParamUpdatePlan specifies updates to the Oracle module parameters
 * and at which block height they should occur.
 */
export interface ParamUpdatePlan {
  /** Store keys of the Oracle params getting updated. */
  keys: string[];
  /** The height at which the param update must be performed. */
  height: bigint;
  /** Changes to the oracle parameters. */
  changes: Params | undefined;
}

function createBaseParams(): Params {
  return {
    votePeriod: 0n,
    voteThreshold: "",
    rewardBands: [],
    rewardDistributionWindow: 0n,
    acceptList: [],
    slashFraction: "",
    slashWindow: 0n,
    minValidPerWindow: "",
    mandatoryList: [],
    historicStampPeriod: 0n,
    medianStampPeriod: 0n,
    maximumPriceStamps: 0n,
    maximumMedianStamps: 0n,
    currencyPairProviders: [],
    currencyDeviationThresholds: [],
    usdcIbcDenom: "",
    slashingEnabled: false,
    averagingWindow: 0n,
  };
}

export const Params: MessageFns<Params> = {
  encode(message: Params, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.votePeriod !== 0n) {
      if (BigInt.asUintN(64, message.votePeriod) !== message.votePeriod) {
        throw new globalThis.Error("value provided for field message.votePeriod of type uint64 too large");
      }
      writer.uint32(8).uint64(message.votePeriod);
    }
    if (message.voteThreshold !== "") {
      writer.uint32(18).string(message.voteThreshold);
    }
    for (const v of message.rewardBands) {
      RewardBand.encode(v!, writer.uint32(26).fork()).join();
    }
    if (message.rewardDistributionWindow !== 0n) {
      if (BigInt.asUintN(64, message.rewardDistributionWindow) !== message.rewardDistributionWindow) {
        throw new globalThis.Error(
          "value provided for field message.rewardDistributionWindow of type uint64 too large",
        );
      }
      writer.uint32(32).uint64(message.rewardDistributionWindow);
    }
    for (const v of message.acceptList) {
      Denom.encode(v!, writer.uint32(42).fork()).join();
    }
    if (message.slashFraction !== "") {
      writer.uint32(50).string(message.slashFraction);
    }
    if (message.slashWindow !== 0n) {
      if (BigInt.asUintN(64, message.slashWindow) !== message.slashWindow) {
        throw new globalThis.Error("value provided for field message.slashWindow of type uint64 too large");
      }
      writer.uint32(56).uint64(message.slashWindow);
    }
    if (message.minValidPerWindow !== "") {
      writer.uint32(66).string(message.minValidPerWindow);
    }
    for (const v of message.mandatoryList) {
      Denom.encode(v!, writer.uint32(74).fork()).join();
    }
    if (message.historicStampPeriod !== 0n) {
      if (BigInt.asUintN(64, message.historicStampPeriod) !== message.historicStampPeriod) {
        throw new globalThis.Error("value provided for field message.historicStampPeriod of type uint64 too large");
      }
      writer.uint32(80).uint64(message.historicStampPeriod);
    }
    if (message.medianStampPeriod !== 0n) {
      if (BigInt.asUintN(64, message.medianStampPeriod) !== message.medianStampPeriod) {
        throw new globalThis.Error("value provided for field message.medianStampPeriod of type uint64 too large");
      }
      writer.uint32(88).uint64(message.medianStampPeriod);
    }
    if (message.maximumPriceStamps !== 0n) {
      if (BigInt.asUintN(64, message.maximumPriceStamps) !== message.maximumPriceStamps) {
        throw new globalThis.Error("value provided for field message.maximumPriceStamps of type uint64 too large");
      }
      writer.uint32(96).uint64(message.maximumPriceStamps);
    }
    if (message.maximumMedianStamps !== 0n) {
      if (BigInt.asUintN(64, message.maximumMedianStamps) !== message.maximumMedianStamps) {
        throw new globalThis.Error("value provided for field message.maximumMedianStamps of type uint64 too large");
      }
      writer.uint32(104).uint64(message.maximumMedianStamps);
    }
    for (const v of message.currencyPairProviders) {
      CurrencyPairProviders.encode(v!, writer.uint32(114).fork()).join();
    }
    for (const v of message.currencyDeviationThresholds) {
      CurrencyDeviationThreshold.encode(v!, writer.uint32(122).fork()).join();
    }
    if (message.usdcIbcDenom !== "") {
      writer.uint32(130).string(message.usdcIbcDenom);
    }
    if (message.slashingEnabled !== false) {
      writer.uint32(136).bool(message.slashingEnabled);
    }
    if (message.averagingWindow !== 0n) {
      if (BigInt.asUintN(64, message.averagingWindow) !== message.averagingWindow) {
        throw new globalThis.Error("value provided for field message.averagingWindow of type uint64 too large");
      }
      writer.uint32(144).uint64(message.averagingWindow);
    }
    return writer;
  },

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

          message.votePeriod = reader.uint64() as bigint;
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

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

          message.rewardBands.push(RewardBand.decode(reader, reader.uint32()));
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.rewardDistributionWindow = reader.uint64() as bigint;
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.acceptList.push(Denom.decode(reader, reader.uint32()));
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.slashFraction = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 56) {
            break;
          }

          message.slashWindow = reader.uint64() as bigint;
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }

          message.minValidPerWindow = reader.string();
          continue;
        }
        case 9: {
          if (tag !== 74) {
            break;
          }

          message.mandatoryList.push(Denom.decode(reader, reader.uint32()));
          continue;
        }
        case 10: {
          if (tag !== 80) {
            break;
          }

          message.historicStampPeriod = reader.uint64() as bigint;
          continue;
        }
        case 11: {
          if (tag !== 88) {
            break;
          }

          message.medianStampPeriod = reader.uint64() as bigint;
          continue;
        }
        case 12: {
          if (tag !== 96) {
            break;
          }

          message.maximumPriceStamps = reader.uint64() as bigint;
          continue;
        }
        case 13: {
          if (tag !== 104) {
            break;
          }

          message.maximumMedianStamps = reader.uint64() as bigint;
          continue;
        }
        case 14: {
          if (tag !== 114) {
            break;
          }

          message.currencyPairProviders.push(CurrencyPairProviders.decode(reader, reader.uint32()));
          continue;
        }
        case 15: {
          if (tag !== 122) {
            break;
          }

          message.currencyDeviationThresholds.push(CurrencyDeviationThreshold.decode(reader, reader.uint32()));
          continue;
        }
        case 16: {
          if (tag !== 130) {
            break;
          }

          message.usdcIbcDenom = reader.string();
          continue;
        }
        case 17: {
          if (tag !== 136) {
            break;
          }

          message.slashingEnabled = reader.bool();
          continue;
        }
        case 18: {
          if (tag !== 144) {
            break;
          }

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

  fromJSON(object: any): Params {
    return {
      votePeriod: isSet(object.votePeriod)
        ? BigInt(object.votePeriod)
        : isSet(object.vote_period)
        ? BigInt(object.vote_period)
        : 0n,
      voteThreshold: isSet(object.voteThreshold)
        ? globalThis.String(object.voteThreshold)
        : isSet(object.vote_threshold)
        ? globalThis.String(object.vote_threshold)
        : "",
      rewardBands: globalThis.Array.isArray(object?.rewardBands)
        ? object.rewardBands.map((e: any) => RewardBand.fromJSON(e))
        : globalThis.Array.isArray(object?.reward_bands)
        ? object.reward_bands.map((e: any) => RewardBand.fromJSON(e))
        : [],
      rewardDistributionWindow: isSet(object.rewardDistributionWindow)
        ? BigInt(object.rewardDistributionWindow)
        : isSet(object.reward_distribution_window)
        ? BigInt(object.reward_distribution_window)
        : 0n,
      acceptList: globalThis.Array.isArray(object?.acceptList)
        ? object.acceptList.map((e: any) => Denom.fromJSON(e))
        : globalThis.Array.isArray(object?.accept_list)
        ? object.accept_list.map((e: any) => Denom.fromJSON(e))
        : [],
      slashFraction: isSet(object.slashFraction)
        ? globalThis.String(object.slashFraction)
        : isSet(object.slash_fraction)
        ? globalThis.String(object.slash_fraction)
        : "",
      slashWindow: isSet(object.slashWindow)
        ? BigInt(object.slashWindow)
        : isSet(object.slash_window)
        ? BigInt(object.slash_window)
        : 0n,
      minValidPerWindow: isSet(object.minValidPerWindow)
        ? globalThis.String(object.minValidPerWindow)
        : isSet(object.min_valid_per_window)
        ? globalThis.String(object.min_valid_per_window)
        : "",
      mandatoryList: globalThis.Array.isArray(object?.mandatoryList)
        ? object.mandatoryList.map((e: any) => Denom.fromJSON(e))
        : globalThis.Array.isArray(object?.mandatory_list)
        ? object.mandatory_list.map((e: any) => Denom.fromJSON(e))
        : [],
      historicStampPeriod: isSet(object.historicStampPeriod)
        ? BigInt(object.historicStampPeriod)
        : isSet(object.historic_stamp_period)
        ? BigInt(object.historic_stamp_period)
        : 0n,
      medianStampPeriod: isSet(object.medianStampPeriod)
        ? BigInt(object.medianStampPeriod)
        : isSet(object.median_stamp_period)
        ? BigInt(object.median_stamp_period)
        : 0n,
      maximumPriceStamps: isSet(object.maximumPriceStamps)
        ? BigInt(object.maximumPriceStamps)
        : isSet(object.maximum_price_stamps)
        ? BigInt(object.maximum_price_stamps)
        : 0n,
      maximumMedianStamps: isSet(object.maximumMedianStamps)
        ? BigInt(object.maximumMedianStamps)
        : isSet(object.maximum_median_stamps)
        ? BigInt(object.maximum_median_stamps)
        : 0n,
      currencyPairProviders: globalThis.Array.isArray(object?.currencyPairProviders)
        ? object.currencyPairProviders.map((e: any) => CurrencyPairProviders.fromJSON(e))
        : globalThis.Array.isArray(object?.currency_pair_providers)
        ? object.currency_pair_providers.map((e: any) => CurrencyPairProviders.fromJSON(e))
        : [],
      currencyDeviationThresholds: globalThis.Array.isArray(object?.currencyDeviationThresholds)
        ? object.currencyDeviationThresholds.map((e: any) => CurrencyDeviationThreshold.fromJSON(e))
        : globalThis.Array.isArray(object?.currency_deviation_thresholds)
        ? object.currency_deviation_thresholds.map((e: any) => CurrencyDeviationThreshold.fromJSON(e))
        : [],
      usdcIbcDenom: isSet(object.usdcIbcDenom)
        ? globalThis.String(object.usdcIbcDenom)
        : isSet(object.usdc_ibc_denom)
        ? globalThis.String(object.usdc_ibc_denom)
        : "",
      slashingEnabled: isSet(object.slashingEnabled)
        ? globalThis.Boolean(object.slashingEnabled)
        : isSet(object.slashing_enabled)
        ? globalThis.Boolean(object.slashing_enabled)
        : false,
      averagingWindow: isSet(object.averagingWindow)
        ? BigInt(object.averagingWindow)
        : isSet(object.averaging_window)
        ? BigInt(object.averaging_window)
        : 0n,
    };
  },

  toJSON(message: Params): unknown {
    const obj: any = {};
    if (message.votePeriod !== 0n) {
      obj.votePeriod = message.votePeriod.toString();
    }
    if (message.voteThreshold !== "") {
      obj.voteThreshold = message.voteThreshold;
    }
    if (message.rewardBands?.length) {
      obj.rewardBands = message.rewardBands.map((e) => RewardBand.toJSON(e));
    }
    if (message.rewardDistributionWindow !== 0n) {
      obj.rewardDistributionWindow = message.rewardDistributionWindow.toString();
    }
    if (message.acceptList?.length) {
      obj.acceptList = message.acceptList.map((e) => Denom.toJSON(e));
    }
    if (message.slashFraction !== "") {
      obj.slashFraction = message.slashFraction;
    }
    if (message.slashWindow !== 0n) {
      obj.slashWindow = message.slashWindow.toString();
    }
    if (message.minValidPerWindow !== "") {
      obj.minValidPerWindow = message.minValidPerWindow;
    }
    if (message.mandatoryList?.length) {
      obj.mandatoryList = message.mandatoryList.map((e) => Denom.toJSON(e));
    }
    if (message.historicStampPeriod !== 0n) {
      obj.historicStampPeriod = message.historicStampPeriod.toString();
    }
    if (message.medianStampPeriod !== 0n) {
      obj.medianStampPeriod = message.medianStampPeriod.toString();
    }
    if (message.maximumPriceStamps !== 0n) {
      obj.maximumPriceStamps = message.maximumPriceStamps.toString();
    }
    if (message.maximumMedianStamps !== 0n) {
      obj.maximumMedianStamps = message.maximumMedianStamps.toString();
    }
    if (message.currencyPairProviders?.length) {
      obj.currencyPairProviders = message.currencyPairProviders.map((e) => CurrencyPairProviders.toJSON(e));
    }
    if (message.currencyDeviationThresholds?.length) {
      obj.currencyDeviationThresholds = message.currencyDeviationThresholds.map((e) =>
        CurrencyDeviationThreshold.toJSON(e)
      );
    }
    if (message.usdcIbcDenom !== "") {
      obj.usdcIbcDenom = message.usdcIbcDenom;
    }
    if (message.slashingEnabled !== false) {
      obj.slashingEnabled = message.slashingEnabled;
    }
    if (message.averagingWindow !== 0n) {
      obj.averagingWindow = message.averagingWindow.toString();
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Params>, I>>(base?: I): Params {
    return Params.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Params>, I>>(object: I): Params {
    const message = createBaseParams();
    message.votePeriod = object.votePeriod ?? 0n;
    message.voteThreshold = object.voteThreshold ?? "";
    message.rewardBands = object.rewardBands?.map((e) => RewardBand.fromPartial(e)) || [];
    message.rewardDistributionWindow = object.rewardDistributionWindow ?? 0n;
    message.acceptList = object.acceptList?.map((e) => Denom.fromPartial(e)) || [];
    message.slashFraction = object.slashFraction ?? "";
    message.slashWindow = object.slashWindow ?? 0n;
    message.minValidPerWindow = object.minValidPerWindow ?? "";
    message.mandatoryList = object.mandatoryList?.map((e) => Denom.fromPartial(e)) || [];
    message.historicStampPeriod = object.historicStampPeriod ?? 0n;
    message.medianStampPeriod = object.medianStampPeriod ?? 0n;
    message.maximumPriceStamps = object.maximumPriceStamps ?? 0n;
    message.maximumMedianStamps = object.maximumMedianStamps ?? 0n;
    message.currencyPairProviders = object.currencyPairProviders?.map((e) => CurrencyPairProviders.fromPartial(e)) ||
      [];
    message.currencyDeviationThresholds =
      object.currencyDeviationThresholds?.map((e) => CurrencyDeviationThreshold.fromPartial(e)) || [];
    message.usdcIbcDenom = object.usdcIbcDenom ?? "";
    message.slashingEnabled = object.slashingEnabled ?? false;
    message.averagingWindow = object.averagingWindow ?? 0n;
    return message;
  },
};

function createBaseDenom(): Denom {
  return { baseDenom: "", symbolDenom: "", exponent: 0 };
}

export const Denom: MessageFns<Denom> = {
  encode(message: Denom, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.baseDenom !== "") {
      writer.uint32(10).string(message.baseDenom);
    }
    if (message.symbolDenom !== "") {
      writer.uint32(18).string(message.symbolDenom);
    }
    if (message.exponent !== 0) {
      writer.uint32(24).uint32(message.exponent);
    }
    return writer;
  },

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

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

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

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

  fromJSON(object: any): Denom {
    return {
      baseDenom: isSet(object.baseDenom)
        ? globalThis.String(object.baseDenom)
        : isSet(object.base_denom)
        ? globalThis.String(object.base_denom)
        : "",
      symbolDenom: isSet(object.symbolDenom)
        ? globalThis.String(object.symbolDenom)
        : isSet(object.symbol_denom)
        ? globalThis.String(object.symbol_denom)
        : "",
      exponent: isSet(object.exponent) ? globalThis.Number(object.exponent) : 0,
    };
  },

  toJSON(message: Denom): unknown {
    const obj: any = {};
    if (message.baseDenom !== "") {
      obj.baseDenom = message.baseDenom;
    }
    if (message.symbolDenom !== "") {
      obj.symbolDenom = message.symbolDenom;
    }
    if (message.exponent !== 0) {
      obj.exponent = Math.round(message.exponent);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Denom>, I>>(base?: I): Denom {
    return Denom.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Denom>, I>>(object: I): Denom {
    const message = createBaseDenom();
    message.baseDenom = object.baseDenom ?? "";
    message.symbolDenom = object.symbolDenom ?? "";
    message.exponent = object.exponent ?? 0;
    return message;
  },
};

function createBaseRewardBand(): RewardBand {
  return { symbolDenom: "", rewardBand: "" };
}

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

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

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

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

  fromJSON(object: any): RewardBand {
    return {
      symbolDenom: isSet(object.symbolDenom)
        ? globalThis.String(object.symbolDenom)
        : isSet(object.symbol_denom)
        ? globalThis.String(object.symbol_denom)
        : "",
      rewardBand: isSet(object.rewardBand)
        ? globalThis.String(object.rewardBand)
        : isSet(object.reward_band)
        ? globalThis.String(object.reward_band)
        : "",
    };
  },

  toJSON(message: RewardBand): unknown {
    const obj: any = {};
    if (message.symbolDenom !== "") {
      obj.symbolDenom = message.symbolDenom;
    }
    if (message.rewardBand !== "") {
      obj.rewardBand = message.rewardBand;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RewardBand>, I>>(base?: I): RewardBand {
    return RewardBand.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RewardBand>, I>>(object: I): RewardBand {
    const message = createBaseRewardBand();
    message.symbolDenom = object.symbolDenom ?? "";
    message.rewardBand = object.rewardBand ?? "";
    return message;
  },
};

function createBaseAggregateExchangeRatePrevote(): AggregateExchangeRatePrevote {
  return { hash: "", voter: "", submitBlock: 0n };
}

export const AggregateExchangeRatePrevote: MessageFns<AggregateExchangeRatePrevote> = {
  encode(message: AggregateExchangeRatePrevote, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.hash !== "") {
      writer.uint32(10).string(message.hash);
    }
    if (message.voter !== "") {
      writer.uint32(18).string(message.voter);
    }
    if (message.submitBlock !== 0n) {
      if (BigInt.asUintN(64, message.submitBlock) !== message.submitBlock) {
        throw new globalThis.Error("value provided for field message.submitBlock of type uint64 too large");
      }
      writer.uint32(24).uint64(message.submitBlock);
    }
    return writer;
  },

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

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

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

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

  fromJSON(object: any): AggregateExchangeRatePrevote {
    return {
      hash: isSet(object.hash) ? globalThis.String(object.hash) : "",
      voter: isSet(object.voter) ? globalThis.String(object.voter) : "",
      submitBlock: isSet(object.submitBlock)
        ? BigInt(object.submitBlock)
        : isSet(object.submit_block)
        ? BigInt(object.submit_block)
        : 0n,
    };
  },

  toJSON(message: AggregateExchangeRatePrevote): unknown {
    const obj: any = {};
    if (message.hash !== "") {
      obj.hash = message.hash;
    }
    if (message.voter !== "") {
      obj.voter = message.voter;
    }
    if (message.submitBlock !== 0n) {
      obj.submitBlock = message.submitBlock.toString();
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AggregateExchangeRatePrevote>, I>>(base?: I): AggregateExchangeRatePrevote {
    return AggregateExchangeRatePrevote.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AggregateExchangeRatePrevote>, I>>(object: I): AggregateExchangeRatePrevote {
    const message = createBaseAggregateExchangeRatePrevote();
    message.hash = object.hash ?? "";
    message.voter = object.voter ?? "";
    message.submitBlock = object.submitBlock ?? 0n;
    return message;
  },
};

function createBaseAggregateExchangeRateVote(): AggregateExchangeRateVote {
  return { exchangeRates: [], voter: "" };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): AggregateExchangeRateVote {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAggregateExchangeRateVote();
    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;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

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

  fromJSON(object: any): AggregateExchangeRateVote {
    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))
        : [],
      voter: isSet(object.voter) ? globalThis.String(object.voter) : "",
    };
  },

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

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

function createBasePriceStamp(): PriceStamp {
  return { exchangeRate: undefined, blockNum: 0n };
}

export const PriceStamp: MessageFns<PriceStamp> = {
  encode(message: PriceStamp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.exchangeRate !== undefined) {
      DecCoin.encode(message.exchangeRate, writer.uint32(10).fork()).join();
    }
    if (message.blockNum !== 0n) {
      if (BigInt.asUintN(64, message.blockNum) !== message.blockNum) {
        throw new globalThis.Error("value provided for field message.blockNum of type uint64 too large");
      }
      writer.uint32(16).uint64(message.blockNum);
    }
    return writer;
  },

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

          message.exchangeRate = DecCoin.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

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

  fromJSON(object: any): PriceStamp {
    return {
      exchangeRate: isSet(object.exchangeRate)
        ? DecCoin.fromJSON(object.exchangeRate)
        : isSet(object.exchange_rate)
        ? DecCoin.fromJSON(object.exchange_rate)
        : undefined,
      blockNum: isSet(object.blockNum)
        ? BigInt(object.blockNum)
        : isSet(object.block_num)
        ? BigInt(object.block_num)
        : 0n,
    };
  },

  toJSON(message: PriceStamp): unknown {
    const obj: any = {};
    if (message.exchangeRate !== undefined) {
      obj.exchangeRate = DecCoin.toJSON(message.exchangeRate);
    }
    if (message.blockNum !== 0n) {
      obj.blockNum = message.blockNum.toString();
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PriceStamp>, I>>(base?: I): PriceStamp {
    return PriceStamp.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PriceStamp>, I>>(object: I): PriceStamp {
    const message = createBasePriceStamp();
    message.exchangeRate = (object.exchangeRate !== undefined && object.exchangeRate !== null)
      ? DecCoin.fromPartial(object.exchangeRate)
      : undefined;
    message.blockNum = object.blockNum ?? 0n;
    return message;
  },
};

function createBaseValidatorRewardSet(): ValidatorRewardSet {
  return { validatorSet: [] };
}

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

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

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

  fromJSON(object: any): ValidatorRewardSet {
    return {
      validatorSet: globalThis.Array.isArray(object?.validatorSet)
        ? object.validatorSet.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.validator_set)
        ? object.validator_set.map((e: any) => globalThis.String(e))
        : [],
    };
  },

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

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

function createBaseCurrencyPairProviders(): CurrencyPairProviders {
  return { baseDenom: "", quoteDenom: "", pairAddress: [], providers: [] };
}

export const CurrencyPairProviders: MessageFns<CurrencyPairProviders> = {
  encode(message: CurrencyPairProviders, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.baseDenom !== "") {
      writer.uint32(10).string(message.baseDenom);
    }
    if (message.quoteDenom !== "") {
      writer.uint32(18).string(message.quoteDenom);
    }
    for (const v of message.pairAddress) {
      PairAddressProvider.encode(v!, writer.uint32(26).fork()).join();
    }
    for (const v of message.providers) {
      writer.uint32(34).string(v!);
    }
    return writer;
  },

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

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

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

          message.pairAddress.push(PairAddressProvider.decode(reader, reader.uint32()));
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

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

  fromJSON(object: any): CurrencyPairProviders {
    return {
      baseDenom: isSet(object.baseDenom)
        ? globalThis.String(object.baseDenom)
        : isSet(object.base_denom)
        ? globalThis.String(object.base_denom)
        : "",
      quoteDenom: isSet(object.quoteDenom)
        ? globalThis.String(object.quoteDenom)
        : isSet(object.quote_denom)
        ? globalThis.String(object.quote_denom)
        : "",
      pairAddress: globalThis.Array.isArray(object?.pairAddress)
        ? object.pairAddress.map((e: any) => PairAddressProvider.fromJSON(e))
        : globalThis.Array.isArray(object?.pair_address)
        ? object.pair_address.map((e: any) => PairAddressProvider.fromJSON(e))
        : [],
      providers: globalThis.Array.isArray(object?.providers)
        ? object.providers.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: CurrencyPairProviders): unknown {
    const obj: any = {};
    if (message.baseDenom !== "") {
      obj.baseDenom = message.baseDenom;
    }
    if (message.quoteDenom !== "") {
      obj.quoteDenom = message.quoteDenom;
    }
    if (message.pairAddress?.length) {
      obj.pairAddress = message.pairAddress.map((e) => PairAddressProvider.toJSON(e));
    }
    if (message.providers?.length) {
      obj.providers = message.providers;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<CurrencyPairProviders>, I>>(base?: I): CurrencyPairProviders {
    return CurrencyPairProviders.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<CurrencyPairProviders>, I>>(object: I): CurrencyPairProviders {
    const message = createBaseCurrencyPairProviders();
    message.baseDenom = object.baseDenom ?? "";
    message.quoteDenom = object.quoteDenom ?? "";
    message.pairAddress = object.pairAddress?.map((e) => PairAddressProvider.fromPartial(e)) || [];
    message.providers = object.providers?.map((e) => e) || [];
    return message;
  },
};

function createBasePairAddressProvider(): PairAddressProvider {
  return { address: "", addressProvider: "" };
}

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

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

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

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

  fromJSON(object: any): PairAddressProvider {
    return {
      address: isSet(object.address) ? globalThis.String(object.address) : "",
      addressProvider: isSet(object.addressProvider)
        ? globalThis.String(object.addressProvider)
        : isSet(object.address_provider)
        ? globalThis.String(object.address_provider)
        : "",
    };
  },

  toJSON(message: PairAddressProvider): unknown {
    const obj: any = {};
    if (message.address !== "") {
      obj.address = message.address;
    }
    if (message.addressProvider !== "") {
      obj.addressProvider = message.addressProvider;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<PairAddressProvider>, I>>(base?: I): PairAddressProvider {
    return PairAddressProvider.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<PairAddressProvider>, I>>(object: I): PairAddressProvider {
    const message = createBasePairAddressProvider();
    message.address = object.address ?? "";
    message.addressProvider = object.addressProvider ?? "";
    return message;
  },
};

function createBaseCurrencyDeviationThreshold(): CurrencyDeviationThreshold {
  return { baseDenom: "", threshold: "" };
}

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

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

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

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

  fromJSON(object: any): CurrencyDeviationThreshold {
    return {
      baseDenom: isSet(object.baseDenom)
        ? globalThis.String(object.baseDenom)
        : isSet(object.base_denom)
        ? globalThis.String(object.base_denom)
        : "",
      threshold: isSet(object.threshold) ? globalThis.String(object.threshold) : "",
    };
  },

  toJSON(message: CurrencyDeviationThreshold): unknown {
    const obj: any = {};
    if (message.baseDenom !== "") {
      obj.baseDenom = message.baseDenom;
    }
    if (message.threshold !== "") {
      obj.threshold = message.threshold;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<CurrencyDeviationThreshold>, I>>(base?: I): CurrencyDeviationThreshold {
    return CurrencyDeviationThreshold.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<CurrencyDeviationThreshold>, I>>(object: I): CurrencyDeviationThreshold {
    const message = createBaseCurrencyDeviationThreshold();
    message.baseDenom = object.baseDenom ?? "";
    message.threshold = object.threshold ?? "";
    return message;
  },
};

function createBaseParamUpdatePlan(): ParamUpdatePlan {
  return { keys: [], height: 0n, changes: undefined };
}

export const ParamUpdatePlan: MessageFns<ParamUpdatePlan> = {
  encode(message: ParamUpdatePlan, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.keys) {
      writer.uint32(10).string(v!);
    }
    if (message.height !== 0n) {
      if (BigInt.asIntN(64, message.height) !== message.height) {
        throw new globalThis.Error("value provided for field message.height of type int64 too large");
      }
      writer.uint32(16).int64(message.height);
    }
    if (message.changes !== undefined) {
      Params.encode(message.changes, writer.uint32(26).fork()).join();
    }
    return writer;
  },

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

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

          message.height = reader.int64() as bigint;
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

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

  fromJSON(object: any): ParamUpdatePlan {
    return {
      keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e: any) => globalThis.String(e)) : [],
      height: isSet(object.height) ? BigInt(object.height) : 0n,
      changes: isSet(object.changes) ? Params.fromJSON(object.changes) : undefined,
    };
  },

  toJSON(message: ParamUpdatePlan): unknown {
    const obj: any = {};
    if (message.keys?.length) {
      obj.keys = message.keys;
    }
    if (message.height !== 0n) {
      obj.height = message.height.toString();
    }
    if (message.changes !== undefined) {
      obj.changes = Params.toJSON(message.changes);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ParamUpdatePlan>, I>>(base?: I): ParamUpdatePlan {
    return ParamUpdatePlan.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ParamUpdatePlan>, I>>(object: I): ParamUpdatePlan {
    const message = createBaseParamUpdatePlan();
    message.keys = object.keys?.map((e) => e) || [];
    message.height = object.height ?? 0n;
    message.changes = (object.changes !== undefined && object.changes !== null)
      ? Params.fromPartial(object.changes)
      : undefined;
    return message;
  },
};

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;
}