injectivejs 1.4.0 → 1.6.0

package/injective/oracle/v1beta1/oracle.d.ts

@@ -0,0 +1,958 @@
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+export declare enum OracleType {
+    Unspecified = 0,
+    Band = 1,
+    PriceFeed = 2,
+    Coinbase = 3,
+    Chainlink = 4,
+    Razor = 5,
+    Dia = 6,
+    API3 = 7,
+    Uma = 8,
+    Pyth = 9,
+    BandIBC = 10,
+    Provider = 11,
+    Stork = 12,
+    UNRECOGNIZED = -1
+}
+export declare const OracleTypeAmino: typeof OracleType;
+export declare function oracleTypeFromJSON(object: any): OracleType;
+export declare function oracleTypeToJSON(object: OracleType): string;
+export interface Params {
+    pythContract: string;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.Params";
+    value: Uint8Array;
+}
+export interface ParamsAmino {
+    pyth_contract: string;
+}
+export interface ParamsAminoMsg {
+    type: "oracle/Params";
+    value: ParamsAmino;
+}
+export interface OracleInfo {
+    symbol: string;
+    oracleType: OracleType;
+}
+export interface OracleInfoProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.OracleInfo";
+    value: Uint8Array;
+}
+export interface OracleInfoAmino {
+    symbol: string;
+    oracle_type: OracleType;
+}
+export interface OracleInfoAminoMsg {
+    type: "/injective.oracle.v1beta1.OracleInfo";
+    value: OracleInfoAmino;
+}
+export interface ChainlinkPriceState {
+    feedId: string;
+    answer: string;
+    timestamp: bigint;
+    priceState: PriceState;
+}
+export interface ChainlinkPriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.ChainlinkPriceState";
+    value: Uint8Array;
+}
+export interface ChainlinkPriceStateAmino {
+    feed_id: string;
+    answer: string;
+    timestamp: string;
+    price_state: PriceStateAmino;
+}
+export interface ChainlinkPriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.ChainlinkPriceState";
+    value: ChainlinkPriceStateAmino;
+}
+export interface BandPriceState {
+    symbol: string;
+    rate: string;
+    resolveTime: bigint;
+    requestID: bigint;
+    priceState: PriceState;
+}
+export interface BandPriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.BandPriceState";
+    value: Uint8Array;
+}
+export interface BandPriceStateAmino {
+    symbol: string;
+    rate: string;
+    resolve_time: string;
+    request_ID: string;
+    price_state: PriceStateAmino;
+}
+export interface BandPriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.BandPriceState";
+    value: BandPriceStateAmino;
+}
+export interface PriceFeedState {
+    base: string;
+    quote: string;
+    priceState?: PriceState;
+    relayers: string[];
+}
+export interface PriceFeedStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceFeedState";
+    value: Uint8Array;
+}
+export interface PriceFeedStateAmino {
+    base: string;
+    quote: string;
+    price_state?: PriceStateAmino;
+    relayers: string[];
+}
+export interface PriceFeedStateAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceFeedState";
+    value: PriceFeedStateAmino;
+}
+export interface ProviderInfo {
+    provider: string;
+    relayers: string[];
+}
+export interface ProviderInfoProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.ProviderInfo";
+    value: Uint8Array;
+}
+export interface ProviderInfoAmino {
+    provider: string;
+    relayers: string[];
+}
+export interface ProviderInfoAminoMsg {
+    type: "/injective.oracle.v1beta1.ProviderInfo";
+    value: ProviderInfoAmino;
+}
+export interface ProviderState {
+    providerInfo?: ProviderInfo;
+    providerPriceStates: ProviderPriceState[];
+}
+export interface ProviderStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.ProviderState";
+    value: Uint8Array;
+}
+export interface ProviderStateAmino {
+    provider_info?: ProviderInfoAmino;
+    provider_price_states: ProviderPriceStateAmino[];
+}
+export interface ProviderStateAminoMsg {
+    type: "/injective.oracle.v1beta1.ProviderState";
+    value: ProviderStateAmino;
+}
+export interface ProviderPriceState {
+    symbol: string;
+    state?: PriceState;
+}
+export interface ProviderPriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.ProviderPriceState";
+    value: Uint8Array;
+}
+export interface ProviderPriceStateAmino {
+    symbol: string;
+    state?: PriceStateAmino;
+}
+export interface ProviderPriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.ProviderPriceState";
+    value: ProviderPriceStateAmino;
+}
+export interface PriceFeedInfo {
+    base: string;
+    quote: string;
+}
+export interface PriceFeedInfoProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceFeedInfo";
+    value: Uint8Array;
+}
+export interface PriceFeedInfoAmino {
+    base: string;
+    quote: string;
+}
+export interface PriceFeedInfoAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceFeedInfo";
+    value: PriceFeedInfoAmino;
+}
+export interface PriceFeedPrice {
+    price: string;
+}
+export interface PriceFeedPriceProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceFeedPrice";
+    value: Uint8Array;
+}
+export interface PriceFeedPriceAmino {
+    price: string;
+}
+export interface PriceFeedPriceAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceFeedPrice";
+    value: PriceFeedPriceAmino;
+}
+export interface CoinbasePriceState {
+    /** kind should always be "prices" */
+    kind: string;
+    /** timestamp of the when the price was signed by coinbase */
+    timestamp: bigint;
+    /** the symbol of the price, e.g. BTC */
+    key: string;
+    /** the value of the price scaled by 1e6 */
+    value: bigint;
+    /** the price state */
+    priceState: PriceState;
+}
+export interface CoinbasePriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.CoinbasePriceState";
+    value: Uint8Array;
+}
+export interface CoinbasePriceStateAmino {
+    /** kind should always be "prices" */
+    kind: string;
+    /** timestamp of the when the price was signed by coinbase */
+    timestamp: string;
+    /** the symbol of the price, e.g. BTC */
+    key: string;
+    /** the value of the price scaled by 1e6 */
+    value: string;
+    /** the price state */
+    price_state: PriceStateAmino;
+}
+export interface CoinbasePriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.CoinbasePriceState";
+    value: CoinbasePriceStateAmino;
+}
+export interface StorkPriceState {
+    /** timestamp of the when the price was signed by stork */
+    timestamp: bigint;
+    /** the symbol of the price, e.g. BTC */
+    symbol: string;
+    /** the value of the price scaled by 1e18 */
+    value: string;
+    /** the price state */
+    priceState: PriceState;
+}
+export interface StorkPriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.StorkPriceState";
+    value: Uint8Array;
+}
+export interface StorkPriceStateAmino {
+    /** timestamp of the when the price was signed by stork */
+    timestamp: string;
+    /** the symbol of the price, e.g. BTC */
+    symbol: string;
+    /** the value of the price scaled by 1e18 */
+    value: string;
+    /** the price state */
+    price_state: PriceStateAmino;
+}
+export interface StorkPriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.StorkPriceState";
+    value: StorkPriceStateAmino;
+}
+export interface PriceState {
+    price: string;
+    cumulativePrice: string;
+    timestamp: bigint;
+}
+export interface PriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceState";
+    value: Uint8Array;
+}
+export interface PriceStateAmino {
+    price: string;
+    cumulative_price: string;
+    timestamp: string;
+}
+export interface PriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceState";
+    value: PriceStateAmino;
+}
+export interface PythPriceState {
+    priceId: string;
+    emaPrice: string;
+    emaConf: string;
+    conf: string;
+    publishTime: bigint;
+    priceState: PriceState;
+}
+export interface PythPriceStateProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PythPriceState";
+    value: Uint8Array;
+}
+export interface PythPriceStateAmino {
+    price_id: string;
+    ema_price: string;
+    ema_conf: string;
+    conf: string;
+    publish_time: string;
+    price_state: PriceStateAmino;
+}
+export interface PythPriceStateAminoMsg {
+    type: "/injective.oracle.v1beta1.PythPriceState";
+    value: PythPriceStateAmino;
+}
+export interface BandOracleRequest {
+    /** Unique Identifier for band ibc oracle request */
+    requestId: bigint;
+    /**
+     * OracleScriptID is the unique identifier of the oracle script to be
+     * executed.
+     */
+    oracleScriptId: bigint;
+    /** Symbols is the list of symbols to prepare in the calldata */
+    symbols: string[];
+    /**
+     * AskCount is the number of validators that are requested to respond to this
+     * oracle request. Higher value means more security, at a higher gas cost.
+     */
+    askCount: bigint;
+    /**
+     * MinCount is the minimum number of validators necessary for the request to
+     * proceed to the execution phase. Higher value means more security, at the
+     * cost of liveness.
+     */
+    minCount: bigint;
+    /**
+     * FeeLimit is the maximum tokens that will be paid to all data source
+     * providers.
+     */
+    feeLimit: Coin[];
+    /** PrepareGas is amount of gas to pay to prepare raw requests */
+    prepareGas: bigint;
+    /** ExecuteGas is amount of gas to reserve for executing */
+    executeGas: bigint;
+    /**
+     * MinSourceCount is the minimum number of data sources that must be used by
+     * each validator
+     */
+    minSourceCount: bigint;
+}
+export interface BandOracleRequestProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.BandOracleRequest";
+    value: Uint8Array;
+}
+export interface BandOracleRequestAmino {
+    /** Unique Identifier for band ibc oracle request */
+    request_id: string;
+    /**
+     * OracleScriptID is the unique identifier of the oracle script to be
+     * executed.
+     */
+    oracle_script_id: string;
+    /** Symbols is the list of symbols to prepare in the calldata */
+    symbols: string[];
+    /**
+     * AskCount is the number of validators that are requested to respond to this
+     * oracle request. Higher value means more security, at a higher gas cost.
+     */
+    ask_count: string;
+    /**
+     * MinCount is the minimum number of validators necessary for the request to
+     * proceed to the execution phase. Higher value means more security, at the
+     * cost of liveness.
+     */
+    min_count: string;
+    /**
+     * FeeLimit is the maximum tokens that will be paid to all data source
+     * providers.
+     */
+    fee_limit: CoinAmino[];
+    /** PrepareGas is amount of gas to pay to prepare raw requests */
+    prepare_gas: string;
+    /** ExecuteGas is amount of gas to reserve for executing */
+    execute_gas: string;
+    /**
+     * MinSourceCount is the minimum number of data sources that must be used by
+     * each validator
+     */
+    min_source_count: string;
+}
+export interface BandOracleRequestAminoMsg {
+    type: "/injective.oracle.v1beta1.BandOracleRequest";
+    value: BandOracleRequestAmino;
+}
+export interface BandIBCParams {
+    /** true if Band IBC should be enabled */
+    bandIbcEnabled: boolean;
+    /** block request interval to send Band IBC prices */
+    ibcRequestInterval: bigint;
+    /** band IBC source channel */
+    ibcSourceChannel: string;
+    /** band IBC version */
+    ibcVersion: string;
+    /** band IBC portID */
+    ibcPortId: string;
+    /** legacy oracle scheme ids */
+    legacyOracleIds: bigint[];
+}
+export interface BandIBCParamsProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.BandIBCParams";
+    value: Uint8Array;
+}
+export interface BandIBCParamsAmino {
+    /** true if Band IBC should be enabled */
+    band_ibc_enabled: boolean;
+    /** block request interval to send Band IBC prices */
+    ibc_request_interval: string;
+    /** band IBC source channel */
+    ibc_source_channel: string;
+    /** band IBC version */
+    ibc_version: string;
+    /** band IBC portID */
+    ibc_port_id: string;
+    /** legacy oracle scheme ids */
+    legacy_oracle_ids: string[];
+}
+export interface BandIBCParamsAminoMsg {
+    type: "/injective.oracle.v1beta1.BandIBCParams";
+    value: BandIBCParamsAmino;
+}
+export interface SymbolPriceTimestamp {
+    oracle: OracleType;
+    symbolId: string;
+    timestamp: bigint;
+}
+export interface SymbolPriceTimestampProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.SymbolPriceTimestamp";
+    value: Uint8Array;
+}
+export interface SymbolPriceTimestampAmino {
+    oracle: OracleType;
+    symbol_id: string;
+    timestamp: string;
+}
+export interface SymbolPriceTimestampAminoMsg {
+    type: "/injective.oracle.v1beta1.SymbolPriceTimestamp";
+    value: SymbolPriceTimestampAmino;
+}
+export interface LastPriceTimestamps {
+    lastPriceTimestamps: SymbolPriceTimestamp[];
+}
+export interface LastPriceTimestampsProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.LastPriceTimestamps";
+    value: Uint8Array;
+}
+export interface LastPriceTimestampsAmino {
+    last_price_timestamps: SymbolPriceTimestampAmino[];
+}
+export interface LastPriceTimestampsAminoMsg {
+    type: "/injective.oracle.v1beta1.LastPriceTimestamps";
+    value: LastPriceTimestampsAmino;
+}
+export interface PriceRecords {
+    oracle: OracleType;
+    symbolId: string;
+    latestPriceRecords: PriceRecord[];
+}
+export interface PriceRecordsProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceRecords";
+    value: Uint8Array;
+}
+export interface PriceRecordsAmino {
+    oracle: OracleType;
+    symbol_id: string;
+    latest_price_records: PriceRecordAmino[];
+}
+export interface PriceRecordsAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceRecords";
+    value: PriceRecordsAmino;
+}
+export interface PriceRecord {
+    timestamp: bigint;
+    price: string;
+}
+export interface PriceRecordProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceRecord";
+    value: Uint8Array;
+}
+export interface PriceRecordAmino {
+    timestamp: string;
+    price: string;
+}
+export interface PriceRecordAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceRecord";
+    value: PriceRecordAmino;
+}
+/**
+ * MetadataStatistics refers to the metadata summary statistics of the
+ * historical sample considered
+ */
+export interface MetadataStatistics {
+    /**
+     * GroupCount refers to the number of groups used. Equals RecordsSampleSize if
+     * no grouping is used
+     */
+    groupCount: number;
+    /** RecordsSampleSize refers to the total number of records used. */
+    recordsSampleSize: number;
+    /**
+     * Mean refers to the arithmetic mean
+     * For trades, the mean is the VWAP computed over the grouped trade records ∑
+     * (price * quantity) / ∑ quantity For oracle prices, the mean is computed
+     * over the price records ∑ (price) / prices_count
+     */
+    mean: string;
+    /**
+     * TWAP refers to the time-weighted average price which equals ∑ (price_i *
+     * ∆t_i) / ∑ ∆t_i where ∆t_i = t_i - t_{i-1}
+     */
+    twap: string;
+    /** FirstTimestamp is the timestamp of the oldest record considered */
+    firstTimestamp: bigint;
+    /** LastTimestamp is the timestamp of the youngest record considered */
+    lastTimestamp: bigint;
+    /** MinPrice refers to the smallest individual raw price considered */
+    minPrice: string;
+    /** MaxPrice refers to the largest individual raw price considered */
+    maxPrice: string;
+    /** MedianPrice refers to the median individual raw price considered */
+    medianPrice: string;
+}
+export interface MetadataStatisticsProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.MetadataStatistics";
+    value: Uint8Array;
+}
+/**
+ * MetadataStatistics refers to the metadata summary statistics of the
+ * historical sample considered
+ */
+export interface MetadataStatisticsAmino {
+    /**
+     * GroupCount refers to the number of groups used. Equals RecordsSampleSize if
+     * no grouping is used
+     */
+    group_count: number;
+    /** RecordsSampleSize refers to the total number of records used. */
+    records_sample_size: number;
+    /**
+     * Mean refers to the arithmetic mean
+     * For trades, the mean is the VWAP computed over the grouped trade records ∑
+     * (price * quantity) / ∑ quantity For oracle prices, the mean is computed
+     * over the price records ∑ (price) / prices_count
+     */
+    mean: string;
+    /**
+     * TWAP refers to the time-weighted average price which equals ∑ (price_i *
+     * ∆t_i) / ∑ ∆t_i where ∆t_i = t_i - t_{i-1}
+     */
+    twap: string;
+    /** FirstTimestamp is the timestamp of the oldest record considered */
+    first_timestamp: string;
+    /** LastTimestamp is the timestamp of the youngest record considered */
+    last_timestamp: string;
+    /** MinPrice refers to the smallest individual raw price considered */
+    min_price: string;
+    /** MaxPrice refers to the largest individual raw price considered */
+    max_price: string;
+    /** MedianPrice refers to the median individual raw price considered */
+    median_price: string;
+}
+export interface MetadataStatisticsAminoMsg {
+    type: "/injective.oracle.v1beta1.MetadataStatistics";
+    value: MetadataStatisticsAmino;
+}
+export interface PriceAttestation {
+    priceId: string;
+    /** MaxPrice refers to the largest individual raw price considered */
+    price: bigint;
+    conf: bigint;
+    expo: number;
+    emaPrice: bigint;
+    emaConf: bigint;
+    emaExpo: number;
+    publishTime: bigint;
+}
+export interface PriceAttestationProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.PriceAttestation";
+    value: Uint8Array;
+}
+export interface PriceAttestationAmino {
+    price_id: string;
+    /** MaxPrice refers to the largest individual raw price considered */
+    price: string;
+    conf: string;
+    expo: number;
+    ema_price: string;
+    ema_conf: string;
+    ema_expo: number;
+    publish_time: string;
+}
+export interface PriceAttestationAminoMsg {
+    type: "/injective.oracle.v1beta1.PriceAttestation";
+    value: PriceAttestationAmino;
+}
+export interface AssetPair {
+    assetId: string;
+    signedPrices: SignedPriceOfAssetPair[];
+}
+export interface AssetPairProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.AssetPair";
+    value: Uint8Array;
+}
+export interface AssetPairAmino {
+    asset_id: string;
+    signed_prices: SignedPriceOfAssetPairAmino[];
+}
+export interface AssetPairAminoMsg {
+    type: "/injective.oracle.v1beta1.AssetPair";
+    value: AssetPairAmino;
+}
+export interface SignedPriceOfAssetPair {
+    publisherKey: string;
+    timestamp: bigint;
+    price: string;
+    signature: Uint8Array;
+}
+export interface SignedPriceOfAssetPairProtoMsg {
+    typeUrl: "/injective.oracle.v1beta1.SignedPriceOfAssetPair";
+    value: Uint8Array;
+}
+export interface SignedPriceOfAssetPairAmino {
+    publisher_key: string;
+    timestamp: string;
+    price: string;
+    signature: string;
+}
+export interface SignedPriceOfAssetPairAminoMsg {
+    type: "/injective.oracle.v1beta1.SignedPriceOfAssetPair";
+    value: SignedPriceOfAssetPairAmino;
+}
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Params;
+    isAmino(o: any): o is ParamsAmino;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};
+export declare const OracleInfo: {
+    typeUrl: string;
+    is(o: any): o is OracleInfo;
+    isAmino(o: any): o is OracleInfoAmino;
+    encode(message: OracleInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OracleInfo;
+    fromPartial(object: DeepPartial<OracleInfo>): OracleInfo;
+    fromAmino(object: OracleInfoAmino): OracleInfo;
+    toAmino(message: OracleInfo): OracleInfoAmino;
+    fromAminoMsg(object: OracleInfoAminoMsg): OracleInfo;
+    fromProtoMsg(message: OracleInfoProtoMsg): OracleInfo;
+    toProto(message: OracleInfo): Uint8Array;
+    toProtoMsg(message: OracleInfo): OracleInfoProtoMsg;
+};
+export declare const ChainlinkPriceState: {
+    typeUrl: string;
+    is(o: any): o is ChainlinkPriceState;
+    isAmino(o: any): o is ChainlinkPriceStateAmino;
+    encode(message: ChainlinkPriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ChainlinkPriceState;
+    fromPartial(object: DeepPartial<ChainlinkPriceState>): ChainlinkPriceState;
+    fromAmino(object: ChainlinkPriceStateAmino): ChainlinkPriceState;
+    toAmino(message: ChainlinkPriceState): ChainlinkPriceStateAmino;
+    fromAminoMsg(object: ChainlinkPriceStateAminoMsg): ChainlinkPriceState;
+    fromProtoMsg(message: ChainlinkPriceStateProtoMsg): ChainlinkPriceState;
+    toProto(message: ChainlinkPriceState): Uint8Array;
+    toProtoMsg(message: ChainlinkPriceState): ChainlinkPriceStateProtoMsg;
+};
+export declare const BandPriceState: {
+    typeUrl: string;
+    is(o: any): o is BandPriceState;
+    isAmino(o: any): o is BandPriceStateAmino;
+    encode(message: BandPriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BandPriceState;
+    fromPartial(object: DeepPartial<BandPriceState>): BandPriceState;
+    fromAmino(object: BandPriceStateAmino): BandPriceState;
+    toAmino(message: BandPriceState): BandPriceStateAmino;
+    fromAminoMsg(object: BandPriceStateAminoMsg): BandPriceState;
+    fromProtoMsg(message: BandPriceStateProtoMsg): BandPriceState;
+    toProto(message: BandPriceState): Uint8Array;
+    toProtoMsg(message: BandPriceState): BandPriceStateProtoMsg;
+};
+export declare const PriceFeedState: {
+    typeUrl: string;
+    is(o: any): o is PriceFeedState;
+    isAmino(o: any): o is PriceFeedStateAmino;
+    encode(message: PriceFeedState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceFeedState;
+    fromPartial(object: DeepPartial<PriceFeedState>): PriceFeedState;
+    fromAmino(object: PriceFeedStateAmino): PriceFeedState;
+    toAmino(message: PriceFeedState): PriceFeedStateAmino;
+    fromAminoMsg(object: PriceFeedStateAminoMsg): PriceFeedState;
+    fromProtoMsg(message: PriceFeedStateProtoMsg): PriceFeedState;
+    toProto(message: PriceFeedState): Uint8Array;
+    toProtoMsg(message: PriceFeedState): PriceFeedStateProtoMsg;
+};
+export declare const ProviderInfo: {
+    typeUrl: string;
+    is(o: any): o is ProviderInfo;
+    isAmino(o: any): o is ProviderInfoAmino;
+    encode(message: ProviderInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ProviderInfo;
+    fromPartial(object: DeepPartial<ProviderInfo>): ProviderInfo;
+    fromAmino(object: ProviderInfoAmino): ProviderInfo;
+    toAmino(message: ProviderInfo): ProviderInfoAmino;
+    fromAminoMsg(object: ProviderInfoAminoMsg): ProviderInfo;
+    fromProtoMsg(message: ProviderInfoProtoMsg): ProviderInfo;
+    toProto(message: ProviderInfo): Uint8Array;
+    toProtoMsg(message: ProviderInfo): ProviderInfoProtoMsg;
+};
+export declare const ProviderState: {
+    typeUrl: string;
+    is(o: any): o is ProviderState;
+    isAmino(o: any): o is ProviderStateAmino;
+    encode(message: ProviderState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ProviderState;
+    fromPartial(object: DeepPartial<ProviderState>): ProviderState;
+    fromAmino(object: ProviderStateAmino): ProviderState;
+    toAmino(message: ProviderState): ProviderStateAmino;
+    fromAminoMsg(object: ProviderStateAminoMsg): ProviderState;
+    fromProtoMsg(message: ProviderStateProtoMsg): ProviderState;
+    toProto(message: ProviderState): Uint8Array;
+    toProtoMsg(message: ProviderState): ProviderStateProtoMsg;
+};
+export declare const ProviderPriceState: {
+    typeUrl: string;
+    is(o: any): o is ProviderPriceState;
+    isAmino(o: any): o is ProviderPriceStateAmino;
+    encode(message: ProviderPriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ProviderPriceState;
+    fromPartial(object: DeepPartial<ProviderPriceState>): ProviderPriceState;
+    fromAmino(object: ProviderPriceStateAmino): ProviderPriceState;
+    toAmino(message: ProviderPriceState): ProviderPriceStateAmino;
+    fromAminoMsg(object: ProviderPriceStateAminoMsg): ProviderPriceState;
+    fromProtoMsg(message: ProviderPriceStateProtoMsg): ProviderPriceState;
+    toProto(message: ProviderPriceState): Uint8Array;
+    toProtoMsg(message: ProviderPriceState): ProviderPriceStateProtoMsg;
+};
+export declare const PriceFeedInfo: {
+    typeUrl: string;
+    is(o: any): o is PriceFeedInfo;
+    isAmino(o: any): o is PriceFeedInfoAmino;
+    encode(message: PriceFeedInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceFeedInfo;
+    fromPartial(object: DeepPartial<PriceFeedInfo>): PriceFeedInfo;
+    fromAmino(object: PriceFeedInfoAmino): PriceFeedInfo;
+    toAmino(message: PriceFeedInfo): PriceFeedInfoAmino;
+    fromAminoMsg(object: PriceFeedInfoAminoMsg): PriceFeedInfo;
+    fromProtoMsg(message: PriceFeedInfoProtoMsg): PriceFeedInfo;
+    toProto(message: PriceFeedInfo): Uint8Array;
+    toProtoMsg(message: PriceFeedInfo): PriceFeedInfoProtoMsg;
+};
+export declare const PriceFeedPrice: {
+    typeUrl: string;
+    is(o: any): o is PriceFeedPrice;
+    isAmino(o: any): o is PriceFeedPriceAmino;
+    encode(message: PriceFeedPrice, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceFeedPrice;
+    fromPartial(object: DeepPartial<PriceFeedPrice>): PriceFeedPrice;
+    fromAmino(object: PriceFeedPriceAmino): PriceFeedPrice;
+    toAmino(message: PriceFeedPrice): PriceFeedPriceAmino;
+    fromAminoMsg(object: PriceFeedPriceAminoMsg): PriceFeedPrice;
+    fromProtoMsg(message: PriceFeedPriceProtoMsg): PriceFeedPrice;
+    toProto(message: PriceFeedPrice): Uint8Array;
+    toProtoMsg(message: PriceFeedPrice): PriceFeedPriceProtoMsg;
+};
+export declare const CoinbasePriceState: {
+    typeUrl: string;
+    is(o: any): o is CoinbasePriceState;
+    isAmino(o: any): o is CoinbasePriceStateAmino;
+    encode(message: CoinbasePriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CoinbasePriceState;
+    fromPartial(object: DeepPartial<CoinbasePriceState>): CoinbasePriceState;
+    fromAmino(object: CoinbasePriceStateAmino): CoinbasePriceState;
+    toAmino(message: CoinbasePriceState): CoinbasePriceStateAmino;
+    fromAminoMsg(object: CoinbasePriceStateAminoMsg): CoinbasePriceState;
+    fromProtoMsg(message: CoinbasePriceStateProtoMsg): CoinbasePriceState;
+    toProto(message: CoinbasePriceState): Uint8Array;
+    toProtoMsg(message: CoinbasePriceState): CoinbasePriceStateProtoMsg;
+};
+export declare const StorkPriceState: {
+    typeUrl: string;
+    is(o: any): o is StorkPriceState;
+    isAmino(o: any): o is StorkPriceStateAmino;
+    encode(message: StorkPriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): StorkPriceState;
+    fromPartial(object: DeepPartial<StorkPriceState>): StorkPriceState;
+    fromAmino(object: StorkPriceStateAmino): StorkPriceState;
+    toAmino(message: StorkPriceState): StorkPriceStateAmino;
+    fromAminoMsg(object: StorkPriceStateAminoMsg): StorkPriceState;
+    fromProtoMsg(message: StorkPriceStateProtoMsg): StorkPriceState;
+    toProto(message: StorkPriceState): Uint8Array;
+    toProtoMsg(message: StorkPriceState): StorkPriceStateProtoMsg;
+};
+export declare const PriceState: {
+    typeUrl: string;
+    is(o: any): o is PriceState;
+    isAmino(o: any): o is PriceStateAmino;
+    encode(message: PriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceState;
+    fromPartial(object: DeepPartial<PriceState>): PriceState;
+    fromAmino(object: PriceStateAmino): PriceState;
+    toAmino(message: PriceState): PriceStateAmino;
+    fromAminoMsg(object: PriceStateAminoMsg): PriceState;
+    fromProtoMsg(message: PriceStateProtoMsg): PriceState;
+    toProto(message: PriceState): Uint8Array;
+    toProtoMsg(message: PriceState): PriceStateProtoMsg;
+};
+export declare const PythPriceState: {
+    typeUrl: string;
+    is(o: any): o is PythPriceState;
+    isAmino(o: any): o is PythPriceStateAmino;
+    encode(message: PythPriceState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PythPriceState;
+    fromPartial(object: DeepPartial<PythPriceState>): PythPriceState;
+    fromAmino(object: PythPriceStateAmino): PythPriceState;
+    toAmino(message: PythPriceState): PythPriceStateAmino;
+    fromAminoMsg(object: PythPriceStateAminoMsg): PythPriceState;
+    fromProtoMsg(message: PythPriceStateProtoMsg): PythPriceState;
+    toProto(message: PythPriceState): Uint8Array;
+    toProtoMsg(message: PythPriceState): PythPriceStateProtoMsg;
+};
+export declare const BandOracleRequest: {
+    typeUrl: string;
+    is(o: any): o is BandOracleRequest;
+    isAmino(o: any): o is BandOracleRequestAmino;
+    encode(message: BandOracleRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BandOracleRequest;
+    fromPartial(object: DeepPartial<BandOracleRequest>): BandOracleRequest;
+    fromAmino(object: BandOracleRequestAmino): BandOracleRequest;
+    toAmino(message: BandOracleRequest): BandOracleRequestAmino;
+    fromAminoMsg(object: BandOracleRequestAminoMsg): BandOracleRequest;
+    fromProtoMsg(message: BandOracleRequestProtoMsg): BandOracleRequest;
+    toProto(message: BandOracleRequest): Uint8Array;
+    toProtoMsg(message: BandOracleRequest): BandOracleRequestProtoMsg;
+};
+export declare const BandIBCParams: {
+    typeUrl: string;
+    is(o: any): o is BandIBCParams;
+    isAmino(o: any): o is BandIBCParamsAmino;
+    encode(message: BandIBCParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BandIBCParams;
+    fromPartial(object: DeepPartial<BandIBCParams>): BandIBCParams;
+    fromAmino(object: BandIBCParamsAmino): BandIBCParams;
+    toAmino(message: BandIBCParams): BandIBCParamsAmino;
+    fromAminoMsg(object: BandIBCParamsAminoMsg): BandIBCParams;
+    fromProtoMsg(message: BandIBCParamsProtoMsg): BandIBCParams;
+    toProto(message: BandIBCParams): Uint8Array;
+    toProtoMsg(message: BandIBCParams): BandIBCParamsProtoMsg;
+};
+export declare const SymbolPriceTimestamp: {
+    typeUrl: string;
+    is(o: any): o is SymbolPriceTimestamp;
+    isAmino(o: any): o is SymbolPriceTimestampAmino;
+    encode(message: SymbolPriceTimestamp, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SymbolPriceTimestamp;
+    fromPartial(object: DeepPartial<SymbolPriceTimestamp>): SymbolPriceTimestamp;
+    fromAmino(object: SymbolPriceTimestampAmino): SymbolPriceTimestamp;
+    toAmino(message: SymbolPriceTimestamp): SymbolPriceTimestampAmino;
+    fromAminoMsg(object: SymbolPriceTimestampAminoMsg): SymbolPriceTimestamp;
+    fromProtoMsg(message: SymbolPriceTimestampProtoMsg): SymbolPriceTimestamp;
+    toProto(message: SymbolPriceTimestamp): Uint8Array;
+    toProtoMsg(message: SymbolPriceTimestamp): SymbolPriceTimestampProtoMsg;
+};
+export declare const LastPriceTimestamps: {
+    typeUrl: string;
+    is(o: any): o is LastPriceTimestamps;
+    isAmino(o: any): o is LastPriceTimestampsAmino;
+    encode(message: LastPriceTimestamps, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): LastPriceTimestamps;
+    fromPartial(object: DeepPartial<LastPriceTimestamps>): LastPriceTimestamps;
+    fromAmino(object: LastPriceTimestampsAmino): LastPriceTimestamps;
+    toAmino(message: LastPriceTimestamps): LastPriceTimestampsAmino;
+    fromAminoMsg(object: LastPriceTimestampsAminoMsg): LastPriceTimestamps;
+    fromProtoMsg(message: LastPriceTimestampsProtoMsg): LastPriceTimestamps;
+    toProto(message: LastPriceTimestamps): Uint8Array;
+    toProtoMsg(message: LastPriceTimestamps): LastPriceTimestampsProtoMsg;
+};
+export declare const PriceRecords: {
+    typeUrl: string;
+    is(o: any): o is PriceRecords;
+    isAmino(o: any): o is PriceRecordsAmino;
+    encode(message: PriceRecords, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceRecords;
+    fromPartial(object: DeepPartial<PriceRecords>): PriceRecords;
+    fromAmino(object: PriceRecordsAmino): PriceRecords;
+    toAmino(message: PriceRecords): PriceRecordsAmino;
+    fromAminoMsg(object: PriceRecordsAminoMsg): PriceRecords;
+    fromProtoMsg(message: PriceRecordsProtoMsg): PriceRecords;
+    toProto(message: PriceRecords): Uint8Array;
+    toProtoMsg(message: PriceRecords): PriceRecordsProtoMsg;
+};
+export declare const PriceRecord: {
+    typeUrl: string;
+    is(o: any): o is PriceRecord;
+    isAmino(o: any): o is PriceRecordAmino;
+    encode(message: PriceRecord, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceRecord;
+    fromPartial(object: DeepPartial<PriceRecord>): PriceRecord;
+    fromAmino(object: PriceRecordAmino): PriceRecord;
+    toAmino(message: PriceRecord): PriceRecordAmino;
+    fromAminoMsg(object: PriceRecordAminoMsg): PriceRecord;
+    fromProtoMsg(message: PriceRecordProtoMsg): PriceRecord;
+    toProto(message: PriceRecord): Uint8Array;
+    toProtoMsg(message: PriceRecord): PriceRecordProtoMsg;
+};
+export declare const MetadataStatistics: {
+    typeUrl: string;
+    is(o: any): o is MetadataStatistics;
+    isAmino(o: any): o is MetadataStatisticsAmino;
+    encode(message: MetadataStatistics, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MetadataStatistics;
+    fromPartial(object: DeepPartial<MetadataStatistics>): MetadataStatistics;
+    fromAmino(object: MetadataStatisticsAmino): MetadataStatistics;
+    toAmino(message: MetadataStatistics): MetadataStatisticsAmino;
+    fromAminoMsg(object: MetadataStatisticsAminoMsg): MetadataStatistics;
+    fromProtoMsg(message: MetadataStatisticsProtoMsg): MetadataStatistics;
+    toProto(message: MetadataStatistics): Uint8Array;
+    toProtoMsg(message: MetadataStatistics): MetadataStatisticsProtoMsg;
+};
+export declare const PriceAttestation: {
+    typeUrl: string;
+    is(o: any): o is PriceAttestation;
+    isAmino(o: any): o is PriceAttestationAmino;
+    encode(message: PriceAttestation, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PriceAttestation;
+    fromPartial(object: DeepPartial<PriceAttestation>): PriceAttestation;
+    fromAmino(object: PriceAttestationAmino): PriceAttestation;
+    toAmino(message: PriceAttestation): PriceAttestationAmino;
+    fromAminoMsg(object: PriceAttestationAminoMsg): PriceAttestation;
+    fromProtoMsg(message: PriceAttestationProtoMsg): PriceAttestation;
+    toProto(message: PriceAttestation): Uint8Array;
+    toProtoMsg(message: PriceAttestation): PriceAttestationProtoMsg;
+};
+export declare const AssetPair: {
+    typeUrl: string;
+    is(o: any): o is AssetPair;
+    isAmino(o: any): o is AssetPairAmino;
+    encode(message: AssetPair, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AssetPair;
+    fromPartial(object: DeepPartial<AssetPair>): AssetPair;
+    fromAmino(object: AssetPairAmino): AssetPair;
+    toAmino(message: AssetPair): AssetPairAmino;
+    fromAminoMsg(object: AssetPairAminoMsg): AssetPair;
+    fromProtoMsg(message: AssetPairProtoMsg): AssetPair;
+    toProto(message: AssetPair): Uint8Array;
+    toProtoMsg(message: AssetPair): AssetPairProtoMsg;
+};
+export declare const SignedPriceOfAssetPair: {
+    typeUrl: string;
+    is(o: any): o is SignedPriceOfAssetPair;
+    isAmino(o: any): o is SignedPriceOfAssetPairAmino;
+    encode(message: SignedPriceOfAssetPair, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SignedPriceOfAssetPair;
+    fromPartial(object: DeepPartial<SignedPriceOfAssetPair>): SignedPriceOfAssetPair;
+    fromAmino(object: SignedPriceOfAssetPairAmino): SignedPriceOfAssetPair;
+    toAmino(message: SignedPriceOfAssetPair): SignedPriceOfAssetPairAmino;
+    fromAminoMsg(object: SignedPriceOfAssetPairAminoMsg): SignedPriceOfAssetPair;
+    fromProtoMsg(message: SignedPriceOfAssetPairProtoMsg): SignedPriceOfAssetPair;
+    toProto(message: SignedPriceOfAssetPair): Uint8Array;
+    toProtoMsg(message: SignedPriceOfAssetPair): SignedPriceOfAssetPairProtoMsg;
+};