go-cyber/x/liquidity/types/liquidity.pb.go

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

package types

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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

// Structure for the pool type to distinguish the characteristics of the reserve
// pools.
type PoolType struct {
	// This is the id of the pool_type that is used as pool_type_id for pool
	// creation. In this version, only pool-type-id 1 is supported.
	// {"id":1,"name":"ConstantProductLiquidityPool","min_reserve_coin_num":2,"max_reserve_coin_num":2,"description":""}
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id"`
	// name of the pool type.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	// minimum number of reserveCoins for LiquidityPoolType, only 2 reserve coins
	// are supported.
	MinReserveCoinNum uint32 `protobuf:"varint,3,opt,name=min_reserve_coin_num,json=minReserveCoinNum,proto3" json:"min_reserve_coin_num,omitempty" yaml:"min_reserve_coin_num"`
	// maximum number of reserveCoins for LiquidityPoolType, only 2 reserve coins
	// are supported.
	MaxReserveCoinNum uint32 `protobuf:"varint,4,opt,name=max_reserve_coin_num,json=maxReserveCoinNum,proto3" json:"max_reserve_coin_num,omitempty" yaml:"max_reserve_coin_num"`
	// description of the pool type.
	Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
}

func (m *PoolType) Reset()         { *m = PoolType{} }
func (m *PoolType) String() string { return proto.CompactTextString(m) }
func (*PoolType) ProtoMessage()    {}
func (*PoolType) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{0}
}

func (m *PoolType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *PoolType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PoolType.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 *PoolType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoolType.Merge(m, src)
}

func (m *PoolType) XXX_Size() int {
	return m.Size()
}

func (m *PoolType) XXX_DiscardUnknown() {
	xxx_messageInfo_PoolType.DiscardUnknown(m)
}

var xxx_messageInfo_PoolType proto.InternalMessageInfo

// Params defines the parameters for the liquidity module.
type Params struct {
	// list of available pool types
	PoolTypes []PoolType `protobuf:"bytes,1,rep,name=pool_types,json=poolTypes,proto3" json:"pool_types" yaml:"pool_types"`
	// Minimum number of coins to be deposited to the liquidity pool on pool
	// creation.
	MinInitDepositAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=min_init_deposit_amount,json=minInitDepositAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_init_deposit_amount" yaml:"min_init_deposit_amount"`
	// Initial mint amount of pool coins upon pool creation.
	InitPoolCoinMintAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=init_pool_coin_mint_amount,json=initPoolCoinMintAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"init_pool_coin_mint_amount" yaml:"init_pool_coin_mint_amount"`
	// Limit the size of each liquidity pool to minimize risk. In development, set
	// to 0 for no limit. In production, set a limit.
	MaxReserveCoinAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=max_reserve_coin_amount,json=maxReserveCoinAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_reserve_coin_amount" yaml:"max_reserve_coin_amount"`
	// Fee paid to create a Liquidity Pool. Set a fee to prevent spamming.
	PoolCreationFee github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,5,rep,name=pool_creation_fee,json=poolCreationFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"pool_creation_fee" yaml:"pool_creation_fee"`
	// Swap fee rate for every executed swap.
	SwapFeeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=swap_fee_rate,json=swapFeeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"swap_fee_rate" yaml:"swap_fee_rate"`
	// Reserve coin withdrawal with less proportion by withdrawFeeRate.
	WithdrawFeeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=withdraw_fee_rate,json=withdrawFeeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"withdraw_fee_rate" yaml:"withdraw_fee_rate"`
	// Maximum ratio of reserve coins that can be ordered at a swap order.
	MaxOrderAmountRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=max_order_amount_ratio,json=maxOrderAmountRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_order_amount_ratio" yaml:"max_order_amount_ratio"`
	// The smallest unit batch height for every liquidity pool.
	UnitBatchHeight uint32 `protobuf:"varint,9,opt,name=unit_batch_height,json=unitBatchHeight,proto3" json:"unit_batch_height,omitempty" yaml:"unit_batch_height"`
	// Circuit breaker enables or disables transaction messages in liquidity
	// module.
	CircuitBreakerEnabled bool `protobuf:"varint,10,opt,name=circuit_breaker_enabled,json=circuitBreakerEnabled,proto3" json:"circuit_breaker_enabled,omitempty" yaml:"circuit_breaker_enabled"`
}

func (m *Params) Reset()      { *m = Params{} }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{1}
}

func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}

func (m *Params) XXX_Size() int {
	return m.Size()
}

func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

// Pool defines the liquidity pool that contains pool information.
type Pool struct {
	// id of the pool
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id" yaml:"id"`
	// id of the pool_type
	TypeId uint32 `protobuf:"varint,2,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty" yaml:"type_id"`
	// denoms of reserve coin pair of the pool
	ReserveCoinDenoms []string `protobuf:"bytes,3,rep,name=reserve_coin_denoms,json=reserveCoinDenoms,proto3" json:"reserve_coin_denoms,omitempty" yaml:"reserve_coin_denoms"`
	// reserve account address of the pool
	ReserveAccountAddress string `protobuf:"bytes,4,opt,name=reserve_account_address,json=reserveAccountAddress,proto3" json:"reserve_account_address,omitempty" yaml:"reserve_account_address"`
	// denom of pool coin of the pool
	PoolCoinDenom string `protobuf:"bytes,5,opt,name=pool_coin_denom,json=poolCoinDenom,proto3" json:"pool_coin_denom,omitempty" yaml:"pool_coin_denom"`
}

func (m *Pool) Reset()         { *m = Pool{} }
func (m *Pool) String() string { return proto.CompactTextString(m) }
func (*Pool) ProtoMessage()    {}
func (*Pool) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{2}
}

func (m *Pool) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Pool.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 *Pool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pool.Merge(m, src)
}

func (m *Pool) XXX_Size() int {
	return m.Size()
}

func (m *Pool) XXX_DiscardUnknown() {
	xxx_messageInfo_Pool.DiscardUnknown(m)
}

var xxx_messageInfo_Pool proto.InternalMessageInfo

// Metadata for the state of each pool for invariant checking after genesis
// export or import.
type PoolMetadata struct {
	// id of the pool
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id" yaml:"pool_id"`
	// pool coin issued at the pool
	PoolCoinTotalSupply types.Coin `protobuf:"bytes,2,opt,name=pool_coin_total_supply,json=poolCoinTotalSupply,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"pool_coin_total_supply" yaml:"pool_coin"`
	// reserve coins deposited in the pool
	ReserveCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=reserve_coins,json=reserveCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"reserve_coins" yaml:"deposit_coins"`
}

func (m *PoolMetadata) Reset()         { *m = PoolMetadata{} }
func (m *PoolMetadata) String() string { return proto.CompactTextString(m) }
func (*PoolMetadata) ProtoMessage()    {}
func (*PoolMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{3}
}

func (m *PoolMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *PoolMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PoolMetadata.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 *PoolMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoolMetadata.Merge(m, src)
}

func (m *PoolMetadata) XXX_Size() int {
	return m.Size()
}

func (m *PoolMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_PoolMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_PoolMetadata proto.InternalMessageInfo

// PoolBatch defines the batch or batches of a given liquidity pool that
// contains indexes of deposit, withdraw, and swap messages. Index param
// increments by 1 if the pool id is same.
type PoolBatch struct {
	// id of the pool
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id" yaml:"pool_id"`
	// index of this batch
	Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty" yaml:"index"`
	// height where this batch is started
	BeginHeight int64 `protobuf:"varint,3,opt,name=begin_height,json=beginHeight,proto3" json:"begin_height,omitempty" yaml:"begin_height"`
	// last index of DepositMsgStates
	DepositMsgIndex uint64 `protobuf:"varint,4,opt,name=deposit_msg_index,json=depositMsgIndex,proto3" json:"deposit_msg_index,omitempty" yaml:"deposit_msg_index"`
	// last index of WithdrawMsgStates
	WithdrawMsgIndex uint64 `protobuf:"varint,5,opt,name=withdraw_msg_index,json=withdrawMsgIndex,proto3" json:"withdraw_msg_index,omitempty" yaml:"withdraw_msg_index"`
	// last index of SwapMsgStates
	SwapMsgIndex uint64 `protobuf:"varint,6,opt,name=swap_msg_index,json=swapMsgIndex,proto3" json:"swap_msg_index,omitempty" yaml:"swap_msg_index"`
	// true if executed, false if not executed
	Executed bool `protobuf:"varint,7,opt,name=executed,proto3" json:"executed,omitempty" yaml:"executed"`
}

func (m *PoolBatch) Reset()         { *m = PoolBatch{} }
func (m *PoolBatch) String() string { return proto.CompactTextString(m) }
func (*PoolBatch) ProtoMessage()    {}
func (*PoolBatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{4}
}

func (m *PoolBatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *PoolBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PoolBatch.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 *PoolBatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoolBatch.Merge(m, src)
}

func (m *PoolBatch) XXX_Size() int {
	return m.Size()
}

func (m *PoolBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_PoolBatch.DiscardUnknown(m)
}

var xxx_messageInfo_PoolBatch proto.InternalMessageInfo

// DepositMsgState defines the state of deposit message that contains state
// information as it is processed in the next batch or batches.
type DepositMsgState struct {
	// height where this message is appended to the batch
	MsgHeight int64 `protobuf:"varint,1,opt,name=msg_height,json=msgHeight,proto3" json:"msg_height,omitempty" yaml:"msg_height"`
	// index of this deposit message in this liquidity pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty" yaml:"msg_index"`
	// true if executed on this batch, false if not executed
	Executed bool `protobuf:"varint,3,opt,name=executed,proto3" json:"executed,omitempty" yaml:"executed"`
	// true if executed successfully on this batch, false if failed
	Succeeded bool `protobuf:"varint,4,opt,name=succeeded,proto3" json:"succeeded,omitempty" yaml:"succeeded"`
	// true if ready to be deleted on kvstore, false if not ready to be deleted
	ToBeDeleted bool `protobuf:"varint,5,opt,name=to_be_deleted,json=toBeDeleted,proto3" json:"to_be_deleted,omitempty" yaml:"to_be_deleted"`
	// MsgDepositWithinBatch
	Msg *MsgDepositWithinBatch `protobuf:"bytes,6,opt,name=msg,proto3" json:"msg,omitempty" yaml:"msg"`
}

func (m *DepositMsgState) Reset()         { *m = DepositMsgState{} }
func (m *DepositMsgState) String() string { return proto.CompactTextString(m) }
func (*DepositMsgState) ProtoMessage()    {}
func (*DepositMsgState) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{5}
}

func (m *DepositMsgState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *DepositMsgState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DepositMsgState.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 *DepositMsgState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DepositMsgState.Merge(m, src)
}

func (m *DepositMsgState) XXX_Size() int {
	return m.Size()
}

func (m *DepositMsgState) XXX_DiscardUnknown() {
	xxx_messageInfo_DepositMsgState.DiscardUnknown(m)
}

var xxx_messageInfo_DepositMsgState proto.InternalMessageInfo

// WithdrawMsgState defines the state of the withdraw message that contains
// state information as the message is processed in the next batch or batches.
type WithdrawMsgState struct {
	// height where this message is appended to the batch
	MsgHeight int64 `protobuf:"varint,1,opt,name=msg_height,json=msgHeight,proto3" json:"msg_height,omitempty" yaml:"msg_height"`
	// index of this withdraw message in this liquidity pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty" yaml:"msg_index"`
	// true if executed on this batch, false if not executed
	Executed bool `protobuf:"varint,3,opt,name=executed,proto3" json:"executed,omitempty" yaml:"executed"`
	// true if executed successfully on this batch, false if failed
	Succeeded bool `protobuf:"varint,4,opt,name=succeeded,proto3" json:"succeeded,omitempty" yaml:"succeeded"`
	// true if ready to be deleted on kvstore, false if not ready to be deleted
	ToBeDeleted bool `protobuf:"varint,5,opt,name=to_be_deleted,json=toBeDeleted,proto3" json:"to_be_deleted,omitempty" yaml:"to_be_deleted"`
	// MsgWithdrawWithinBatch
	Msg *MsgWithdrawWithinBatch `protobuf:"bytes,6,opt,name=msg,proto3" json:"msg,omitempty" yaml:"msg"`
}

func (m *WithdrawMsgState) Reset()         { *m = WithdrawMsgState{} }
func (m *WithdrawMsgState) String() string { return proto.CompactTextString(m) }
func (*WithdrawMsgState) ProtoMessage()    {}
func (*WithdrawMsgState) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{6}
}

func (m *WithdrawMsgState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *WithdrawMsgState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WithdrawMsgState.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 *WithdrawMsgState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WithdrawMsgState.Merge(m, src)
}

func (m *WithdrawMsgState) XXX_Size() int {
	return m.Size()
}

func (m *WithdrawMsgState) XXX_DiscardUnknown() {
	xxx_messageInfo_WithdrawMsgState.DiscardUnknown(m)
}

var xxx_messageInfo_WithdrawMsgState proto.InternalMessageInfo

// SwapMsgState defines the state of the swap message that contains state
// information as the message is processed in the next batch or batches.
type SwapMsgState struct {
	// height where this message is appended to the batch
	MsgHeight int64 `protobuf:"varint,1,opt,name=msg_height,json=msgHeight,proto3" json:"msg_height,omitempty" yaml:"msg_height"`
	// index of this swap message in this liquidity pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty" yaml:"msg_index"`
	// true if executed on this batch, false if not executed
	Executed bool `protobuf:"varint,3,opt,name=executed,proto3" json:"executed,omitempty" yaml:"executed"`
	// true if executed successfully on this batch, false if failed
	Succeeded bool `protobuf:"varint,4,opt,name=succeeded,proto3" json:"succeeded,omitempty" yaml:"succeeded"`
	// true if ready to be deleted on kvstore, false if not ready to be deleted
	ToBeDeleted bool `protobuf:"varint,5,opt,name=to_be_deleted,json=toBeDeleted,proto3" json:"to_be_deleted,omitempty" yaml:"to_be_deleted"`
	// swap orders are cancelled when current height is equal to or higher than
	// ExpiryHeight
	OrderExpiryHeight int64 `protobuf:"varint,6,opt,name=order_expiry_height,json=orderExpiryHeight,proto3" json:"order_expiry_height,omitempty" yaml:"order_expiry_height"`
	// offer coin exchanged until now
	ExchangedOfferCoin types.Coin `protobuf:"bytes,7,opt,name=exchanged_offer_coin,json=exchangedOfferCoin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"exchanged_offer_coin" yaml:"exchanged_offer_coin"`
	// offer coin currently remaining to be exchanged
	RemainingOfferCoin types.Coin `protobuf:"bytes,8,opt,name=remaining_offer_coin,json=remainingOfferCoin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"remaining_offer_coin" yaml:"remaining_offer_coin"`
	// reserve fee for pays fee in half offer coin
	ReservedOfferCoinFee types.Coin `protobuf:"bytes,9,opt,name=reserved_offer_coin_fee,json=reservedOfferCoinFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"reserved_offer_coin_fee" yaml:"reserved_offer_coin_fee"`
	// MsgSwapWithinBatch
	Msg *MsgSwapWithinBatch `protobuf:"bytes,10,opt,name=msg,proto3" json:"msg,omitempty" yaml:"msg"`
}

func (m *SwapMsgState) Reset()         { *m = SwapMsgState{} }
func (m *SwapMsgState) String() string { return proto.CompactTextString(m) }
func (*SwapMsgState) ProtoMessage()    {}
func (*SwapMsgState) Descriptor() ([]byte, []int) {
	return fileDescriptor_67b6d59e96092d89, []int{7}
}

func (m *SwapMsgState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *SwapMsgState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SwapMsgState.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 *SwapMsgState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SwapMsgState.Merge(m, src)
}

func (m *SwapMsgState) XXX_Size() int {
	return m.Size()
}

func (m *SwapMsgState) XXX_DiscardUnknown() {
	xxx_messageInfo_SwapMsgState.DiscardUnknown(m)
}

var xxx_messageInfo_SwapMsgState proto.InternalMessageInfo

func init() {
	proto.RegisterType((*PoolType)(nil), "cyber.liquidity.v1beta1.PoolType")
	proto.RegisterType((*Params)(nil), "cyber.liquidity.v1beta1.Params")
	proto.RegisterType((*Pool)(nil), "cyber.liquidity.v1beta1.Pool")
	proto.RegisterType((*PoolMetadata)(nil), "cyber.liquidity.v1beta1.PoolMetadata")
	proto.RegisterType((*PoolBatch)(nil), "cyber.liquidity.v1beta1.PoolBatch")
	proto.RegisterType((*DepositMsgState)(nil), "cyber.liquidity.v1beta1.DepositMsgState")
	proto.RegisterType((*WithdrawMsgState)(nil), "cyber.liquidity.v1beta1.WithdrawMsgState")
	proto.RegisterType((*SwapMsgState)(nil), "cyber.liquidity.v1beta1.SwapMsgState")
}

func init() {
	proto.RegisterFile("cyber/liquidity/v1beta1/liquidity.proto", fileDescriptor_67b6d59e96092d89)
}

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

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

	that1, ok := that.(*PoolType)
	if !ok {
		that2, ok := that.(PoolType)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.MinReserveCoinNum != that1.MinReserveCoinNum {
		return false
	}
	if this.MaxReserveCoinNum != that1.MaxReserveCoinNum {
		return false
	}
	if this.Description != that1.Description {
		return false
	}
	return true
}

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

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.PoolTypes) != len(that1.PoolTypes) {
		return false
	}
	for i := range this.PoolTypes {
		if !this.PoolTypes[i].Equal(&that1.PoolTypes[i]) {
			return false
		}
	}
	if !this.MinInitDepositAmount.Equal(that1.MinInitDepositAmount) {
		return false
	}
	if !this.InitPoolCoinMintAmount.Equal(that1.InitPoolCoinMintAmount) {
		return false
	}
	if !this.MaxReserveCoinAmount.Equal(that1.MaxReserveCoinAmount) {
		return false
	}
	if len(this.PoolCreationFee) != len(that1.PoolCreationFee) {
		return false
	}
	for i := range this.PoolCreationFee {
		if !this.PoolCreationFee[i].Equal(&that1.PoolCreationFee[i]) {
			return false
		}
	}
	if !this.SwapFeeRate.Equal(that1.SwapFeeRate) {
		return false
	}
	if !this.WithdrawFeeRate.Equal(that1.WithdrawFeeRate) {
		return false
	}
	if !this.MaxOrderAmountRatio.Equal(that1.MaxOrderAmountRatio) {
		return false
	}
	if this.UnitBatchHeight != that1.UnitBatchHeight {
		return false
	}
	if this.CircuitBreakerEnabled != that1.CircuitBreakerEnabled {
		return false
	}
	return true
}

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

	that1, ok := that.(*Pool)
	if !ok {
		that2, ok := that.(Pool)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.TypeId != that1.TypeId {
		return false
	}
	if len(this.ReserveCoinDenoms) != len(that1.ReserveCoinDenoms) {
		return false
	}
	for i := range this.ReserveCoinDenoms {
		if this.ReserveCoinDenoms[i] != that1.ReserveCoinDenoms[i] {
			return false
		}
	}
	if this.ReserveAccountAddress != that1.ReserveAccountAddress {
		return false
	}
	if this.PoolCoinDenom != that1.PoolCoinDenom {
		return false
	}
	return true
}

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

	that1, ok := that.(*PoolMetadata)
	if !ok {
		that2, ok := that.(PoolMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PoolId != that1.PoolId {
		return false
	}
	if !this.PoolCoinTotalSupply.Equal(&that1.PoolCoinTotalSupply) {
		return false
	}
	if len(this.ReserveCoins) != len(that1.ReserveCoins) {
		return false
	}
	for i := range this.ReserveCoins {
		if !this.ReserveCoins[i].Equal(&that1.ReserveCoins[i]) {
			return false
		}
	}
	return true
}

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

	that1, ok := that.(*PoolBatch)
	if !ok {
		that2, ok := that.(PoolBatch)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PoolId != that1.PoolId {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.BeginHeight != that1.BeginHeight {
		return false
	}
	if this.DepositMsgIndex != that1.DepositMsgIndex {
		return false
	}
	if this.WithdrawMsgIndex != that1.WithdrawMsgIndex {
		return false
	}
	if this.SwapMsgIndex != that1.SwapMsgIndex {
		return false
	}
	if this.Executed != that1.Executed {
		return false
	}
	return true
}

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

func (m *PoolType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintLiquidity(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if m.MaxReserveCoinNum != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MaxReserveCoinNum))
		i--
		dAtA[i] = 0x20
	}
	if m.MinReserveCoinNum != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MinReserveCoinNum))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLiquidity(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CircuitBreakerEnabled {
		i--
		if m.CircuitBreakerEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.UnitBatchHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.UnitBatchHeight))
		i--
		dAtA[i] = 0x48
	}
	{
		size := m.MaxOrderAmountRatio.Size()
		i -= size
		if _, err := m.MaxOrderAmountRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.WithdrawFeeRate.Size()
		i -= size
		if _, err := m.WithdrawFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.SwapFeeRate.Size()
		i -= size
		if _, err := m.SwapFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.PoolCreationFee) > 0 {
		for iNdEx := len(m.PoolCreationFee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PoolCreationFee[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLiquidity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	{
		size := m.MaxReserveCoinAmount.Size()
		i -= size
		if _, err := m.MaxReserveCoinAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.InitPoolCoinMintAmount.Size()
		i -= size
		if _, err := m.InitPoolCoinMintAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.MinInitDepositAmount.Size()
		i -= size
		if _, err := m.MinInitDepositAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.PoolTypes) > 0 {
		for iNdEx := len(m.PoolTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PoolTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLiquidity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PoolCoinDenom) > 0 {
		i -= len(m.PoolCoinDenom)
		copy(dAtA[i:], m.PoolCoinDenom)
		i = encodeVarintLiquidity(dAtA, i, uint64(len(m.PoolCoinDenom)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ReserveAccountAddress) > 0 {
		i -= len(m.ReserveAccountAddress)
		copy(dAtA[i:], m.ReserveAccountAddress)
		i = encodeVarintLiquidity(dAtA, i, uint64(len(m.ReserveAccountAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ReserveCoinDenoms) > 0 {
		for iNdEx := len(m.ReserveCoinDenoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ReserveCoinDenoms[iNdEx])
			copy(dAtA[i:], m.ReserveCoinDenoms[iNdEx])
			i = encodeVarintLiquidity(dAtA, i, uint64(len(m.ReserveCoinDenoms[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.TypeId != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.TypeId))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *PoolMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReserveCoins) > 0 {
		for iNdEx := len(m.ReserveCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReserveCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLiquidity(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.PoolCoinTotalSupply.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.PoolId != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *PoolBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Executed {
		i--
		if m.Executed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.SwapMsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.SwapMsgIndex))
		i--
		dAtA[i] = 0x30
	}
	if m.WithdrawMsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.WithdrawMsgIndex))
		i--
		dAtA[i] = 0x28
	}
	if m.DepositMsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.DepositMsgIndex))
		i--
		dAtA[i] = 0x20
	}
	if m.BeginHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.BeginHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.PoolId != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DepositMsgState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLiquidity(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ToBeDeleted {
		i--
		if m.ToBeDeleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Succeeded {
		i--
		if m.Succeeded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Executed {
		i--
		if m.Executed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.MsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.MsgHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *WithdrawMsgState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLiquidity(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ToBeDeleted {
		i--
		if m.ToBeDeleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Succeeded {
		i--
		if m.Succeeded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Executed {
		i--
		if m.Executed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.MsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.MsgHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SwapMsgState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLiquidity(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	{
		size, err := m.ReservedOfferCoinFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size, err := m.RemainingOfferCoin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size, err := m.ExchangedOfferCoin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLiquidity(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if m.OrderExpiryHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.OrderExpiryHeight))
		i--
		dAtA[i] = 0x30
	}
	if m.ToBeDeleted {
		i--
		if m.ToBeDeleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Succeeded {
		i--
		if m.Succeeded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Executed {
		i--
		if m.Executed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.MsgIndex != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.MsgHeight != 0 {
		i = encodeVarintLiquidity(dAtA, i, uint64(m.MsgHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintLiquidity(dAtA []byte, offset int, v uint64) int {
	offset -= sovLiquidity(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *PoolType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovLiquidity(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLiquidity(uint64(l))
	}
	if m.MinReserveCoinNum != 0 {
		n += 1 + sovLiquidity(uint64(m.MinReserveCoinNum))
	}
	if m.MaxReserveCoinNum != 0 {
		n += 1 + sovLiquidity(uint64(m.MaxReserveCoinNum))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovLiquidity(uint64(l))
	}
	return n
}

func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PoolTypes) > 0 {
		for _, e := range m.PoolTypes {
			l = e.Size()
			n += 1 + l + sovLiquidity(uint64(l))
		}
	}
	l = m.MinInitDepositAmount.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.InitPoolCoinMintAmount.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.MaxReserveCoinAmount.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	if len(m.PoolCreationFee) > 0 {
		for _, e := range m.PoolCreationFee {
			l = e.Size()
			n += 1 + l + sovLiquidity(uint64(l))
		}
	}
	l = m.SwapFeeRate.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.WithdrawFeeRate.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.MaxOrderAmountRatio.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	if m.UnitBatchHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.UnitBatchHeight))
	}
	if m.CircuitBreakerEnabled {
		n += 2
	}
	return n
}

func (m *Pool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovLiquidity(uint64(m.Id))
	}
	if m.TypeId != 0 {
		n += 1 + sovLiquidity(uint64(m.TypeId))
	}
	if len(m.ReserveCoinDenoms) > 0 {
		for _, s := range m.ReserveCoinDenoms {
			l = len(s)
			n += 1 + l + sovLiquidity(uint64(l))
		}
	}
	l = len(m.ReserveAccountAddress)
	if l > 0 {
		n += 1 + l + sovLiquidity(uint64(l))
	}
	l = len(m.PoolCoinDenom)
	if l > 0 {
		n += 1 + l + sovLiquidity(uint64(l))
	}
	return n
}

func (m *PoolMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovLiquidity(uint64(m.PoolId))
	}
	l = m.PoolCoinTotalSupply.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	if len(m.ReserveCoins) > 0 {
		for _, e := range m.ReserveCoins {
			l = e.Size()
			n += 1 + l + sovLiquidity(uint64(l))
		}
	}
	return n
}

func (m *PoolBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PoolId != 0 {
		n += 1 + sovLiquidity(uint64(m.PoolId))
	}
	if m.Index != 0 {
		n += 1 + sovLiquidity(uint64(m.Index))
	}
	if m.BeginHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.BeginHeight))
	}
	if m.DepositMsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.DepositMsgIndex))
	}
	if m.WithdrawMsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.WithdrawMsgIndex))
	}
	if m.SwapMsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.SwapMsgIndex))
	}
	if m.Executed {
		n += 2
	}
	return n
}

func (m *DepositMsgState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MsgHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgHeight))
	}
	if m.MsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgIndex))
	}
	if m.Executed {
		n += 2
	}
	if m.Succeeded {
		n += 2
	}
	if m.ToBeDeleted {
		n += 2
	}
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovLiquidity(uint64(l))
	}
	return n
}

func (m *WithdrawMsgState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MsgHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgHeight))
	}
	if m.MsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgIndex))
	}
	if m.Executed {
		n += 2
	}
	if m.Succeeded {
		n += 2
	}
	if m.ToBeDeleted {
		n += 2
	}
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovLiquidity(uint64(l))
	}
	return n
}

func (m *SwapMsgState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MsgHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgHeight))
	}
	if m.MsgIndex != 0 {
		n += 1 + sovLiquidity(uint64(m.MsgIndex))
	}
	if m.Executed {
		n += 2
	}
	if m.Succeeded {
		n += 2
	}
	if m.ToBeDeleted {
		n += 2
	}
	if m.OrderExpiryHeight != 0 {
		n += 1 + sovLiquidity(uint64(m.OrderExpiryHeight))
	}
	l = m.ExchangedOfferCoin.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.RemainingOfferCoin.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	l = m.ReservedOfferCoinFee.Size()
	n += 1 + l + sovLiquidity(uint64(l))
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovLiquidity(uint64(l))
	}
	return n
}

func sovLiquidity(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozLiquidity(x uint64) (n int) {
	return sovLiquidity(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

func (m *PoolType) 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 ErrIntOverflowLiquidity
			}
			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: PoolType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PoolType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinReserveCoinNum", wireType)
			}
			m.MinReserveCoinNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinReserveCoinNum |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxReserveCoinNum", wireType)
			}
			m.MaxReserveCoinNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxReserveCoinNum |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *Params) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLiquidity
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PoolTypes = append(m.PoolTypes, PoolType{})
			if err := m.PoolTypes[len(m.PoolTypes)-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 MinInitDepositAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinInitDepositAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitPoolCoinMintAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InitPoolCoinMintAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxReserveCoinAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxReserveCoinAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolCreationFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PoolCreationFee = append(m.PoolCreationFee, types.Coin{})
			if err := m.PoolCreationFee[len(m.PoolCreationFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SwapFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.WithdrawFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxOrderAmountRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				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 ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxOrderAmountRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnitBatchHeight", wireType)
			}
			m.UnitBatchHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnitBatchHeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CircuitBreakerEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CircuitBreakerEnabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *PoolBatch) 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 ErrIntOverflowLiquidity
			}
			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: PoolBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PoolBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeginHeight", wireType)
			}
			m.BeginHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BeginHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositMsgIndex", wireType)
			}
			m.DepositMsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DepositMsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawMsgIndex", wireType)
			}
			m.WithdrawMsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WithdrawMsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapMsgIndex", wireType)
			}
			m.SwapMsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SwapMsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Executed = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *DepositMsgState) 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 ErrIntOverflowLiquidity
			}
			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: DepositMsgState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DepositMsgState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgHeight", wireType)
			}
			m.MsgHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgIndex", wireType)
			}
			m.MsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Executed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Succeeded = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToBeDeleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ToBeDeleted = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Msg == nil {
				m.Msg = &MsgDepositWithinBatch{}
			}
			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *WithdrawMsgState) 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 ErrIntOverflowLiquidity
			}
			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: WithdrawMsgState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WithdrawMsgState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgHeight", wireType)
			}
			m.MsgHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgIndex", wireType)
			}
			m.MsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Executed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Succeeded = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToBeDeleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ToBeDeleted = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Msg == nil {
				m.Msg = &MsgWithdrawWithinBatch{}
			}
			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *SwapMsgState) 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 ErrIntOverflowLiquidity
			}
			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: SwapMsgState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SwapMsgState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgHeight", wireType)
			}
			m.MsgHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgIndex", wireType)
			}
			m.MsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Executed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Succeeded = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToBeDeleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ToBeDeleted = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderExpiryHeight", wireType)
			}
			m.OrderExpiryHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OrderExpiryHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExchangedOfferCoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExchangedOfferCoin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemainingOfferCoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RemainingOfferCoin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReservedOfferCoinFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ReservedOfferCoinFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidity
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidity
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidity
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Msg == nil {
				m.Msg = &MsgSwapWithinBatch{}
			}
			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidity(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidity
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

var (
	ErrInvalidLengthLiquidity        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLiquidity          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLiquidity = fmt.Errorf("proto: unexpected end of group")
)