oracle.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: injective/oracle/v1beta1/oracle.proto

package types

import (
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type OracleType int32

const (
	OracleType_Unspecified OracleType = 0
	OracleType_Band        OracleType = 1
	OracleType_PriceFeed   OracleType = 2
	OracleType_Coinbase    OracleType = 3
	OracleType_Chainlink   OracleType = 4
	OracleType_Razor       OracleType = 5
	OracleType_Dia         OracleType = 6
	OracleType_API3        OracleType = 7
	OracleType_Uma         OracleType = 8
	OracleType_Pyth        OracleType = 9
	OracleType_BandIBC     OracleType = 10
	OracleType_Provider    OracleType = 11
)

var OracleType_name = map[int32]string{
	0:  "Unspecified",
	1:  "Band",
	2:  "PriceFeed",
	3:  "Coinbase",
	4:  "Chainlink",
	5:  "Razor",
	6:  "Dia",
	7:  "API3",
	8:  "Uma",
	9:  "Pyth",
	10: "BandIBC",
	11: "Provider",
}

var OracleType_value = map[string]int32{
	"Unspecified": 0,
	"Band":        1,
	"PriceFeed":   2,
	"Coinbase":    3,
	"Chainlink":   4,
	"Razor":       5,
	"Dia":         6,
	"API3":        7,
	"Uma":         8,
	"Pyth":        9,
	"BandIBC":     10,
	"Provider":    11,
}

func (x OracleType) String() string {
	return proto.EnumName(OracleType_name, int32(x))
}

func (OracleType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{0}
}

type Params struct {
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
	return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

type OracleInfo struct {
	Symbol      string     `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	OracleType  OracleType `protobuf:"varint,2,opt,name=oracle_type,json=oracleType,proto3,enum=injective.oracle.v1beta1.OracleType" json:"oracle_type,omitempty"`
	ScaleFactor uint32     `protobuf:"varint,3,opt,name=scale_factor,json=scaleFactor,proto3" json:"scale_factor,omitempty"`
}

func (m *OracleInfo) Reset()         { *m = OracleInfo{} }
func (m *OracleInfo) String() string { return proto.CompactTextString(m) }
func (*OracleInfo) ProtoMessage()    {}
func (*OracleInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{1}
}
func (m *OracleInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OracleInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OracleInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OracleInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OracleInfo.Merge(m, src)
}
func (m *OracleInfo) XXX_Size() int {
	return m.Size()
}
func (m *OracleInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_OracleInfo.DiscardUnknown(m)
}

var xxx_messageInfo_OracleInfo proto.InternalMessageInfo

func (m *OracleInfo) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *OracleInfo) GetOracleType() OracleType {
	if m != nil {
		return m.OracleType
	}
	return OracleType_Unspecified
}

func (m *OracleInfo) GetScaleFactor() uint32 {
	if m != nil {
		return m.ScaleFactor
	}
	return 0
}

type ChainlinkPriceState struct {
	FeedId     string                                 `protobuf:"bytes,1,opt,name=feed_id,json=feedId,proto3" json:"feed_id,omitempty"`
	Answer     github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=answer,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"answer"`
	Timestamp  uint64                                 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	PriceState PriceState                             `protobuf:"bytes,4,opt,name=price_state,json=priceState,proto3" json:"price_state"`
}

func (m *ChainlinkPriceState) Reset()         { *m = ChainlinkPriceState{} }
func (m *ChainlinkPriceState) String() string { return proto.CompactTextString(m) }
func (*ChainlinkPriceState) ProtoMessage()    {}
func (*ChainlinkPriceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{2}
}
func (m *ChainlinkPriceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChainlinkPriceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChainlinkPriceState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChainlinkPriceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChainlinkPriceState.Merge(m, src)
}
func (m *ChainlinkPriceState) XXX_Size() int {
	return m.Size()
}
func (m *ChainlinkPriceState) XXX_DiscardUnknown() {
	xxx_messageInfo_ChainlinkPriceState.DiscardUnknown(m)
}

var xxx_messageInfo_ChainlinkPriceState proto.InternalMessageInfo

func (m *ChainlinkPriceState) GetFeedId() string {
	if m != nil {
		return m.FeedId
	}
	return ""
}

func (m *ChainlinkPriceState) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *ChainlinkPriceState) GetPriceState() PriceState {
	if m != nil {
		return m.PriceState
	}
	return PriceState{}
}

type BandPriceState struct {
	Symbol      string                                 `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Rate        github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"rate"`
	ResolveTime uint64                                 `protobuf:"varint,3,opt,name=resolve_time,json=resolveTime,proto3" json:"resolve_time,omitempty"`
	Request_ID  uint64                                 `protobuf:"varint,4,opt,name=request_ID,json=requestID,proto3" json:"request_ID,omitempty"`
	PriceState  PriceState                             `protobuf:"bytes,5,opt,name=price_state,json=priceState,proto3" json:"price_state"`
}

func (m *BandPriceState) Reset()         { *m = BandPriceState{} }
func (m *BandPriceState) String() string { return proto.CompactTextString(m) }
func (*BandPriceState) ProtoMessage()    {}
func (*BandPriceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{3}
}
func (m *BandPriceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BandPriceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BandPriceState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BandPriceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BandPriceState.Merge(m, src)
}
func (m *BandPriceState) XXX_Size() int {
	return m.Size()
}
func (m *BandPriceState) XXX_DiscardUnknown() {
	xxx_messageInfo_BandPriceState.DiscardUnknown(m)
}

var xxx_messageInfo_BandPriceState proto.InternalMessageInfo

func (m *BandPriceState) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *BandPriceState) GetResolveTime() uint64 {
	if m != nil {
		return m.ResolveTime
	}
	return 0
}

func (m *BandPriceState) GetRequest_ID() uint64 {
	if m != nil {
		return m.Request_ID
	}
	return 0
}

func (m *BandPriceState) GetPriceState() PriceState {
	if m != nil {
		return m.PriceState
	}
	return PriceState{}
}

type PriceFeedState struct {
	Base       string      `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Quote      string      `protobuf:"bytes,2,opt,name=quote,proto3" json:"quote,omitempty"`
	PriceState *PriceState `protobuf:"bytes,3,opt,name=price_state,json=priceState,proto3" json:"price_state,omitempty"`
	Relayers   []string    `protobuf:"bytes,4,rep,name=relayers,proto3" json:"relayers,omitempty"`
}

func (m *PriceFeedState) Reset()         { *m = PriceFeedState{} }
func (m *PriceFeedState) String() string { return proto.CompactTextString(m) }
func (*PriceFeedState) ProtoMessage()    {}
func (*PriceFeedState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{4}
}
func (m *PriceFeedState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceFeedState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceFeedState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceFeedState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceFeedState.Merge(m, src)
}
func (m *PriceFeedState) XXX_Size() int {
	return m.Size()
}
func (m *PriceFeedState) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceFeedState.DiscardUnknown(m)
}

var xxx_messageInfo_PriceFeedState proto.InternalMessageInfo

func (m *PriceFeedState) GetBase() string {
	if m != nil {
		return m.Base
	}
	return ""
}

func (m *PriceFeedState) GetQuote() string {
	if m != nil {
		return m.Quote
	}
	return ""
}

func (m *PriceFeedState) GetPriceState() *PriceState {
	if m != nil {
		return m.PriceState
	}
	return nil
}

func (m *PriceFeedState) GetRelayers() []string {
	if m != nil {
		return m.Relayers
	}
	return nil
}

type ProviderInfo struct {
	Provider string   `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"`
	Relayers []string `protobuf:"bytes,2,rep,name=relayers,proto3" json:"relayers,omitempty"`
}

func (m *ProviderInfo) Reset()         { *m = ProviderInfo{} }
func (m *ProviderInfo) String() string { return proto.CompactTextString(m) }
func (*ProviderInfo) ProtoMessage()    {}
func (*ProviderInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{5}
}
func (m *ProviderInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProviderInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProviderInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProviderInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProviderInfo.Merge(m, src)
}
func (m *ProviderInfo) XXX_Size() int {
	return m.Size()
}
func (m *ProviderInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ProviderInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ProviderInfo proto.InternalMessageInfo

func (m *ProviderInfo) GetProvider() string {
	if m != nil {
		return m.Provider
	}
	return ""
}

func (m *ProviderInfo) GetRelayers() []string {
	if m != nil {
		return m.Relayers
	}
	return nil
}

type ProviderState struct {
	ProviderInfo        *ProviderInfo         `protobuf:"bytes,1,opt,name=provider_info,json=providerInfo,proto3" json:"provider_info,omitempty"`
	ProviderPriceStates []*ProviderPriceState `protobuf:"bytes,2,rep,name=provider_price_states,json=providerPriceStates,proto3" json:"provider_price_states,omitempty"`
}

func (m *ProviderState) Reset()         { *m = ProviderState{} }
func (m *ProviderState) String() string { return proto.CompactTextString(m) }
func (*ProviderState) ProtoMessage()    {}
func (*ProviderState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{6}
}
func (m *ProviderState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProviderState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProviderState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProviderState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProviderState.Merge(m, src)
}
func (m *ProviderState) XXX_Size() int {
	return m.Size()
}
func (m *ProviderState) XXX_DiscardUnknown() {
	xxx_messageInfo_ProviderState.DiscardUnknown(m)
}

var xxx_messageInfo_ProviderState proto.InternalMessageInfo

func (m *ProviderState) GetProviderInfo() *ProviderInfo {
	if m != nil {
		return m.ProviderInfo
	}
	return nil
}

func (m *ProviderState) GetProviderPriceStates() []*ProviderPriceState {
	if m != nil {
		return m.ProviderPriceStates
	}
	return nil
}

type ProviderPriceState struct {
	Symbol string      `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	State  *PriceState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
}

func (m *ProviderPriceState) Reset()         { *m = ProviderPriceState{} }
func (m *ProviderPriceState) String() string { return proto.CompactTextString(m) }
func (*ProviderPriceState) ProtoMessage()    {}
func (*ProviderPriceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{7}
}
func (m *ProviderPriceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProviderPriceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProviderPriceState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProviderPriceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProviderPriceState.Merge(m, src)
}
func (m *ProviderPriceState) XXX_Size() int {
	return m.Size()
}
func (m *ProviderPriceState) XXX_DiscardUnknown() {
	xxx_messageInfo_ProviderPriceState.DiscardUnknown(m)
}

var xxx_messageInfo_ProviderPriceState proto.InternalMessageInfo

func (m *ProviderPriceState) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *ProviderPriceState) GetState() *PriceState {
	if m != nil {
		return m.State
	}
	return nil
}

type PriceFeedInfo struct {
	Base  string `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Quote string `protobuf:"bytes,2,opt,name=quote,proto3" json:"quote,omitempty"`
}

func (m *PriceFeedInfo) Reset()         { *m = PriceFeedInfo{} }
func (m *PriceFeedInfo) String() string { return proto.CompactTextString(m) }
func (*PriceFeedInfo) ProtoMessage()    {}
func (*PriceFeedInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{8}
}
func (m *PriceFeedInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceFeedInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceFeedInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceFeedInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceFeedInfo.Merge(m, src)
}
func (m *PriceFeedInfo) XXX_Size() int {
	return m.Size()
}
func (m *PriceFeedInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceFeedInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PriceFeedInfo proto.InternalMessageInfo

func (m *PriceFeedInfo) GetBase() string {
	if m != nil {
		return m.Base
	}
	return ""
}

func (m *PriceFeedInfo) GetQuote() string {
	if m != nil {
		return m.Quote
	}
	return ""
}

type PriceFeedPrice struct {
	Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
}

func (m *PriceFeedPrice) Reset()         { *m = PriceFeedPrice{} }
func (m *PriceFeedPrice) String() string { return proto.CompactTextString(m) }
func (*PriceFeedPrice) ProtoMessage()    {}
func (*PriceFeedPrice) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{9}
}
func (m *PriceFeedPrice) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceFeedPrice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceFeedPrice.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceFeedPrice) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceFeedPrice.Merge(m, src)
}
func (m *PriceFeedPrice) XXX_Size() int {
	return m.Size()
}
func (m *PriceFeedPrice) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceFeedPrice.DiscardUnknown(m)
}

var xxx_messageInfo_PriceFeedPrice proto.InternalMessageInfo

type CoinbasePriceState struct {
	// kind should always be "prices"
	Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	// timestamp of the when the price was signed by coinbase
	Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// the symbol of the price, e.g. BTC
	Key string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	// the value of the price scaled by 1e6
	Value uint64 `protobuf:"varint,4,opt,name=value,proto3" json:"value,omitempty"`
	// the price state
	PriceState PriceState `protobuf:"bytes,5,opt,name=price_state,json=priceState,proto3" json:"price_state"`
}

func (m *CoinbasePriceState) Reset()         { *m = CoinbasePriceState{} }
func (m *CoinbasePriceState) String() string { return proto.CompactTextString(m) }
func (*CoinbasePriceState) ProtoMessage()    {}
func (*CoinbasePriceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{10}
}
func (m *CoinbasePriceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CoinbasePriceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CoinbasePriceState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CoinbasePriceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CoinbasePriceState.Merge(m, src)
}
func (m *CoinbasePriceState) XXX_Size() int {
	return m.Size()
}
func (m *CoinbasePriceState) XXX_DiscardUnknown() {
	xxx_messageInfo_CoinbasePriceState.DiscardUnknown(m)
}

var xxx_messageInfo_CoinbasePriceState proto.InternalMessageInfo

func (m *CoinbasePriceState) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *CoinbasePriceState) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *CoinbasePriceState) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *CoinbasePriceState) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *CoinbasePriceState) GetPriceState() PriceState {
	if m != nil {
		return m.PriceState
	}
	return PriceState{}
}

type PriceState struct {
	Price           github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
	CumulativePrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=cumulative_price,json=cumulativePrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"cumulative_price"`
	Timestamp       int64                                  `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

func (m *PriceState) Reset()         { *m = PriceState{} }
func (m *PriceState) String() string { return proto.CompactTextString(m) }
func (*PriceState) ProtoMessage()    {}
func (*PriceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{11}
}
func (m *PriceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceState.Merge(m, src)
}
func (m *PriceState) XXX_Size() int {
	return m.Size()
}
func (m *PriceState) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceState.DiscardUnknown(m)
}

var xxx_messageInfo_PriceState proto.InternalMessageInfo

func (m *PriceState) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type BandOracleRequest struct {
	// Unique Identifier for band ibc oracle request
	RequestId uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// OracleScriptID is the unique identifier of the oracle script to be executed.
	OracleScriptId int64 `protobuf:"varint,2,opt,name=oracle_script_id,json=oracleScriptId,proto3" json:"oracle_script_id,omitempty"`
	// Symbols is the list of symbols to prepare in the calldata
	Symbols []string `protobuf:"bytes,3,rep,name=symbols,proto3" json:"symbols,omitempty"`
	// 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 uint64 `protobuf:"varint,4,opt,name=ask_count,json=askCount,proto3" json:"ask_count,omitempty"`
	// 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 uint64 `protobuf:"varint,5,opt,name=min_count,json=minCount,proto3" json:"min_count,omitempty"`
	// FeeLimit is the maximum tokens that will be paid to all data source providers.
	FeeLimit github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,6,rep,name=fee_limit,json=feeLimit,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fee_limit"`
	// PrepareGas is amount of gas to pay to prepare raw requests
	PrepareGas uint64 `protobuf:"varint,7,opt,name=prepare_gas,json=prepareGas,proto3" json:"prepare_gas,omitempty"`
	// ExecuteGas is amount of gas to reserve for executing
	ExecuteGas uint64 `protobuf:"varint,8,opt,name=execute_gas,json=executeGas,proto3" json:"execute_gas,omitempty"`
}

func (m *BandOracleRequest) Reset()         { *m = BandOracleRequest{} }
func (m *BandOracleRequest) String() string { return proto.CompactTextString(m) }
func (*BandOracleRequest) ProtoMessage()    {}
func (*BandOracleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{12}
}
func (m *BandOracleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BandOracleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BandOracleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BandOracleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BandOracleRequest.Merge(m, src)
}
func (m *BandOracleRequest) XXX_Size() int {
	return m.Size()
}
func (m *BandOracleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BandOracleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BandOracleRequest proto.InternalMessageInfo

func (m *BandOracleRequest) GetRequestId() uint64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

func (m *BandOracleRequest) GetOracleScriptId() int64 {
	if m != nil {
		return m.OracleScriptId
	}
	return 0
}

func (m *BandOracleRequest) GetSymbols() []string {
	if m != nil {
		return m.Symbols
	}
	return nil
}

func (m *BandOracleRequest) GetAskCount() uint64 {
	if m != nil {
		return m.AskCount
	}
	return 0
}

func (m *BandOracleRequest) GetMinCount() uint64 {
	if m != nil {
		return m.MinCount
	}
	return 0
}

func (m *BandOracleRequest) GetFeeLimit() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.FeeLimit
	}
	return nil
}

func (m *BandOracleRequest) GetPrepareGas() uint64 {
	if m != nil {
		return m.PrepareGas
	}
	return 0
}

func (m *BandOracleRequest) GetExecuteGas() uint64 {
	if m != nil {
		return m.ExecuteGas
	}
	return 0
}

type BandIBCParams struct {
	// true if Band IBC should be enabled
	BandIbcEnabled bool `protobuf:"varint,1,opt,name=band_ibc_enabled,json=bandIbcEnabled,proto3" json:"band_ibc_enabled,omitempty"`
	// block request interval to send Band IBC prices
	IbcRequestInterval int64 `protobuf:"varint,2,opt,name=ibc_request_interval,json=ibcRequestInterval,proto3" json:"ibc_request_interval,omitempty"`
	// band IBC source channel
	IbcSourceChannel string `protobuf:"bytes,3,opt,name=ibc_source_channel,json=ibcSourceChannel,proto3" json:"ibc_source_channel,omitempty"`
	// band IBC version
	IbcVersion string `protobuf:"bytes,4,opt,name=ibc_version,json=ibcVersion,proto3" json:"ibc_version,omitempty"`
	// band IBC portID
	IbcPortId string `protobuf:"bytes,5,opt,name=ibc_port_id,json=ibcPortId,proto3" json:"ibc_port_id,omitempty"`
}

func (m *BandIBCParams) Reset()         { *m = BandIBCParams{} }
func (m *BandIBCParams) String() string { return proto.CompactTextString(m) }
func (*BandIBCParams) ProtoMessage()    {}
func (*BandIBCParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{13}
}
func (m *BandIBCParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BandIBCParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BandIBCParams.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BandIBCParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BandIBCParams.Merge(m, src)
}
func (m *BandIBCParams) XXX_Size() int {
	return m.Size()
}
func (m *BandIBCParams) XXX_DiscardUnknown() {
	xxx_messageInfo_BandIBCParams.DiscardUnknown(m)
}

var xxx_messageInfo_BandIBCParams proto.InternalMessageInfo

func (m *BandIBCParams) GetBandIbcEnabled() bool {
	if m != nil {
		return m.BandIbcEnabled
	}
	return false
}

func (m *BandIBCParams) GetIbcRequestInterval() int64 {
	if m != nil {
		return m.IbcRequestInterval
	}
	return 0
}

func (m *BandIBCParams) GetIbcSourceChannel() string {
	if m != nil {
		return m.IbcSourceChannel
	}
	return ""
}

func (m *BandIBCParams) GetIbcVersion() string {
	if m != nil {
		return m.IbcVersion
	}
	return ""
}

func (m *BandIBCParams) GetIbcPortId() string {
	if m != nil {
		return m.IbcPortId
	}
	return ""
}

type SymbolPriceTimestamp struct {
	Oracle    OracleType `protobuf:"varint,1,opt,name=oracle,proto3,enum=injective.oracle.v1beta1.OracleType" json:"oracle,omitempty"`
	SymbolId  string     `protobuf:"bytes,2,opt,name=symbol_id,json=symbolId,proto3" json:"symbol_id,omitempty"`
	Timestamp int64      `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

func (m *SymbolPriceTimestamp) Reset()         { *m = SymbolPriceTimestamp{} }
func (m *SymbolPriceTimestamp) String() string { return proto.CompactTextString(m) }
func (*SymbolPriceTimestamp) ProtoMessage()    {}
func (*SymbolPriceTimestamp) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{14}
}
func (m *SymbolPriceTimestamp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SymbolPriceTimestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SymbolPriceTimestamp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SymbolPriceTimestamp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SymbolPriceTimestamp.Merge(m, src)
}
func (m *SymbolPriceTimestamp) XXX_Size() int {
	return m.Size()
}
func (m *SymbolPriceTimestamp) XXX_DiscardUnknown() {
	xxx_messageInfo_SymbolPriceTimestamp.DiscardUnknown(m)
}

var xxx_messageInfo_SymbolPriceTimestamp proto.InternalMessageInfo

func (m *SymbolPriceTimestamp) GetOracle() OracleType {
	if m != nil {
		return m.Oracle
	}
	return OracleType_Unspecified
}

func (m *SymbolPriceTimestamp) GetSymbolId() string {
	if m != nil {
		return m.SymbolId
	}
	return ""
}

func (m *SymbolPriceTimestamp) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type LastPriceTimestamps struct {
	LastPriceTimestamps []*SymbolPriceTimestamp `protobuf:"bytes,1,rep,name=last_price_timestamps,json=lastPriceTimestamps,proto3" json:"last_price_timestamps,omitempty"`
}

func (m *LastPriceTimestamps) Reset()         { *m = LastPriceTimestamps{} }
func (m *LastPriceTimestamps) String() string { return proto.CompactTextString(m) }
func (*LastPriceTimestamps) ProtoMessage()    {}
func (*LastPriceTimestamps) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{15}
}
func (m *LastPriceTimestamps) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LastPriceTimestamps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LastPriceTimestamps.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LastPriceTimestamps) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LastPriceTimestamps.Merge(m, src)
}
func (m *LastPriceTimestamps) XXX_Size() int {
	return m.Size()
}
func (m *LastPriceTimestamps) XXX_DiscardUnknown() {
	xxx_messageInfo_LastPriceTimestamps.DiscardUnknown(m)
}

var xxx_messageInfo_LastPriceTimestamps proto.InternalMessageInfo

func (m *LastPriceTimestamps) GetLastPriceTimestamps() []*SymbolPriceTimestamp {
	if m != nil {
		return m.LastPriceTimestamps
	}
	return nil
}

type PriceRecords struct {
	Oracle             OracleType     `protobuf:"varint,1,opt,name=oracle,proto3,enum=injective.oracle.v1beta1.OracleType" json:"oracle,omitempty"`
	SymbolId           string         `protobuf:"bytes,2,opt,name=symbol_id,json=symbolId,proto3" json:"symbol_id,omitempty"`
	LatestPriceRecords []*PriceRecord `protobuf:"bytes,3,rep,name=latest_price_records,json=latestPriceRecords,proto3" json:"latest_price_records,omitempty"`
}

func (m *PriceRecords) Reset()         { *m = PriceRecords{} }
func (m *PriceRecords) String() string { return proto.CompactTextString(m) }
func (*PriceRecords) ProtoMessage()    {}
func (*PriceRecords) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{16}
}
func (m *PriceRecords) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceRecords) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceRecords.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceRecords) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceRecords.Merge(m, src)
}
func (m *PriceRecords) XXX_Size() int {
	return m.Size()
}
func (m *PriceRecords) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceRecords.DiscardUnknown(m)
}

var xxx_messageInfo_PriceRecords proto.InternalMessageInfo

func (m *PriceRecords) GetOracle() OracleType {
	if m != nil {
		return m.Oracle
	}
	return OracleType_Unspecified
}

func (m *PriceRecords) GetSymbolId() string {
	if m != nil {
		return m.SymbolId
	}
	return ""
}

func (m *PriceRecords) GetLatestPriceRecords() []*PriceRecord {
	if m != nil {
		return m.LatestPriceRecords
	}
	return nil
}

type PriceRecord struct {
	Timestamp int64                                  `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Price     github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
}

func (m *PriceRecord) Reset()         { *m = PriceRecord{} }
func (m *PriceRecord) String() string { return proto.CompactTextString(m) }
func (*PriceRecord) ProtoMessage()    {}
func (*PriceRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{17}
}
func (m *PriceRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PriceRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PriceRecord.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PriceRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PriceRecord.Merge(m, src)
}
func (m *PriceRecord) XXX_Size() int {
	return m.Size()
}
func (m *PriceRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_PriceRecord.DiscardUnknown(m)
}

var xxx_messageInfo_PriceRecord proto.InternalMessageInfo

func (m *PriceRecord) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

// MetadataStatistics refers to the metadata summary statistics of the historical sample considered
type MetadataStatistics struct {
	// GroupCount refers to the number of groups used. Equals RecordsSampleSize if no grouping is used
	GroupCount uint32 `protobuf:"varint,1,opt,name=group_count,json=groupCount,proto3" json:"group_count,omitempty"`
	// RecordsSampleSize refers to the total number of records used.
	RecordsSampleSize uint32 `protobuf:"varint,2,opt,name=records_sample_size,json=recordsSampleSize,proto3" json:"records_sample_size,omitempty"`
	// 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 github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=mean,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"mean"`
	// 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 github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=twap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"twap"`
	// FirstTimestamp is the timestamp of the oldest record considered
	FirstTimestamp int64 `protobuf:"varint,5,opt,name=first_timestamp,json=firstTimestamp,proto3" json:"first_timestamp,omitempty"`
	// LastTimestamp is the timestamp of the youngest record considered
	LastTimestamp int64 `protobuf:"varint,6,opt,name=last_timestamp,json=lastTimestamp,proto3" json:"last_timestamp,omitempty"`
	// MinPrice refers to the smallest individual raw price considered
	MinPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=min_price,json=minPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_price"`
	// MaxPrice refers to the largest individual raw price considered
	MaxPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=max_price,json=maxPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_price"`
	// MedianPrice refers to the median individual raw price considered
	MedianPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=median_price,json=medianPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"median_price"`
}

func (m *MetadataStatistics) Reset()         { *m = MetadataStatistics{} }
func (m *MetadataStatistics) String() string { return proto.CompactTextString(m) }
func (*MetadataStatistics) ProtoMessage()    {}
func (*MetadataStatistics) Descriptor() ([]byte, []int) {
	return fileDescriptor_1c8fbf1e7a765423, []int{18}
}
func (m *MetadataStatistics) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataStatistics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataStatistics.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MetadataStatistics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataStatistics.Merge(m, src)
}
func (m *MetadataStatistics) XXX_Size() int {
	return m.Size()
}
func (m *MetadataStatistics) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataStatistics.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataStatistics proto.InternalMessageInfo

func (m *MetadataStatistics) GetGroupCount() uint32 {
	if m != nil {
		return m.GroupCount
	}
	return 0
}

func (m *MetadataStatistics) GetRecordsSampleSize() uint32 {
	if m != nil {
		return m.RecordsSampleSize
	}
	return 0
}

func (m *MetadataStatistics) GetFirstTimestamp() int64 {
	if m != nil {
		return m.FirstTimestamp
	}
	return 0
}

func (m *MetadataStatistics) GetLastTimestamp() int64 {
	if m != nil {
		return m.LastTimestamp
	}
	return 0
}

func init() {
	proto.RegisterEnum("injective.oracle.v1beta1.OracleType", OracleType_name, OracleType_value)
	proto.RegisterType((*Params)(nil), "injective.oracle.v1beta1.Params")
	proto.RegisterType((*OracleInfo)(nil), "injective.oracle.v1beta1.OracleInfo")
	proto.RegisterType((*ChainlinkPriceState)(nil), "injective.oracle.v1beta1.ChainlinkPriceState")
	proto.RegisterType((*BandPriceState)(nil), "injective.oracle.v1beta1.BandPriceState")
	proto.RegisterType((*PriceFeedState)(nil), "injective.oracle.v1beta1.PriceFeedState")
	proto.RegisterType((*ProviderInfo)(nil), "injective.oracle.v1beta1.ProviderInfo")
	proto.RegisterType((*ProviderState)(nil), "injective.oracle.v1beta1.ProviderState")
	proto.RegisterType((*ProviderPriceState)(nil), "injective.oracle.v1beta1.ProviderPriceState")
	proto.RegisterType((*PriceFeedInfo)(nil), "injective.oracle.v1beta1.PriceFeedInfo")
	proto.RegisterType((*PriceFeedPrice)(nil), "injective.oracle.v1beta1.PriceFeedPrice")
	proto.RegisterType((*CoinbasePriceState)(nil), "injective.oracle.v1beta1.CoinbasePriceState")
	proto.RegisterType((*PriceState)(nil), "injective.oracle.v1beta1.PriceState")
	proto.RegisterType((*BandOracleRequest)(nil), "injective.oracle.v1beta1.BandOracleRequest")
	proto.RegisterType((*BandIBCParams)(nil), "injective.oracle.v1beta1.BandIBCParams")
	proto.RegisterType((*SymbolPriceTimestamp)(nil), "injective.oracle.v1beta1.SymbolPriceTimestamp")
	proto.RegisterType((*LastPriceTimestamps)(nil), "injective.oracle.v1beta1.LastPriceTimestamps")
	proto.RegisterType((*PriceRecords)(nil), "injective.oracle.v1beta1.PriceRecords")
	proto.RegisterType((*PriceRecord)(nil), "injective.oracle.v1beta1.PriceRecord")
	proto.RegisterType((*MetadataStatistics)(nil), "injective.oracle.v1beta1.MetadataStatistics")
}

func init() {
	proto.RegisterFile("injective/oracle/v1beta1/oracle.proto", fileDescriptor_1c8fbf1e7a765423)
}

var fileDescriptor_1c8fbf1e7a765423 = []byte{
	// 1419 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x72, 0xdc, 0xc4,
	0x16, 0xb6, 0xe6, 0xcf, 0xa3, 0x33, 0xf6, 0x44, 0x69, 0x3b, 0xf7, 0xce, 0xf5, 0xbd, 0x77, 0x6c,
	0x54, 0x24, 0xb8, 0xa8, 0x64, 0x26, 0x71, 0x56, 0xa4, 0xd8, 0x60, 0x3b, 0x4e, 0x4d, 0xc5, 0x14,
	0x46, 0x76, 0x42, 0xc1, 0x46, 0xb4, 0xa4, 0x1e, 0xbb, 0xb1, 0xa4, 0x56, 0xd4, 0x9a, 0x49, 0x26,
	0x0f, 0x01, 0xbc, 0x00, 0x05, 0xeb, 0xbc, 0x02, 0x55, 0x2c, 0x58, 0xa5, 0x8a, 0x4d, 0x96, 0x54,
	0x8a, 0x0a, 0x90, 0x6c, 0x78, 0x07, 0x36, 0x54, 0xff, 0x8c, 0x46, 0xb6, 0x71, 0x62, 0x3b, 0x61,
	0x35, 0x3a, 0xa7, 0x4f, 0x7f, 0xfd, 0x9d, 0xdf, 0xee, 0x81, 0x8b, 0x34, 0xfe, 0x82, 0xf8, 0x19,
	0x1d, 0x92, 0x2e, 0x4b, 0xb1, 0x1f, 0x92, 0xee, 0xf0, 0x9a, 0x47, 0x32, 0x7c, 0x4d, 0x8b, 0x9d,
	0x24, 0x65, 0x19, 0x43, 0xad, 0xdc, 0xac, 0xa3, 0xf5, 0xda, 0x6c, 0x61, 0x7e, 0x97, 0xed, 0x32,
	0x69, 0xd4, 0x15, 0x5f, 0xca, 0x7e, 0xa1, 0xed, 0x33, 0x1e, 0x31, 0xde, 0xf5, 0x30, 0x9f, 0x20,
	0xfa, 0x8c, 0xc6, 0x6a, 0xdd, 0x6e, 0x42, 0x6d, 0x0b, 0xa7, 0x38, 0xe2, 0x37, 0x2a, 0x7f, 0x7c,
	0xb7, 0x68, 0xd8, 0x5f, 0x1a, 0x00, 0x1f, 0x49, 0xe0, 0x5e, 0xdc, 0x67, 0xe8, 0x5f, 0x50, 0xe3,
	0xa3, 0xc8, 0x63, 0x61, 0xcb, 0x58, 0x32, 0x96, 0x4d, 0x47, 0x4b, 0xe8, 0x26, 0x34, 0xd4, 0xf1,
	0x6e, 0x36, 0x4a, 0x48, 0xab, 0xb4, 0x64, 0x2c, 0x37, 0x57, 0xde, 0xee, 0x1c, 0x47, 0xae, 0xa3,
	0x20, 0x77, 0x46, 0x09, 0x71, 0x80, 0xe5, 0xdf, 0xe8, 0x2d, 0x98, 0xe1, 0x3e, 0x0e, 0x89, 0xdb,
	0xc7, 0x7e, 0xc6, 0xd2, 0x56, 0x79, 0xc9, 0x58, 0x9e, 0x75, 0x1a, 0x52, 0xb7, 0x21, 0x55, 0xf6,
	0xef, 0x06, 0xcc, 0xad, 0xed, 0x61, 0x1a, 0x87, 0x34, 0xde, 0xdf, 0x4a, 0xa9, 0x4f, 0xb6, 0x33,
	0x9c, 0x11, 0xf4, 0x6f, 0x98, 0xee, 0x13, 0x12, 0xb8, 0x34, 0x18, 0x53, 0x13, 0x62, 0x2f, 0x40,
	0x1b, 0x50, 0xc3, 0x31, 0xbf, 0x4f, 0x52, 0xc9, 0xca, 0x5c, 0xed, 0x3c, 0x7e, 0xb6, 0x38, 0xf5,
	0xf4, 0xd9, 0xe2, 0xa5, 0x5d, 0x9a, 0xed, 0x0d, 0xbc, 0x8e, 0xcf, 0xa2, 0xae, 0x0e, 0x8a, 0xfa,
	0xb9, 0xc2, 0x83, 0xfd, 0xae, 0x70, 0x83, 0x77, 0xd6, 0x89, 0xef, 0xe8, 0xdd, 0xe8, 0x7f, 0x60,
	0x66, 0x34, 0x22, 0x3c, 0xc3, 0x51, 0x22, 0x89, 0x55, 0x9c, 0x89, 0x02, 0xdd, 0x86, 0x46, 0x22,
	0xc8, 0xb8, 0x5c, 0xb0, 0x69, 0x55, 0x96, 0x8c, 0xe5, 0xc6, 0xcb, 0x02, 0x30, 0x61, 0xbe, 0x5a,
	0x11, 0x84, 0x1c, 0x48, 0x72, 0x8d, 0xfd, 0xa7, 0x01, 0xcd, 0x55, 0x1c, 0x07, 0x05, 0xf7, 0x8e,
	0x0b, 0xfc, 0x2a, 0x54, 0x52, 0x71, 0xe0, 0xe9, 0x7d, 0xeb, 0xc5, 0x99, 0x23, 0xf7, 0x8a, 0xa8,
	0xa7, 0x84, 0xb3, 0x70, 0x48, 0x5c, 0xe1, 0x90, 0x76, 0xae, 0xa1, 0x75, 0x3b, 0x34, 0x22, 0xe8,
	0xff, 0x00, 0x29, 0xb9, 0x37, 0x20, 0x3c, 0x73, 0x7b, 0xeb, 0xd2, 0xbb, 0x8a, 0x63, 0x6a, 0x4d,
	0x6f, 0xfd, 0xb0, 0xf7, 0xd5, 0xd7, 0xf2, 0xfe, 0x1b, 0x03, 0x9a, 0xd2, 0x60, 0x83, 0x90, 0x40,
	0x79, 0x8f, 0xa0, 0x22, 0x0a, 0x56, 0xfb, 0x2e, 0xbf, 0xd1, 0x3c, 0x54, 0xef, 0x0d, 0xd8, 0xd8,
	0x75, 0x47, 0x09, 0xa2, 0x10, 0x8b, 0x4c, 0xca, 0x27, 0x67, 0x52, 0xe4, 0x80, 0x16, 0xa0, 0x9e,
	0x92, 0x10, 0x8f, 0x48, 0xca, 0x5b, 0x95, 0xa5, 0xf2, 0xb2, 0xe9, 0xe4, 0xb2, 0xbd, 0x01, 0x33,
	0x5b, 0x29, 0x1b, 0xd2, 0x80, 0xa4, 0xb2, 0x27, 0x16, 0xa0, 0x9e, 0x68, 0x59, 0x13, 0xcc, 0xe5,
	0x03, 0x38, 0xa5, 0x43, 0x38, 0x3f, 0x18, 0x30, 0x3b, 0x06, 0x52, 0xa7, 0xde, 0x86, 0xd9, 0xf1,
	0x4e, 0x97, 0xc6, 0x7d, 0x26, 0xe1, 0x1a, 0x2b, 0x97, 0x5e, 0x46, 0x7f, 0x42, 0xc4, 0x99, 0x49,
	0x8a, 0xb4, 0x3e, 0x87, 0x0b, 0x39, 0x58, 0x21, 0x24, 0x8a, 0x47, 0x63, 0xe5, 0xf2, 0xab, 0x41,
	0x0b, 0xb1, 0x99, 0x4b, 0x8e, 0xe8, 0xb8, 0xbd, 0x07, 0xe8, 0xa8, 0xe9, 0xb1, 0x95, 0x7a, 0x03,
	0xaa, 0x2a, 0x27, 0xa5, 0x53, 0xe4, 0x44, 0x6d, 0xb1, 0xdf, 0x13, 0x91, 0xd2, 0x15, 0x21, 0x9d,
	0x3b, 0x71, 0x41, 0xd8, 0x77, 0x0b, 0xc5, 0x24, 0x3f, 0xd0, 0x3a, 0x54, 0x65, 0x3c, 0xd4, 0xe6,
	0x53, 0xcf, 0x03, 0xb5, 0xd9, 0xfe, 0xde, 0x00, 0xb4, 0xc6, 0x68, 0x2c, 0x8e, 0x2e, 0x78, 0x8f,
	0xa0, 0xb2, 0x4f, 0xe3, 0xf1, 0x0c, 0x92, 0xdf, 0x07, 0x27, 0x47, 0xe9, 0xf0, 0xe4, 0xb0, 0xa0,
	0xbc, 0x4f, 0x46, 0xb2, 0x52, 0x4d, 0x47, 0x7c, 0x0a, 0x47, 0x86, 0x38, 0x1c, 0x10, 0xdd, 0x67,
	0x4a, 0x78, 0xb3, 0x3d, 0xf6, 0x93, 0x01, 0x50, 0x60, 0xfd, 0x46, 0x42, 0x82, 0x3e, 0x05, 0xcb,
	0x1f, 0x44, 0x83, 0x10, 0x0b, 0x3a, 0xaa, 0xe6, 0xce, 0x38, 0x73, 0xcf, 0x4d, 0x70, 0x54, 0xce,
	0x8e, 0x0c, 0xdf, 0x72, 0x21, 0x84, 0xf6, 0x2f, 0x25, 0x38, 0x2f, 0xe6, 0xa5, 0xba, 0x55, 0x1c,
	0x35, 0x96, 0x8a, 0x33, 0x4b, 0x5f, 0x0a, 0x85, 0x99, 0x15, 0xa0, 0x65, 0xb0, 0xf4, 0x95, 0xc5,
	0xfd, 0x94, 0x26, 0xd2, 0xa8, 0x24, 0x91, 0x9b, 0x4a, 0xbf, 0x2d, 0xd5, 0xbd, 0x00, 0xb5, 0x60,
	0x5a, 0xd5, 0x30, 0x6f, 0x95, 0x65, 0x0f, 0x8f, 0x45, 0xf4, 0x5f, 0x30, 0x31, 0xdf, 0x77, 0x7d,
	0x36, 0x88, 0x33, 0x9d, 0xad, 0x3a, 0xe6, 0xfb, 0x6b, 0x42, 0x16, 0x8b, 0x11, 0x8d, 0xf5, 0x62,
	0x55, 0x2d, 0x46, 0x34, 0x56, 0x8b, 0x7b, 0x60, 0xf6, 0x09, 0x71, 0x43, 0x1a, 0xd1, 0xac, 0x55,
	0x93, 0x1d, 0xf9, 0x9f, 0x8e, 0x8a, 0x45, 0x47, 0x94, 0x54, 0x9e, 0x46, 0x51, 0x63, 0xab, 0x57,
	0x45, 0xfc, 0x1e, 0xfd, 0xba, 0xb8, 0x7c, 0x82, 0xf8, 0x89, 0x0d, 0xdc, 0xa9, 0xf7, 0x09, 0xd9,
	0x14, 0xe0, 0x68, 0x51, 0xd4, 0x0d, 0x49, 0x70, 0x4a, 0xdc, 0x5d, 0xcc, 0x5b, 0xd3, 0x92, 0x08,
	0x68, 0xd5, 0x2d, 0xcc, 0x85, 0x01, 0x79, 0x40, 0xfc, 0x41, 0xa6, 0x0c, 0xea, 0xca, 0x40, 0xab,
	0x6e, 0x61, 0x6e, 0x3f, 0x35, 0x60, 0x56, 0x84, 0xb7, 0xb7, 0xba, 0xa6, 0xde, 0x06, 0x22, 0x76,
	0x1e, 0x8e, 0x03, 0x97, 0x7a, 0xbe, 0x4b, 0x62, 0xec, 0x85, 0x44, 0x05, 0xb8, 0xee, 0x34, 0x85,
	0xbe, 0xe7, 0xf9, 0x37, 0x95, 0x16, 0x5d, 0x85, 0x79, 0x61, 0x94, 0x27, 0x22, 0xce, 0x48, 0x3a,
	0xc4, 0xa1, 0x8e, 0x34, 0xa2, 0x9e, 0xaf, 0xd3, 0xd5, 0xd3, 0x2b, 0xe8, 0x32, 0x08, 0xad, 0xcb,
	0xd9, 0x20, 0xf5, 0x89, 0xeb, 0xef, 0xe1, 0x38, 0x26, 0xa1, 0x6e, 0x0f, 0x8b, 0x7a, 0xfe, 0xb6,
	0x5c, 0x58, 0x53, 0x7a, 0x41, 0x5e, 0x58, 0x0f, 0x49, 0xca, 0x29, 0x8b, 0x65, 0x0e, 0x4c, 0x07,
	0xa8, 0xe7, 0xdf, 0x55, 0x1a, 0xd4, 0x56, 0x06, 0x09, 0x4b, 0x65, 0x86, 0xab, 0xd2, 0xc0, 0xa4,
	0x9e, 0xbf, 0xc5, 0xd2, 0xac, 0x17, 0xd8, 0x5f, 0x19, 0x30, 0xbf, 0x2d, 0xd3, 0x29, 0x2b, 0x6d,
	0x27, 0xef, 0xcb, 0xf7, 0xa1, 0xa6, 0xea, 0x40, 0x7a, 0x76, 0xd2, 0xd7, 0x8c, 0xde, 0x23, 0x92,
	0xaf, 0x8a, 0x64, 0x5c, 0x56, 0xa6, 0x53, 0x57, 0x8a, 0x5e, 0xf0, 0x8a, 0x6a, 0x1e, 0xc1, 0xdc,
	0x26, 0xe6, 0xd9, 0x41, 0x3a, 0x1c, 0x79, 0x70, 0x21, 0xc4, 0x3c, 0xd3, 0xb3, 0x3c, 0x37, 0xe7,
	0x2d, 0x43, 0x56, 0x4f, 0xe7, 0x78, 0x7a, 0x7f, 0xe7, 0x9e, 0x33, 0x17, 0x1e, 0x3d, 0xc3, 0xfe,
	0xd1, 0x10, 0x77, 0x1b, 0xf5, 0x89, 0x43, 0x7c, 0x96, 0x06, 0xfc, 0x9f, 0x0c, 0xc2, 0x27, 0x30,
	0x1f, 0x8a, 0x6b, 0x64, 0xec, 0x51, 0xaa, 0x8e, 0x94, 0x2d, 0xd6, 0x58, 0xb9, 0xf8, 0x8a, 0xc1,
	0xa6, 0x08, 0x3a, 0x48, 0x41, 0x14, 0x39, 0xdb, 0xf7, 0xa0, 0x51, 0x90, 0x0f, 0x06, 0xdb, 0x38,
	0x14, 0xec, 0xc9, 0xe4, 0x2b, 0xbd, 0xce, 0x65, 0xf0, 0xa8, 0x02, 0xe8, 0x43, 0x92, 0xe1, 0x00,
	0x67, 0x58, 0x4c, 0x54, 0xca, 0x33, 0xea, 0xcb, 0xce, 0xda, 0x4d, 0xd9, 0x20, 0xd1, 0x33, 0xc0,
	0x90, 0xaf, 0x59, 0x90, 0x2a, 0x35, 0x05, 0x3a, 0x30, 0xa7, 0xdd, 0x76, 0x39, 0x8e, 0x12, 0x31,
	0x8b, 0xe8, 0x43, 0xc5, 0x65, 0xd6, 0x39, 0xaf, 0x97, 0xb6, 0xe5, 0xca, 0x36, 0x7d, 0x48, 0xc4,
	0x6b, 0x2f, 0x22, 0x38, 0x56, 0xdd, 0x70, 0x6a, 0xb2, 0x72, 0xaf, 0xc0, 0xc8, 0xee, 0xe3, 0x44,
	0xb5, 0xca, 0xe9, 0x31, 0xc4, 0x5e, 0xf4, 0x0e, 0x9c, 0xeb, 0xd3, 0x94, 0x67, 0x93, 0x32, 0x94,
	0x8d, 0x55, 0x76, 0x9a, 0x52, 0x3d, 0x69, 0xa2, 0x8b, 0xd0, 0x94, 0x45, 0x3b, 0xb1, 0xab, 0x49,
	0xbb, 0x59, 0xa1, 0xdd, 0x29, 0xbc, 0x9e, 0xe5, 0xa8, 0x54, 0x99, 0x98, 0x3e, 0x13, 0x31, 0x31,
	0x5a, 0xd5, 0x5d, 0x21, 0xc0, 0xf0, 0x03, 0x0d, 0x56, 0x3f, 0x23, 0x18, 0x7e, 0xa0, 0xc0, 0x3e,
	0x86, 0x99, 0x88, 0x04, 0x14, 0x8f, 0xc9, 0x99, 0x67, 0xc2, 0x6b, 0x28, 0x0c, 0x09, 0xf9, 0xee,
	0xb7, 0xf9, 0x5f, 0x2a, 0xf9, 0x9f, 0xe7, 0x1c, 0x34, 0xee, 0xc4, 0x3c, 0x21, 0x3e, 0xed, 0x53,
	0x12, 0x58, 0x53, 0xa8, 0x0e, 0x15, 0x31, 0x6d, 0x2d, 0x03, 0xcd, 0x82, 0x99, 0xbf, 0x5d, 0xac,
	0x12, 0x9a, 0x81, 0xfa, 0xf8, 0xc5, 0x61, 0x95, 0xc5, 0x62, 0xfe, 0x3f, 0xc8, 0xaa, 0x20, 0x13,
	0xaa, 0x0e, 0x7e, 0xc8, 0x52, 0xab, 0x8a, 0xa6, 0xa1, 0xbc, 0x4e, 0xb1, 0x55, 0x13, 0x48, 0x1f,
	0x6c, 0xf5, 0xae, 0x5b, 0xd3, 0x42, 0x75, 0x27, 0xc2, 0x56, 0x5d, 0xa8, 0xb6, 0x46, 0xd9, 0x9e,
	0x65, 0xa2, 0x06, 0x4c, 0xeb, 0xa1, 0x6e, 0x81, 0x80, 0x1e, 0x3f, 0xe5, 0xac, 0xc6, 0x6a, 0xff,
	0xf1, 0xf3, 0xb6, 0xf1, 0xe4, 0x79, 0xdb, 0xf8, 0xed, 0x79, 0xdb, 0xf8, 0xfa, 0x45, 0x7b, 0xea,
	0xc9, 0x8b, 0xf6, 0xd4, 0xcf, 0x2f, 0xda, 0x53, 0x9f, 0x6d, 0x16, 0x1c, 0xee, 0x8d, 0x1b, 0x74,
	0x13, 0x7b, 0xbc, 0x9b, 0xb7, 0xeb, 0x15, 0x9f, 0xa5, 0xa4, 0x28, 0x0a, 0x92, 0xdd, 0x88, 0x05,
	0x83, 0x90, 0xf0, 0xf1, 0x7f, 0x59, 0x19, 0x1a, 0xaf, 0x26, 0xff, 0x73, 0x5e, 0xff, 0x2b, 0x00,
	0x00, 0xff, 0xff, 0xec, 0x0d, 0x79, 0xf3, 0xec, 0x0e, 0x00, 0x00,
}

func (this *Params) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (m *Params) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *OracleInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OracleInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OracleInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ScaleFactor != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.ScaleFactor))
		i--
		dAtA[i] = 0x18
	}
	if m.OracleType != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.OracleType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChainlinkPriceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChainlinkPriceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChainlinkPriceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PriceState.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Timestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Answer.Size()
		i -= size
		if _, err := m.Answer.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.FeedId) > 0 {
		i -= len(m.FeedId)
		copy(dAtA[i:], m.FeedId)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.FeedId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BandPriceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BandPriceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BandPriceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PriceState.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Request_ID != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Request_ID))
		i--
		dAtA[i] = 0x20
	}
	if m.ResolveTime != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.ResolveTime))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Rate.Size()
		i -= size
		if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PriceFeedState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceFeedState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceFeedState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relayers) > 0 {
		for iNdEx := len(m.Relayers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Relayers[iNdEx])
			copy(dAtA[i:], m.Relayers[iNdEx])
			i = encodeVarintOracle(dAtA, i, uint64(len(m.Relayers[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.PriceState != nil {
		{
			size, err := m.PriceState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOracle(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Quote) > 0 {
		i -= len(m.Quote)
		copy(dAtA[i:], m.Quote)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Quote)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Base) > 0 {
		i -= len(m.Base)
		copy(dAtA[i:], m.Base)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Base)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProviderInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProviderInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProviderInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relayers) > 0 {
		for iNdEx := len(m.Relayers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Relayers[iNdEx])
			copy(dAtA[i:], m.Relayers[iNdEx])
			i = encodeVarintOracle(dAtA, i, uint64(len(m.Relayers[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Provider) > 0 {
		i -= len(m.Provider)
		copy(dAtA[i:], m.Provider)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Provider)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProviderState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProviderState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProviderState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderPriceStates) > 0 {
		for iNdEx := len(m.ProviderPriceStates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ProviderPriceStates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOracle(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ProviderInfo != nil {
		{
			size, err := m.ProviderInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOracle(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProviderPriceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProviderPriceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProviderPriceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOracle(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PriceFeedInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceFeedInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceFeedInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Quote) > 0 {
		i -= len(m.Quote)
		copy(dAtA[i:], m.Quote)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Quote)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Base) > 0 {
		i -= len(m.Base)
		copy(dAtA[i:], m.Base)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Base)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PriceFeedPrice) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceFeedPrice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceFeedPrice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CoinbasePriceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CoinbasePriceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CoinbasePriceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PriceState.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.Value != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Timestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PriceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.CumulativePrice.Size()
		i -= size
		if _, err := m.CumulativePrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *BandOracleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BandOracleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BandOracleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExecuteGas != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.ExecuteGas))
		i--
		dAtA[i] = 0x40
	}
	if m.PrepareGas != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.PrepareGas))
		i--
		dAtA[i] = 0x38
	}
	if len(m.FeeLimit) > 0 {
		for iNdEx := len(m.FeeLimit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FeeLimit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOracle(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.MinCount != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.MinCount))
		i--
		dAtA[i] = 0x28
	}
	if m.AskCount != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.AskCount))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Symbols) > 0 {
		for iNdEx := len(m.Symbols) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Symbols[iNdEx])
			copy(dAtA[i:], m.Symbols[iNdEx])
			i = encodeVarintOracle(dAtA, i, uint64(len(m.Symbols[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.OracleScriptId != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.OracleScriptId))
		i--
		dAtA[i] = 0x10
	}
	if m.RequestId != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.RequestId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BandIBCParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BandIBCParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BandIBCParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IbcPortId) > 0 {
		i -= len(m.IbcPortId)
		copy(dAtA[i:], m.IbcPortId)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.IbcPortId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IbcVersion) > 0 {
		i -= len(m.IbcVersion)
		copy(dAtA[i:], m.IbcVersion)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.IbcVersion)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IbcSourceChannel) > 0 {
		i -= len(m.IbcSourceChannel)
		copy(dAtA[i:], m.IbcSourceChannel)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.IbcSourceChannel)))
		i--
		dAtA[i] = 0x1a
	}
	if m.IbcRequestInterval != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.IbcRequestInterval))
		i--
		dAtA[i] = 0x10
	}
	if m.BandIbcEnabled {
		i--
		if m.BandIbcEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SymbolPriceTimestamp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SymbolPriceTimestamp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SymbolPriceTimestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x18
	}
	if len(m.SymbolId) > 0 {
		i -= len(m.SymbolId)
		copy(dAtA[i:], m.SymbolId)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.SymbolId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Oracle != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Oracle))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LastPriceTimestamps) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LastPriceTimestamps) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LastPriceTimestamps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LastPriceTimestamps) > 0 {
		for iNdEx := len(m.LastPriceTimestamps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LastPriceTimestamps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOracle(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PriceRecords) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceRecords) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceRecords) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LatestPriceRecords) > 0 {
		for iNdEx := len(m.LatestPriceRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestPriceRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOracle(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.SymbolId) > 0 {
		i -= len(m.SymbolId)
		copy(dAtA[i:], m.SymbolId)
		i = encodeVarintOracle(dAtA, i, uint64(len(m.SymbolId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Oracle != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Oracle))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *PriceRecord) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PriceRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PriceRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Price.Size()
		i -= size
		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Timestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MetadataStatistics) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetadataStatistics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataStatistics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MedianPrice.Size()
		i -= size
		if _, err := m.MedianPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size := m.MaxPrice.Size()
		i -= size
		if _, err := m.MaxPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.MinPrice.Size()
		i -= size
		if _, err := m.MinPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if m.LastTimestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.LastTimestamp))
		i--
		dAtA[i] = 0x30
	}
	if m.FirstTimestamp != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.FirstTimestamp))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.Twap.Size()
		i -= size
		if _, err := m.Twap.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.Mean.Size()
		i -= size
		if _, err := m.Mean.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOracle(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.RecordsSampleSize != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.RecordsSampleSize))
		i--
		dAtA[i] = 0x10
	}
	if m.GroupCount != 0 {
		i = encodeVarintOracle(dAtA, i, uint64(m.GroupCount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintOracle(dAtA []byte, offset int, v uint64) int {
	offset -= sovOracle(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *OracleInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.OracleType != 0 {
		n += 1 + sovOracle(uint64(m.OracleType))
	}
	if m.ScaleFactor != 0 {
		n += 1 + sovOracle(uint64(m.ScaleFactor))
	}
	return n
}

func (m *ChainlinkPriceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FeedId)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = m.Answer.Size()
	n += 1 + l + sovOracle(uint64(l))
	if m.Timestamp != 0 {
		n += 1 + sovOracle(uint64(m.Timestamp))
	}
	l = m.PriceState.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func (m *BandPriceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = m.Rate.Size()
	n += 1 + l + sovOracle(uint64(l))
	if m.ResolveTime != 0 {
		n += 1 + sovOracle(uint64(m.ResolveTime))
	}
	if m.Request_ID != 0 {
		n += 1 + sovOracle(uint64(m.Request_ID))
	}
	l = m.PriceState.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func (m *PriceFeedState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Base)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = len(m.Quote)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.PriceState != nil {
		l = m.PriceState.Size()
		n += 1 + l + sovOracle(uint64(l))
	}
	if len(m.Relayers) > 0 {
		for _, s := range m.Relayers {
			l = len(s)
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	return n
}

func (m *ProviderInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Provider)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if len(m.Relayers) > 0 {
		for _, s := range m.Relayers {
			l = len(s)
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	return n
}

func (m *ProviderState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProviderInfo != nil {
		l = m.ProviderInfo.Size()
		n += 1 + l + sovOracle(uint64(l))
	}
	if len(m.ProviderPriceStates) > 0 {
		for _, e := range m.ProviderPriceStates {
			l = e.Size()
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	return n
}

func (m *ProviderPriceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovOracle(uint64(l))
	}
	return n
}

func (m *PriceFeedInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Base)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = len(m.Quote)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	return n
}

func (m *PriceFeedPrice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Price.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func (m *CoinbasePriceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovOracle(uint64(m.Timestamp))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.Value != 0 {
		n += 1 + sovOracle(uint64(m.Value))
	}
	l = m.PriceState.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func (m *PriceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Price.Size()
	n += 1 + l + sovOracle(uint64(l))
	l = m.CumulativePrice.Size()
	n += 1 + l + sovOracle(uint64(l))
	if m.Timestamp != 0 {
		n += 1 + sovOracle(uint64(m.Timestamp))
	}
	return n
}

func (m *BandOracleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestId != 0 {
		n += 1 + sovOracle(uint64(m.RequestId))
	}
	if m.OracleScriptId != 0 {
		n += 1 + sovOracle(uint64(m.OracleScriptId))
	}
	if len(m.Symbols) > 0 {
		for _, s := range m.Symbols {
			l = len(s)
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	if m.AskCount != 0 {
		n += 1 + sovOracle(uint64(m.AskCount))
	}
	if m.MinCount != 0 {
		n += 1 + sovOracle(uint64(m.MinCount))
	}
	if len(m.FeeLimit) > 0 {
		for _, e := range m.FeeLimit {
			l = e.Size()
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	if m.PrepareGas != 0 {
		n += 1 + sovOracle(uint64(m.PrepareGas))
	}
	if m.ExecuteGas != 0 {
		n += 1 + sovOracle(uint64(m.ExecuteGas))
	}
	return n
}

func (m *BandIBCParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BandIbcEnabled {
		n += 2
	}
	if m.IbcRequestInterval != 0 {
		n += 1 + sovOracle(uint64(m.IbcRequestInterval))
	}
	l = len(m.IbcSourceChannel)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = len(m.IbcVersion)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	l = len(m.IbcPortId)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	return n
}

func (m *SymbolPriceTimestamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Oracle != 0 {
		n += 1 + sovOracle(uint64(m.Oracle))
	}
	l = len(m.SymbolId)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovOracle(uint64(m.Timestamp))
	}
	return n
}

func (m *LastPriceTimestamps) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LastPriceTimestamps) > 0 {
		for _, e := range m.LastPriceTimestamps {
			l = e.Size()
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	return n
}

func (m *PriceRecords) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Oracle != 0 {
		n += 1 + sovOracle(uint64(m.Oracle))
	}
	l = len(m.SymbolId)
	if l > 0 {
		n += 1 + l + sovOracle(uint64(l))
	}
	if len(m.LatestPriceRecords) > 0 {
		for _, e := range m.LatestPriceRecords {
			l = e.Size()
			n += 1 + l + sovOracle(uint64(l))
		}
	}
	return n
}

func (m *PriceRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != 0 {
		n += 1 + sovOracle(uint64(m.Timestamp))
	}
	l = m.Price.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func (m *MetadataStatistics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupCount != 0 {
		n += 1 + sovOracle(uint64(m.GroupCount))
	}
	if m.RecordsSampleSize != 0 {
		n += 1 + sovOracle(uint64(m.RecordsSampleSize))
	}
	l = m.Mean.Size()
	n += 1 + l + sovOracle(uint64(l))
	l = m.Twap.Size()
	n += 1 + l + sovOracle(uint64(l))
	if m.FirstTimestamp != 0 {
		n += 1 + sovOracle(uint64(m.FirstTimestamp))
	}
	if m.LastTimestamp != 0 {
		n += 1 + sovOracle(uint64(m.LastTimestamp))
	}
	l = m.MinPrice.Size()
	n += 1 + l + sovOracle(uint64(l))
	l = m.MaxPrice.Size()
	n += 1 + l + sovOracle(uint64(l))
	l = m.MedianPrice.Size()
	n += 1 + l + sovOracle(uint64(l))
	return n
}

func sovOracle(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozOracle(x uint64) (n int) {
	return sovOracle(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OracleInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OracleInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OracleInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleType", wireType)
			}
			m.OracleType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleType |= OracleType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleFactor", wireType)
			}
			m.ScaleFactor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleFactor |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChainlinkPriceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChainlinkPriceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChainlinkPriceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeedId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeedId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Answer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Answer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PriceState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BandPriceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BandPriceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BandPriceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolveTime", wireType)
			}
			m.ResolveTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResolveTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request_ID", wireType)
			}
			m.Request_ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Request_ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PriceState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceFeedState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceFeedState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceFeedState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Base = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quote", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Quote = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PriceState == nil {
				m.PriceState = &PriceState{}
			}
			if err := m.PriceState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relayers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relayers = append(m.Relayers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProviderInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProviderInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProviderInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Provider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relayers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relayers = append(m.Relayers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProviderState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProviderState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProviderState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderInfo == nil {
				m.ProviderInfo = &ProviderInfo{}
			}
			if err := m.ProviderInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderPriceStates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderPriceStates = append(m.ProviderPriceStates, &ProviderPriceState{})
			if err := m.ProviderPriceStates[len(m.ProviderPriceStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProviderPriceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProviderPriceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProviderPriceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &PriceState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceFeedInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceFeedInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceFeedInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Base = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quote", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Quote = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceFeedPrice) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceFeedPrice: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceFeedPrice: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CoinbasePriceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CoinbasePriceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CoinbasePriceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PriceState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CumulativePrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CumulativePrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BandOracleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BandOracleRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BandOracleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			m.RequestId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleScriptId", wireType)
			}
			m.OracleScriptId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OracleScriptId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbols", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbols = append(m.Symbols, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AskCount", wireType)
			}
			m.AskCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AskCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinCount", wireType)
			}
			m.MinCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeLimit = append(m.FeeLimit, types.Coin{})
			if err := m.FeeLimit[len(m.FeeLimit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrepareGas", wireType)
			}
			m.PrepareGas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrepareGas |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecuteGas", wireType)
			}
			m.ExecuteGas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExecuteGas |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BandIBCParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BandIBCParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BandIBCParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BandIbcEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BandIbcEnabled = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcRequestInterval", wireType)
			}
			m.IbcRequestInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IbcRequestInterval |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcSourceChannel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IbcSourceChannel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IbcVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcPortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IbcPortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SymbolPriceTimestamp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SymbolPriceTimestamp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SymbolPriceTimestamp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Oracle", wireType)
			}
			m.Oracle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Oracle |= OracleType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymbolId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymbolId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LastPriceTimestamps) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LastPriceTimestamps: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastPriceTimestamps: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPriceTimestamps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastPriceTimestamps = append(m.LastPriceTimestamps, &SymbolPriceTimestamp{})
			if err := m.LastPriceTimestamps[len(m.LastPriceTimestamps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceRecords) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceRecords: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Oracle", wireType)
			}
			m.Oracle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Oracle |= OracleType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymbolId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymbolId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestPriceRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestPriceRecords = append(m.LatestPriceRecords, &PriceRecord{})
			if err := m.LatestPriceRecords[len(m.LatestPriceRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PriceRecord) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PriceRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PriceRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataStatistics) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetadataStatistics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataStatistics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupCount", wireType)
			}
			m.GroupCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordsSampleSize", wireType)
			}
			m.RecordsSampleSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordsSampleSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mean", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Mean.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Twap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Twap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstTimestamp", wireType)
			}
			m.FirstTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTimestamp", wireType)
			}
			m.LastTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MedianPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthOracle
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOracle
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MedianPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOracle(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOracle
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipOracle(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowOracle
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOracle
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthOracle
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupOracle
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthOracle
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthOracle        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowOracle          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupOracle = fmt.Errorf("proto: unexpected end of group")
)