protorev.pb.go

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

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	types1 "github.com/osmosis-labs/osmosis/v24/x/poolmanager/types"
	_ "github.com/osmosis-labs/osmosis/v24/x/txfees/types"
	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

// TokenPairArbRoutes tracks all of the hot routes for a given pair of tokens
type TokenPairArbRoutes struct {
	// Stores all of the possible hot paths for a given pair of tokens
	ArbRoutes []Route `protobuf:"bytes,1,rep,name=arb_routes,json=arbRoutes,proto3" json:"arb_routes" yaml:"arb_routes"`
	// Token denomination of the first asset
	TokenIn string `protobuf:"bytes,2,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty" yaml:"token_in"`
	// Token denomination of the second asset
	TokenOut string `protobuf:"bytes,3,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty" yaml:"token_out"`
}

func (m *TokenPairArbRoutes) Reset()         { *m = TokenPairArbRoutes{} }
func (m *TokenPairArbRoutes) String() string { return proto.CompactTextString(m) }
func (*TokenPairArbRoutes) ProtoMessage()    {}
func (*TokenPairArbRoutes) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{0}
}
func (m *TokenPairArbRoutes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TokenPairArbRoutes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TokenPairArbRoutes.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 *TokenPairArbRoutes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenPairArbRoutes.Merge(m, src)
}
func (m *TokenPairArbRoutes) XXX_Size() int {
	return m.Size()
}
func (m *TokenPairArbRoutes) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenPairArbRoutes.DiscardUnknown(m)
}

var xxx_messageInfo_TokenPairArbRoutes proto.InternalMessageInfo

func (m *TokenPairArbRoutes) GetArbRoutes() []Route {
	if m != nil {
		return m.ArbRoutes
	}
	return nil
}

func (m *TokenPairArbRoutes) GetTokenIn() string {
	if m != nil {
		return m.TokenIn
	}
	return ""
}

func (m *TokenPairArbRoutes) GetTokenOut() string {
	if m != nil {
		return m.TokenOut
	}
	return ""
}

// Route is a hot route for a given pair of tokens
type Route struct {
	// The pool IDs that are traversed in the directed cyclic graph (traversed
	// left
	// -> right)
	Trades []Trade `protobuf:"bytes,1,rep,name=trades,proto3" json:"trades" yaml:"trades"`
	// The step size that will be used to find the optimal swap amount in the
	// binary search
	StepSize cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=step_size,json=stepSize,proto3,customtype=cosmossdk.io/math.Int" json:"step_size" yaml:"step_size"`
}

func (m *Route) Reset()         { *m = Route{} }
func (m *Route) String() string { return proto.CompactTextString(m) }
func (*Route) ProtoMessage()    {}
func (*Route) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{1}
}
func (m *Route) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Route) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Route.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 *Route) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Route.Merge(m, src)
}
func (m *Route) XXX_Size() int {
	return m.Size()
}
func (m *Route) XXX_DiscardUnknown() {
	xxx_messageInfo_Route.DiscardUnknown(m)
}

var xxx_messageInfo_Route proto.InternalMessageInfo

func (m *Route) GetTrades() []Trade {
	if m != nil {
		return m.Trades
	}
	return nil
}

// Trade is a single trade in a route
type Trade struct {
	// The pool id of the pool that is traded on
	Pool uint64 `protobuf:"varint,1,opt,name=pool,proto3" json:"pool,omitempty" yaml:"pool"`
	// The denom of the token that is traded
	TokenIn string `protobuf:"bytes,2,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty" yaml:"token_in"`
	// The denom of the token that is received
	TokenOut string `protobuf:"bytes,3,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty" yaml:"token_out"`
}

func (m *Trade) Reset()         { *m = Trade{} }
func (m *Trade) String() string { return proto.CompactTextString(m) }
func (*Trade) ProtoMessage()    {}
func (*Trade) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{2}
}
func (m *Trade) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Trade) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Trade.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 *Trade) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Trade.Merge(m, src)
}
func (m *Trade) XXX_Size() int {
	return m.Size()
}
func (m *Trade) XXX_DiscardUnknown() {
	xxx_messageInfo_Trade.DiscardUnknown(m)
}

var xxx_messageInfo_Trade proto.InternalMessageInfo

func (m *Trade) GetPool() uint64 {
	if m != nil {
		return m.Pool
	}
	return 0
}

func (m *Trade) GetTokenIn() string {
	if m != nil {
		return m.TokenIn
	}
	return ""
}

func (m *Trade) GetTokenOut() string {
	if m != nil {
		return m.TokenOut
	}
	return ""
}

// RouteStatistics contains the number of trades the module has executed after a
// swap on a given route and the profits from the trades
type RouteStatistics struct {
	// profits is the total profit from all trades on this route
	Profits []types.Coin `protobuf:"bytes,1,rep,name=profits,proto3" json:"profits" yaml:"profits"`
	// number_of_trades is the number of trades the module has executed using this
	// route
	NumberOfTrades cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=number_of_trades,json=numberOfTrades,proto3,customtype=cosmossdk.io/math.Int" json:"number_of_trades" yaml:"number_of_trades"`
	// route is the route that was used (pool ids along the arbitrage route)
	Route []uint64 `protobuf:"varint,3,rep,packed,name=route,proto3" json:"route,omitempty" yaml:"route"`
}

func (m *RouteStatistics) Reset()         { *m = RouteStatistics{} }
func (m *RouteStatistics) String() string { return proto.CompactTextString(m) }
func (*RouteStatistics) ProtoMessage()    {}
func (*RouteStatistics) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{3}
}
func (m *RouteStatistics) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteStatistics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RouteStatistics.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 *RouteStatistics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteStatistics.Merge(m, src)
}
func (m *RouteStatistics) XXX_Size() int {
	return m.Size()
}
func (m *RouteStatistics) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteStatistics.DiscardUnknown(m)
}

var xxx_messageInfo_RouteStatistics proto.InternalMessageInfo

func (m *RouteStatistics) GetProfits() []types.Coin {
	if m != nil {
		return m.Profits
	}
	return nil
}

func (m *RouteStatistics) GetRoute() []uint64 {
	if m != nil {
		return m.Route
	}
	return nil
}

// PoolWeights contains the weights of all of the different pool types. This
// distinction is made and necessary because the execution time ranges
// significantly between the different pool types. Each weight roughly
// corresponds to the amount of time (in ms) it takes to execute a swap on that
// pool type.
//
// DEPRECATED: This field is deprecated and will be removed in the next
// release. It is replaced by the `info_by_pool_type` field.
type PoolWeights struct {
	// The weight of a stableswap pool
	StableWeight uint64 `protobuf:"varint,1,opt,name=stable_weight,json=stableWeight,proto3" json:"stable_weight,omitempty" yaml:"stable_weight"`
	// The weight of a balancer pool
	BalancerWeight uint64 `protobuf:"varint,2,opt,name=balancer_weight,json=balancerWeight,proto3" json:"balancer_weight,omitempty" yaml:"balancer_weight"`
	// The weight of a concentrated pool
	ConcentratedWeight uint64 `protobuf:"varint,3,opt,name=concentrated_weight,json=concentratedWeight,proto3" json:"concentrated_weight,omitempty" yaml:"concentrated_weight"`
	// The weight of a cosmwasm pool
	CosmwasmWeight uint64 `protobuf:"varint,4,opt,name=cosmwasm_weight,json=cosmwasmWeight,proto3" json:"cosmwasm_weight,omitempty" yaml:"cosmwasm_weight"`
}

func (m *PoolWeights) Reset()         { *m = PoolWeights{} }
func (m *PoolWeights) String() string { return proto.CompactTextString(m) }
func (*PoolWeights) ProtoMessage()    {}
func (*PoolWeights) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{4}
}
func (m *PoolWeights) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PoolWeights) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PoolWeights.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 *PoolWeights) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoolWeights.Merge(m, src)
}
func (m *PoolWeights) XXX_Size() int {
	return m.Size()
}
func (m *PoolWeights) XXX_DiscardUnknown() {
	xxx_messageInfo_PoolWeights.DiscardUnknown(m)
}

var xxx_messageInfo_PoolWeights proto.InternalMessageInfo

func (m *PoolWeights) GetStableWeight() uint64 {
	if m != nil {
		return m.StableWeight
	}
	return 0
}

func (m *PoolWeights) GetBalancerWeight() uint64 {
	if m != nil {
		return m.BalancerWeight
	}
	return 0
}

func (m *PoolWeights) GetConcentratedWeight() uint64 {
	if m != nil {
		return m.ConcentratedWeight
	}
	return 0
}

func (m *PoolWeights) GetCosmwasmWeight() uint64 {
	if m != nil {
		return m.CosmwasmWeight
	}
	return 0
}

// InfoByPoolType contains information pertaining to how expensive (in terms of
// gas and time) it is to execute a swap on a given pool type. This distinction
// is made and necessary because the execution time ranges significantly between
// the different pool types.
type InfoByPoolType struct {
	// The stable pool info
	Stable StablePoolInfo `protobuf:"bytes,1,opt,name=stable,proto3" json:"stable" yaml:"stable"`
	// The balancer pool info
	Balancer BalancerPoolInfo `protobuf:"bytes,2,opt,name=balancer,proto3" json:"balancer" yaml:"balancer"`
	// The concentrated pool info
	Concentrated ConcentratedPoolInfo `protobuf:"bytes,3,opt,name=concentrated,proto3" json:"concentrated" yaml:"concentrated"`
	// The cosmwasm pool info
	Cosmwasm CosmwasmPoolInfo `protobuf:"bytes,4,opt,name=cosmwasm,proto3" json:"cosmwasm" yaml:"cosmwasm"`
}

func (m *InfoByPoolType) Reset()         { *m = InfoByPoolType{} }
func (m *InfoByPoolType) String() string { return proto.CompactTextString(m) }
func (*InfoByPoolType) ProtoMessage()    {}
func (*InfoByPoolType) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{5}
}
func (m *InfoByPoolType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InfoByPoolType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InfoByPoolType.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 *InfoByPoolType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InfoByPoolType.Merge(m, src)
}
func (m *InfoByPoolType) XXX_Size() int {
	return m.Size()
}
func (m *InfoByPoolType) XXX_DiscardUnknown() {
	xxx_messageInfo_InfoByPoolType.DiscardUnknown(m)
}

var xxx_messageInfo_InfoByPoolType proto.InternalMessageInfo

func (m *InfoByPoolType) GetStable() StablePoolInfo {
	if m != nil {
		return m.Stable
	}
	return StablePoolInfo{}
}

func (m *InfoByPoolType) GetBalancer() BalancerPoolInfo {
	if m != nil {
		return m.Balancer
	}
	return BalancerPoolInfo{}
}

func (m *InfoByPoolType) GetConcentrated() ConcentratedPoolInfo {
	if m != nil {
		return m.Concentrated
	}
	return ConcentratedPoolInfo{}
}

func (m *InfoByPoolType) GetCosmwasm() CosmwasmPoolInfo {
	if m != nil {
		return m.Cosmwasm
	}
	return CosmwasmPoolInfo{}
}

// StablePoolInfo contains meta data pertaining to a stableswap pool type.
type StablePoolInfo struct {
	// The weight of a stableswap pool
	Weight uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty" yaml:"weight"`
}

func (m *StablePoolInfo) Reset()         { *m = StablePoolInfo{} }
func (m *StablePoolInfo) String() string { return proto.CompactTextString(m) }
func (*StablePoolInfo) ProtoMessage()    {}
func (*StablePoolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{6}
}
func (m *StablePoolInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StablePoolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StablePoolInfo.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 *StablePoolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StablePoolInfo.Merge(m, src)
}
func (m *StablePoolInfo) XXX_Size() int {
	return m.Size()
}
func (m *StablePoolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_StablePoolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_StablePoolInfo proto.InternalMessageInfo

func (m *StablePoolInfo) GetWeight() uint64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

// BalancerPoolInfo contains meta data pertaining to a balancer pool type.
type BalancerPoolInfo struct {
	// The weight of a balancer pool
	Weight uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty" yaml:"weight"`
}

func (m *BalancerPoolInfo) Reset()         { *m = BalancerPoolInfo{} }
func (m *BalancerPoolInfo) String() string { return proto.CompactTextString(m) }
func (*BalancerPoolInfo) ProtoMessage()    {}
func (*BalancerPoolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{7}
}
func (m *BalancerPoolInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BalancerPoolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BalancerPoolInfo.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 *BalancerPoolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BalancerPoolInfo.Merge(m, src)
}
func (m *BalancerPoolInfo) XXX_Size() int {
	return m.Size()
}
func (m *BalancerPoolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BalancerPoolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BalancerPoolInfo proto.InternalMessageInfo

func (m *BalancerPoolInfo) GetWeight() uint64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

// ConcentratedPoolInfo contains meta data pertaining to a concentrated pool
// type.
type ConcentratedPoolInfo struct {
	// The weight of a concentrated pool
	Weight uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty" yaml:"weight"`
	// The maximum number of ticks we can move when rebalancing
	MaxTicksCrossed uint64 `protobuf:"varint,2,opt,name=max_ticks_crossed,json=maxTicksCrossed,proto3" json:"max_ticks_crossed,omitempty" yaml:"max_ticks_crossed"`
}

func (m *ConcentratedPoolInfo) Reset()         { *m = ConcentratedPoolInfo{} }
func (m *ConcentratedPoolInfo) String() string { return proto.CompactTextString(m) }
func (*ConcentratedPoolInfo) ProtoMessage()    {}
func (*ConcentratedPoolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{8}
}
func (m *ConcentratedPoolInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConcentratedPoolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConcentratedPoolInfo.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 *ConcentratedPoolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConcentratedPoolInfo.Merge(m, src)
}
func (m *ConcentratedPoolInfo) XXX_Size() int {
	return m.Size()
}
func (m *ConcentratedPoolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ConcentratedPoolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ConcentratedPoolInfo proto.InternalMessageInfo

func (m *ConcentratedPoolInfo) GetWeight() uint64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *ConcentratedPoolInfo) GetMaxTicksCrossed() uint64 {
	if m != nil {
		return m.MaxTicksCrossed
	}
	return 0
}

// CosmwasmPoolInfo contains meta data pertaining to a cosmwasm pool type.
type CosmwasmPoolInfo struct {
	// The weight of a cosmwasm pool (by contract address)
	WeightMaps []WeightMap `protobuf:"bytes,1,rep,name=weight_maps,json=weightMaps,proto3" json:"weight_maps" yaml:"weight_maps"`
}

func (m *CosmwasmPoolInfo) Reset()         { *m = CosmwasmPoolInfo{} }
func (m *CosmwasmPoolInfo) String() string { return proto.CompactTextString(m) }
func (*CosmwasmPoolInfo) ProtoMessage()    {}
func (*CosmwasmPoolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{9}
}
func (m *CosmwasmPoolInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CosmwasmPoolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CosmwasmPoolInfo.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 *CosmwasmPoolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CosmwasmPoolInfo.Merge(m, src)
}
func (m *CosmwasmPoolInfo) XXX_Size() int {
	return m.Size()
}
func (m *CosmwasmPoolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CosmwasmPoolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CosmwasmPoolInfo proto.InternalMessageInfo

func (m *CosmwasmPoolInfo) GetWeightMaps() []WeightMap {
	if m != nil {
		return m.WeightMaps
	}
	return nil
}

// WeightMap maps a contract address to a weight. The weight of an address
// corresponds to the amount of ms required to execute a swap on that contract.
type WeightMap struct {
	// The weight of a cosmwasm pool (by contract address)
	Weight uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty" yaml:"weight"`
	// The contract address
	ContractAddress string `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"`
}

func (m *WeightMap) Reset()         { *m = WeightMap{} }
func (m *WeightMap) String() string { return proto.CompactTextString(m) }
func (*WeightMap) ProtoMessage()    {}
func (*WeightMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{10}
}
func (m *WeightMap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WeightMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WeightMap.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 *WeightMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WeightMap.Merge(m, src)
}
func (m *WeightMap) XXX_Size() int {
	return m.Size()
}
func (m *WeightMap) XXX_DiscardUnknown() {
	xxx_messageInfo_WeightMap.DiscardUnknown(m)
}

var xxx_messageInfo_WeightMap proto.InternalMessageInfo

func (m *WeightMap) GetWeight() uint64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *WeightMap) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// BaseDenom represents a single base denom that the module uses for its
// arbitrage trades. It contains the denom name alongside the step size of the
// binary search that is used to find the optimal swap amount
type BaseDenom struct {
	// The denom i.e. name of the base denom (ex. uosmo)
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
	// The step size of the binary search that is used to find the optimal swap
	// amount
	StepSize cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=step_size,json=stepSize,proto3,customtype=cosmossdk.io/math.Int" json:"step_size" yaml:"step_size"`
}

func (m *BaseDenom) Reset()         { *m = BaseDenom{} }
func (m *BaseDenom) String() string { return proto.CompactTextString(m) }
func (*BaseDenom) ProtoMessage()    {}
func (*BaseDenom) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{11}
}
func (m *BaseDenom) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BaseDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BaseDenom.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 *BaseDenom) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseDenom.Merge(m, src)
}
func (m *BaseDenom) XXX_Size() int {
	return m.Size()
}
func (m *BaseDenom) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseDenom.DiscardUnknown(m)
}

var xxx_messageInfo_BaseDenom proto.InternalMessageInfo

func (m *BaseDenom) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

// BaseDenoms represents all of the base denoms that the module uses for its
// arbitrage trades.
type BaseDenoms struct {
	BaseDenoms []BaseDenom `protobuf:"bytes,1,rep,name=base_denoms,json=baseDenoms,proto3" json:"base_denoms" yaml:"base_denoms"`
}

func (m *BaseDenoms) Reset()         { *m = BaseDenoms{} }
func (m *BaseDenoms) String() string { return proto.CompactTextString(m) }
func (*BaseDenoms) ProtoMessage()    {}
func (*BaseDenoms) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{12}
}
func (m *BaseDenoms) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BaseDenoms) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BaseDenoms.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 *BaseDenoms) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseDenoms.Merge(m, src)
}
func (m *BaseDenoms) XXX_Size() int {
	return m.Size()
}
func (m *BaseDenoms) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseDenoms.DiscardUnknown(m)
}

var xxx_messageInfo_BaseDenoms proto.InternalMessageInfo

func (m *BaseDenoms) GetBaseDenoms() []BaseDenom {
	if m != nil {
		return m.BaseDenoms
	}
	return nil
}

type AllProtocolRevenue struct {
	TakerFeesTracker types1.TakerFeesTracker `protobuf:"bytes,1,opt,name=taker_fees_tracker,json=takerFeesTracker,proto3" json:"taker_fees_tracker" yaml:"taker_fees_tracker"`
	CyclicArbTracker CyclicArbTracker        `protobuf:"bytes,3,opt,name=cyclic_arb_tracker,json=cyclicArbTracker,proto3" json:"cyclic_arb_tracker" yaml:"cyclic_arb_tracker"`
}

func (m *AllProtocolRevenue) Reset()         { *m = AllProtocolRevenue{} }
func (m *AllProtocolRevenue) String() string { return proto.CompactTextString(m) }
func (*AllProtocolRevenue) ProtoMessage()    {}
func (*AllProtocolRevenue) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{13}
}
func (m *AllProtocolRevenue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AllProtocolRevenue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AllProtocolRevenue.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 *AllProtocolRevenue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AllProtocolRevenue.Merge(m, src)
}
func (m *AllProtocolRevenue) XXX_Size() int {
	return m.Size()
}
func (m *AllProtocolRevenue) XXX_DiscardUnknown() {
	xxx_messageInfo_AllProtocolRevenue.DiscardUnknown(m)
}

var xxx_messageInfo_AllProtocolRevenue proto.InternalMessageInfo

func (m *AllProtocolRevenue) GetTakerFeesTracker() types1.TakerFeesTracker {
	if m != nil {
		return m.TakerFeesTracker
	}
	return types1.TakerFeesTracker{}
}

func (m *AllProtocolRevenue) GetCyclicArbTracker() CyclicArbTracker {
	if m != nil {
		return m.CyclicArbTracker
	}
	return CyclicArbTracker{}
}

type CyclicArbTracker struct {
	CyclicArb                  []types.Coin `protobuf:"bytes,1,rep,name=cyclic_arb,json=cyclicArb,proto3" json:"cyclic_arb"`
	HeightAccountingStartsFrom int64        `protobuf:"varint,2,opt,name=height_accounting_starts_from,json=heightAccountingStartsFrom,proto3" json:"height_accounting_starts_from,omitempty" yaml:"height_accounting_starts_from"`
}

func (m *CyclicArbTracker) Reset()         { *m = CyclicArbTracker{} }
func (m *CyclicArbTracker) String() string { return proto.CompactTextString(m) }
func (*CyclicArbTracker) ProtoMessage()    {}
func (*CyclicArbTracker) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e9f2391fd9fec01, []int{14}
}
func (m *CyclicArbTracker) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CyclicArbTracker) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CyclicArbTracker.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 *CyclicArbTracker) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CyclicArbTracker.Merge(m, src)
}
func (m *CyclicArbTracker) XXX_Size() int {
	return m.Size()
}
func (m *CyclicArbTracker) XXX_DiscardUnknown() {
	xxx_messageInfo_CyclicArbTracker.DiscardUnknown(m)
}

var xxx_messageInfo_CyclicArbTracker proto.InternalMessageInfo

func (m *CyclicArbTracker) GetCyclicArb() []types.Coin {
	if m != nil {
		return m.CyclicArb
	}
	return nil
}

func (m *CyclicArbTracker) GetHeightAccountingStartsFrom() int64 {
	if m != nil {
		return m.HeightAccountingStartsFrom
	}
	return 0
}

func init() {
	proto.RegisterType((*TokenPairArbRoutes)(nil), "osmosis.protorev.v1beta1.TokenPairArbRoutes")
	proto.RegisterType((*Route)(nil), "osmosis.protorev.v1beta1.Route")
	proto.RegisterType((*Trade)(nil), "osmosis.protorev.v1beta1.Trade")
	proto.RegisterType((*RouteStatistics)(nil), "osmosis.protorev.v1beta1.RouteStatistics")
	proto.RegisterType((*PoolWeights)(nil), "osmosis.protorev.v1beta1.PoolWeights")
	proto.RegisterType((*InfoByPoolType)(nil), "osmosis.protorev.v1beta1.InfoByPoolType")
	proto.RegisterType((*StablePoolInfo)(nil), "osmosis.protorev.v1beta1.StablePoolInfo")
	proto.RegisterType((*BalancerPoolInfo)(nil), "osmosis.protorev.v1beta1.BalancerPoolInfo")
	proto.RegisterType((*ConcentratedPoolInfo)(nil), "osmosis.protorev.v1beta1.ConcentratedPoolInfo")
	proto.RegisterType((*CosmwasmPoolInfo)(nil), "osmosis.protorev.v1beta1.CosmwasmPoolInfo")
	proto.RegisterType((*WeightMap)(nil), "osmosis.protorev.v1beta1.WeightMap")
	proto.RegisterType((*BaseDenom)(nil), "osmosis.protorev.v1beta1.BaseDenom")
	proto.RegisterType((*BaseDenoms)(nil), "osmosis.protorev.v1beta1.BaseDenoms")
	proto.RegisterType((*AllProtocolRevenue)(nil), "osmosis.protorev.v1beta1.AllProtocolRevenue")
	proto.RegisterType((*CyclicArbTracker)(nil), "osmosis.protorev.v1beta1.CyclicArbTracker")
}

func init() {
	proto.RegisterFile("osmosis/protorev/v1beta1/protorev.proto", fileDescriptor_1e9f2391fd9fec01)
}

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

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

	that1, ok := that.(*TokenPairArbRoutes)
	if !ok {
		that2, ok := that.(TokenPairArbRoutes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.ArbRoutes) != len(that1.ArbRoutes) {
		return false
	}
	for i := range this.ArbRoutes {
		if !this.ArbRoutes[i].Equal(&that1.ArbRoutes[i]) {
			return false
		}
	}
	if this.TokenIn != that1.TokenIn {
		return false
	}
	if this.TokenOut != that1.TokenOut {
		return false
	}
	return true
}
func (this *Route) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Route)
	if !ok {
		that2, ok := that.(Route)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Trades) != len(that1.Trades) {
		return false
	}
	for i := range this.Trades {
		if !this.Trades[i].Equal(&that1.Trades[i]) {
			return false
		}
	}
	if !this.StepSize.Equal(that1.StepSize) {
		return false
	}
	return true
}
func (this *Trade) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Trade)
	if !ok {
		that2, ok := that.(Trade)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Pool != that1.Pool {
		return false
	}
	if this.TokenIn != that1.TokenIn {
		return false
	}
	if this.TokenOut != that1.TokenOut {
		return false
	}
	return true
}
func (m *TokenPairArbRoutes) 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 *TokenPairArbRoutes) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TokenPairArbRoutes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TokenOut) > 0 {
		i -= len(m.TokenOut)
		copy(dAtA[i:], m.TokenOut)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.TokenOut)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TokenIn) > 0 {
		i -= len(m.TokenIn)
		copy(dAtA[i:], m.TokenIn)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.TokenIn)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ArbRoutes) > 0 {
		for iNdEx := len(m.ArbRoutes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ArbRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProtorev(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Route) 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 *Route) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Trade) 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 *Trade) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Trade) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TokenOut) > 0 {
		i -= len(m.TokenOut)
		copy(dAtA[i:], m.TokenOut)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.TokenOut)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TokenIn) > 0 {
		i -= len(m.TokenIn)
		copy(dAtA[i:], m.TokenIn)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.TokenIn)))
		i--
		dAtA[i] = 0x12
	}
	if m.Pool != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.Pool))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RouteStatistics) 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 *RouteStatistics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteStatistics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Route) > 0 {
		dAtA2 := make([]byte, len(m.Route)*10)
		var j1 int
		for _, num := range m.Route {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintProtorev(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.NumberOfTrades.Size()
		i -= size
		if _, err := m.NumberOfTrades.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Profits) > 0 {
		for iNdEx := len(m.Profits) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Profits[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProtorev(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PoolWeights) 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 *PoolWeights) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PoolWeights) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CosmwasmWeight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.CosmwasmWeight))
		i--
		dAtA[i] = 0x20
	}
	if m.ConcentratedWeight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.ConcentratedWeight))
		i--
		dAtA[i] = 0x18
	}
	if m.BalancerWeight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.BalancerWeight))
		i--
		dAtA[i] = 0x10
	}
	if m.StableWeight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.StableWeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InfoByPoolType) 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 *InfoByPoolType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InfoByPoolType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Cosmwasm.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.Concentrated.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Balancer.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Stable.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *StablePoolInfo) 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 *StablePoolInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StablePoolInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Weight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BalancerPoolInfo) 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 *BalancerPoolInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BalancerPoolInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Weight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ConcentratedPoolInfo) 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 *ConcentratedPoolInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConcentratedPoolInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxTicksCrossed != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.MaxTicksCrossed))
		i--
		dAtA[i] = 0x10
	}
	if m.Weight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CosmwasmPoolInfo) 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 *CosmwasmPoolInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *WeightMap) 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 *WeightMap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WeightMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContractAddress) > 0 {
		i -= len(m.ContractAddress)
		copy(dAtA[i:], m.ContractAddress)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.ContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if m.Weight != 0 {
		i = encodeVarintProtorev(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BaseDenom) 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 *BaseDenom) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BaseDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.StepSize.Size()
		i -= size
		if _, err := m.StepSize.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintProtorev(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BaseDenoms) 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 *BaseDenoms) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *AllProtocolRevenue) 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 *AllProtocolRevenue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AllProtocolRevenue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.CyclicArbTracker.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.TakerFeesTracker.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtorev(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CyclicArbTracker) 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 *CyclicArbTracker) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintProtorev(dAtA []byte, offset int, v uint64) int {
	offset -= sovProtorev(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TokenPairArbRoutes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ArbRoutes) > 0 {
		for _, e := range m.ArbRoutes {
			l = e.Size()
			n += 1 + l + sovProtorev(uint64(l))
		}
	}
	l = len(m.TokenIn)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	l = len(m.TokenOut)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	return n
}

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

func (m *Trade) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pool != 0 {
		n += 1 + sovProtorev(uint64(m.Pool))
	}
	l = len(m.TokenIn)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	l = len(m.TokenOut)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	return n
}

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

func (m *PoolWeights) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StableWeight != 0 {
		n += 1 + sovProtorev(uint64(m.StableWeight))
	}
	if m.BalancerWeight != 0 {
		n += 1 + sovProtorev(uint64(m.BalancerWeight))
	}
	if m.ConcentratedWeight != 0 {
		n += 1 + sovProtorev(uint64(m.ConcentratedWeight))
	}
	if m.CosmwasmWeight != 0 {
		n += 1 + sovProtorev(uint64(m.CosmwasmWeight))
	}
	return n
}

func (m *InfoByPoolType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Stable.Size()
	n += 1 + l + sovProtorev(uint64(l))
	l = m.Balancer.Size()
	n += 1 + l + sovProtorev(uint64(l))
	l = m.Concentrated.Size()
	n += 1 + l + sovProtorev(uint64(l))
	l = m.Cosmwasm.Size()
	n += 1 + l + sovProtorev(uint64(l))
	return n
}

func (m *StablePoolInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Weight != 0 {
		n += 1 + sovProtorev(uint64(m.Weight))
	}
	return n
}

func (m *BalancerPoolInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Weight != 0 {
		n += 1 + sovProtorev(uint64(m.Weight))
	}
	return n
}

func (m *ConcentratedPoolInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Weight != 0 {
		n += 1 + sovProtorev(uint64(m.Weight))
	}
	if m.MaxTicksCrossed != 0 {
		n += 1 + sovProtorev(uint64(m.MaxTicksCrossed))
	}
	return n
}

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

func (m *WeightMap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Weight != 0 {
		n += 1 + sovProtorev(uint64(m.Weight))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	return n
}

func (m *BaseDenom) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovProtorev(uint64(l))
	}
	l = m.StepSize.Size()
	n += 1 + l + sovProtorev(uint64(l))
	return n
}

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

func (m *AllProtocolRevenue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TakerFeesTracker.Size()
	n += 1 + l + sovProtorev(uint64(l))
	l = m.CyclicArbTracker.Size()
	n += 1 + l + sovProtorev(uint64(l))
	return n
}

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

func sovProtorev(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProtorev(x uint64) (n int) {
	return sovProtorev(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TokenPairArbRoutes) 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 ErrIntOverflowProtorev
			}
			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: TokenPairArbRoutes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TokenPairArbRoutes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArbRoutes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArbRoutes = append(m.ArbRoutes, Route{})
			if err := m.ArbRoutes[len(m.ArbRoutes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenIn", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenOut", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenOut = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Route) 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 ErrIntOverflowProtorev
			}
			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: Route: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Route: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Trades", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Trades = append(m.Trades, Trade{})
			if err := m.Trades[len(m.Trades)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StepSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Trade) 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 ErrIntOverflowProtorev
			}
			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: Trade: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Trade: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			m.Pool = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pool |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenIn", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenIn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenOut", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenOut = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteStatistics) 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 ErrIntOverflowProtorev
			}
			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: RouteStatistics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteStatistics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Profits", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Profits = append(m.Profits, types.Coin{})
			if err := m.Profits[len(m.Profits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfTrades", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NumberOfTrades.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtorev
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Route = append(m.Route, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtorev
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthProtorev
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthProtorev
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Route) == 0 {
					m.Route = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProtorev
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Route = append(m.Route, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Route", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PoolWeights) 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 ErrIntOverflowProtorev
			}
			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: PoolWeights: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PoolWeights: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StableWeight", wireType)
			}
			m.StableWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StableWeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalancerWeight", wireType)
			}
			m.BalancerWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BalancerWeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConcentratedWeight", wireType)
			}
			m.ConcentratedWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConcentratedWeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmwasmWeight", wireType)
			}
			m.CosmwasmWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CosmwasmWeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InfoByPoolType) 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 ErrIntOverflowProtorev
			}
			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: InfoByPoolType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InfoByPoolType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Stable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balancer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Balancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Concentrated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Concentrated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cosmwasm", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Cosmwasm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StablePoolInfo) 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 ErrIntOverflowProtorev
			}
			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: StablePoolInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StablePoolInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BalancerPoolInfo) 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 ErrIntOverflowProtorev
			}
			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: BalancerPoolInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BalancerPoolInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConcentratedPoolInfo) 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 ErrIntOverflowProtorev
			}
			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: ConcentratedPoolInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConcentratedPoolInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTicksCrossed", wireType)
			}
			m.MaxTicksCrossed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTicksCrossed |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CosmwasmPoolInfo) 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 ErrIntOverflowProtorev
			}
			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: CosmwasmPoolInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CosmwasmPoolInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeightMaps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WeightMaps = append(m.WeightMaps, WeightMap{})
			if err := m.WeightMaps[len(m.WeightMaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WeightMap) 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 ErrIntOverflowProtorev
			}
			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: WeightMap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WeightMap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BaseDenom) 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 ErrIntOverflowProtorev
			}
			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: BaseDenom: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BaseDenom: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepSize", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				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 ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StepSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BaseDenoms) 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 ErrIntOverflowProtorev
			}
			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: BaseDenoms: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BaseDenoms: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenoms", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BaseDenoms = append(m.BaseDenoms, BaseDenom{})
			if err := m.BaseDenoms[len(m.BaseDenoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AllProtocolRevenue) 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 ErrIntOverflowProtorev
			}
			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: AllProtocolRevenue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AllProtocolRevenue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TakerFeesTracker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TakerFeesTracker.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CyclicArbTracker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CyclicArbTracker.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CyclicArbTracker) 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 ErrIntOverflowProtorev
			}
			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: CyclicArbTracker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CyclicArbTracker: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CyclicArb", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtorev
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtorev
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CyclicArb = append(m.CyclicArb, types.Coin{})
			if err := m.CyclicArb[len(m.CyclicArb)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeightAccountingStartsFrom", wireType)
			}
			m.HeightAccountingStartsFrom = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtorev
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeightAccountingStartsFrom |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtorev(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProtorev
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipProtorev(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, ErrIntOverflowProtorev
			}
			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, ErrIntOverflowProtorev
				}
				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, ErrIntOverflowProtorev
				}
				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, ErrInvalidLengthProtorev
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupProtorev
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthProtorev
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthProtorev        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtorev          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProtorev = fmt.Errorf("proto: unexpected end of group")
)