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

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

package types

import (
	context "context"
	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"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// 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

// MsgCreatePool defines an sdk.Msg type that supports submitting a create
// liquidity pool tx.
//
// See:
// https://github.com/gravity-devs/liquidity/blob/develop/x/liquidity/spec/04_messages.md
type MsgCreatePool struct {
	PoolCreatorAddress string `protobuf:"bytes,1,opt,name=pool_creator_address,json=poolCreatorAddress,proto3" json:"pool_creator_address,omitempty" yaml:"pool_creator_address"`
	// id of the target pool type, must match the value in the pool. Only
	// pool-type-id 1 is supported.
	PoolTypeId uint32 `protobuf:"varint,2,opt,name=pool_type_id,json=poolTypeId,proto3" json:"pool_type_id,omitempty" yaml:"pool_type_id"`
	// reserve coin pair of the pool to deposit.
	DepositCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,4,rep,name=deposit_coins,json=depositCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"deposit_coins" yaml:"deposit_coins"`
}

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

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

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

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

func (m *MsgCreatePool) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreatePool.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreatePool proto.InternalMessageInfo

// MsgCreatePoolResponse defines the Msg/CreatePool response type.
type MsgCreatePoolResponse struct{}

func (m *MsgCreatePoolResponse) Reset()         { *m = MsgCreatePoolResponse{} }
func (m *MsgCreatePoolResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreatePoolResponse) ProtoMessage()    {}
func (*MsgCreatePoolResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6c6519f5f802cc0, []int{1}
}

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

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

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

func (m *MsgCreatePoolResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreatePoolResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreatePoolResponse proto.InternalMessageInfo

// `MsgDepositWithinBatch defines` an `sdk.Msg` type that supports submitting
// a deposit request to the batch of the liquidity pool.
// Deposit is submitted to the batch of the Liquidity pool with the specified
// `pool_id`, `deposit_coins` for reserve.
// This request is stacked in the batch of the liquidity pool, is not processed
// immediately, and is processed in the `endblock` at the same time as other
// requests.
//
// See:
// https://github.com/gravity-devs/liquidity/blob/develop/x/liquidity/spec/04_messages.md
type MsgDepositWithinBatch struct {
	DepositorAddress string `protobuf:"bytes,1,opt,name=depositor_address,json=depositorAddress,proto3" json:"depositor_address,omitempty" yaml:"depositor_address"`
	// id of the target pool
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	// reserve coin pair of the pool to deposit
	DepositCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=deposit_coins,json=depositCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"deposit_coins" yaml:"deposit_coins"`
}

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

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

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

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

func (m *MsgDepositWithinBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDepositWithinBatch.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDepositWithinBatch proto.InternalMessageInfo

// MsgDepositWithinBatchResponse defines the Msg/DepositWithinBatch response
// type.
type MsgDepositWithinBatchResponse struct{}

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

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

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

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

func (m *MsgDepositWithinBatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDepositWithinBatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDepositWithinBatchResponse proto.InternalMessageInfo

// `MsgWithdrawWithinBatch` defines an `sdk.Msg` type that supports submitting
// a withdraw request to the batch of the liquidity pool.
// Withdraw is submitted to the batch from the Liquidity pool with the
// specified `pool_id`, `pool_coin` of the pool.
// This request is stacked in the batch of the liquidity pool, is not processed
// immediately, and is processed in the `endblock` at the same time as other
// requests.
//
// See:
// https://github.com/gravity-devs/liquidity/blob/develop/x/liquidity/spec/04_messages.md
type MsgWithdrawWithinBatch struct {
	WithdrawerAddress string `protobuf:"bytes,1,opt,name=withdrawer_address,json=withdrawerAddress,proto3" json:"withdrawer_address,omitempty" yaml:"withdrawer_address"`
	// id of the target pool
	PoolId   uint64     `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	PoolCoin types.Coin `protobuf:"bytes,3,opt,name=pool_coin,json=poolCoin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"pool_coin" yaml:"pool_coin"`
}

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

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

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

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

func (m *MsgWithdrawWithinBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawWithinBatch.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawWithinBatch proto.InternalMessageInfo

// MsgWithdrawWithinBatchResponse defines the Msg/WithdrawWithinBatch response
// type.
type MsgWithdrawWithinBatchResponse struct{}

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

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

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

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

func (m *MsgWithdrawWithinBatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawWithinBatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawWithinBatchResponse proto.InternalMessageInfo

// `MsgSwapWithinBatch` defines an sdk.Msg type that supports submitting a swap
// offer request to the batch of the liquidity pool. Submit swap offer to the
// liquidity pool batch with the specified the `pool_id`, `swap_type_id`,
// `demand_coin_denom` with the coin and the price you're offering
// and `offer_coin_fee` must be half of offer coin amount * current
// `params.swap_fee_rate` and ceil for reservation to pay fees. This request is
// stacked in the batch of the liquidity pool, is not processed immediately, and
// is processed in the `endblock` at the same time as other requests. You must
// request the same fields as the pool. Only the default `swap_type_id` 1 is
// supported.
//
// See: https://github.com/gravity-devs/liquidity/tree/develop/doc
// https://github.com/gravity-devs/liquidity/blob/develop/x/liquidity/spec/04_messages.md
type MsgSwapWithinBatch struct {
	// address of swap requester
	SwapRequesterAddress string `protobuf:"bytes,1,opt,name=swap_requester_address,json=swapRequesterAddress,proto3" json:"swap_requester_address,omitempty" yaml:"swap_requester_address"`
	// id of swap type, must match the value in the pool. Only `swap_type_id` 1 is
	// supported.
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	// id of swap type. Must match the value in the pool.
	SwapTypeId uint32 `protobuf:"varint,3,opt,name=swap_type_id,json=swapTypeId,proto3" json:"swap_type_id,omitempty" yaml:"swap_type_id"`
	// offer sdk.coin for the swap request, must match the denom in the pool.
	OfferCoin types.Coin `protobuf:"bytes,4,opt,name=offer_coin,json=offerCoin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"offer_coin" yaml:"offer_coin"`
	// denom of demand coin to be exchanged on the swap request, must match the
	// denom in the pool.
	DemandCoinDenom string `protobuf:"bytes,5,opt,name=demand_coin_denom,json=demandCoinDenom,proto3" json:"demand_coin_denom,omitempty" yaml:"demand_coin_denom"`
	// half of offer coin amount * params.swap_fee_rate and ceil for reservation
	// to pay fees.
	OfferCoinFee types.Coin `protobuf:"bytes,6,opt,name=offer_coin_fee,json=offerCoinFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"offer_coin_fee" yaml:"offer_coin_fee"`
	// limit order price for the order, the price is the exchange ratio of X/Y
	// where X is the amount of the first coin and Y is the amount
	// of the second coin when their denoms are sorted alphabetically.
	OrderPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=order_price,json=orderPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"order_price" yaml:"order_price"`
}

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

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

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

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

func (m *MsgSwapWithinBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSwapWithinBatch.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSwapWithinBatch proto.InternalMessageInfo

// MsgSwapWithinBatchResponse defines the Msg/Swap response type.
type MsgSwapWithinBatchResponse struct{}

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

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

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

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

func (m *MsgSwapWithinBatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSwapWithinBatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSwapWithinBatchResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreatePool)(nil), "cyber.liquidity.v1beta1.MsgCreatePool")
	proto.RegisterType((*MsgCreatePoolResponse)(nil), "cyber.liquidity.v1beta1.MsgCreatePoolResponse")
	proto.RegisterType((*MsgDepositWithinBatch)(nil), "cyber.liquidity.v1beta1.MsgDepositWithinBatch")
	proto.RegisterType((*MsgDepositWithinBatchResponse)(nil), "cyber.liquidity.v1beta1.MsgDepositWithinBatchResponse")
	proto.RegisterType((*MsgWithdrawWithinBatch)(nil), "cyber.liquidity.v1beta1.MsgWithdrawWithinBatch")
	proto.RegisterType((*MsgWithdrawWithinBatchResponse)(nil), "cyber.liquidity.v1beta1.MsgWithdrawWithinBatchResponse")
	proto.RegisterType((*MsgSwapWithinBatch)(nil), "cyber.liquidity.v1beta1.MsgSwapWithinBatch")
	proto.RegisterType((*MsgSwapWithinBatchResponse)(nil), "cyber.liquidity.v1beta1.MsgSwapWithinBatchResponse")
}

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

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ grpc.ClientConn
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// Submit a create liquidity pool message.
	CreatePool(ctx context.Context, in *MsgCreatePool, opts ...grpc.CallOption) (*MsgCreatePoolResponse, error)
	// Submit a deposit to the liquidity pool batch.
	DepositWithinBatch(ctx context.Context, in *MsgDepositWithinBatch, opts ...grpc.CallOption) (*MsgDepositWithinBatchResponse, error)
	// Submit a withdraw from the liquidity pool batch.
	WithdrawWithinBatch(ctx context.Context, in *MsgWithdrawWithinBatch, opts ...grpc.CallOption) (*MsgWithdrawWithinBatchResponse, error)
	// Submit a swap to the liquidity pool batch.
	Swap(ctx context.Context, in *MsgSwapWithinBatch, opts ...grpc.CallOption) (*MsgSwapWithinBatchResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) CreatePool(ctx context.Context, in *MsgCreatePool, opts ...grpc.CallOption) (*MsgCreatePoolResponse, error) {
	out := new(MsgCreatePoolResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Msg/CreatePool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DepositWithinBatch(ctx context.Context, in *MsgDepositWithinBatch, opts ...grpc.CallOption) (*MsgDepositWithinBatchResponse, error) {
	out := new(MsgDepositWithinBatchResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Msg/DepositWithinBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawWithinBatch(ctx context.Context, in *MsgWithdrawWithinBatch, opts ...grpc.CallOption) (*MsgWithdrawWithinBatchResponse, error) {
	out := new(MsgWithdrawWithinBatchResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Msg/WithdrawWithinBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Swap(ctx context.Context, in *MsgSwapWithinBatch, opts ...grpc.CallOption) (*MsgSwapWithinBatchResponse, error) {
	out := new(MsgSwapWithinBatchResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Msg/Swap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// Submit a create liquidity pool message.
	CreatePool(context.Context, *MsgCreatePool) (*MsgCreatePoolResponse, error)
	// Submit a deposit to the liquidity pool batch.
	DepositWithinBatch(context.Context, *MsgDepositWithinBatch) (*MsgDepositWithinBatchResponse, error)
	// Submit a withdraw from the liquidity pool batch.
	WithdrawWithinBatch(context.Context, *MsgWithdrawWithinBatch) (*MsgWithdrawWithinBatchResponse, error)
	// Submit a swap to the liquidity pool batch.
	Swap(context.Context, *MsgSwapWithinBatch) (*MsgSwapWithinBatchResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct{}

func (*UnimplementedMsgServer) CreatePool(ctx context.Context, req *MsgCreatePool) (*MsgCreatePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePool not implemented")
}

func (*UnimplementedMsgServer) DepositWithinBatch(ctx context.Context, req *MsgDepositWithinBatch) (*MsgDepositWithinBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DepositWithinBatch not implemented")
}

func (*UnimplementedMsgServer) WithdrawWithinBatch(ctx context.Context, req *MsgWithdrawWithinBatch) (*MsgWithdrawWithinBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawWithinBatch not implemented")
}

func (*UnimplementedMsgServer) Swap(ctx context.Context, req *MsgSwapWithinBatch) (*MsgSwapWithinBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_CreatePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreatePool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreatePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Msg/CreatePool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreatePool(ctx, req.(*MsgCreatePool))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DepositWithinBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDepositWithinBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DepositWithinBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Msg/DepositWithinBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DepositWithinBatch(ctx, req.(*MsgDepositWithinBatch))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawWithinBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawWithinBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawWithinBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Msg/WithdrawWithinBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawWithinBatch(ctx, req.(*MsgWithdrawWithinBatch))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Swap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSwapWithinBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Swap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Msg/Swap",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Swap(ctx, req.(*MsgSwapWithinBatch))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cyber.liquidity.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreatePool",
			Handler:    _Msg_CreatePool_Handler,
		},
		{
			MethodName: "DepositWithinBatch",
			Handler:    _Msg_DepositWithinBatch_Handler,
		},
		{
			MethodName: "WithdrawWithinBatch",
			Handler:    _Msg_WithdrawWithinBatch_Handler,
		},
		{
			MethodName: "Swap",
			Handler:    _Msg_Swap_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cyber/liquidity/v1beta1/tx.proto",
}

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

func (m *MsgCreatePool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DepositCoins) > 0 {
		for iNdEx := len(m.DepositCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DepositCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.PoolTypeId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolTypeId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PoolCreatorAddress) > 0 {
		i -= len(m.PoolCreatorAddress)
		copy(dAtA[i:], m.PoolCreatorAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.PoolCreatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDepositWithinBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DepositCoins) > 0 {
		for iNdEx := len(m.DepositCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DepositCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.DepositorAddress) > 0 {
		i -= len(m.DepositorAddress)
		copy(dAtA[i:], m.DepositorAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DepositorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgWithdrawWithinBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PoolCoin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.WithdrawerAddress) > 0 {
		i -= len(m.WithdrawerAddress)
		copy(dAtA[i:], m.WithdrawerAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.WithdrawerAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSwapWithinBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.OrderPrice.Size()
		i -= size
		if _, err := m.OrderPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.OfferCoinFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.DemandCoinDenom) > 0 {
		i -= len(m.DemandCoinDenom)
		copy(dAtA[i:], m.DemandCoinDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DemandCoinDenom)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.OfferCoin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.SwapTypeId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.SwapTypeId))
		i--
		dAtA[i] = 0x18
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SwapRequesterAddress) > 0 {
		i -= len(m.SwapRequesterAddress)
		copy(dAtA[i:], m.SwapRequesterAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SwapRequesterAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgCreatePool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PoolCreatorAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.PoolTypeId != 0 {
		n += 1 + sovTx(uint64(m.PoolTypeId))
	}
	if len(m.DepositCoins) > 0 {
		for _, e := range m.DepositCoins {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgCreatePoolResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDepositWithinBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DepositorAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.PoolId != 0 {
		n += 1 + sovTx(uint64(m.PoolId))
	}
	if len(m.DepositCoins) > 0 {
		for _, e := range m.DepositCoins {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgDepositWithinBatchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgWithdrawWithinBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.WithdrawerAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.PoolId != 0 {
		n += 1 + sovTx(uint64(m.PoolId))
	}
	l = m.PoolCoin.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgWithdrawWithinBatchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgSwapWithinBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SwapRequesterAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.PoolId != 0 {
		n += 1 + sovTx(uint64(m.PoolId))
	}
	if m.SwapTypeId != 0 {
		n += 1 + sovTx(uint64(m.SwapTypeId))
	}
	l = m.OfferCoin.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.DemandCoinDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.OfferCoinFee.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.OrderPrice.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgSwapWithinBatchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

func (m *MsgCreatePoolResponse) 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 ErrIntOverflowTx
			}
			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: MsgCreatePoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreatePoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

func (m *MsgDepositWithinBatchResponse) 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 ErrIntOverflowTx
			}
			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: MsgDepositWithinBatchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositWithinBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

func (m *MsgWithdrawWithinBatchResponse) 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 ErrIntOverflowTx
			}
			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: MsgWithdrawWithinBatchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawWithinBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func (m *MsgSwapWithinBatch) 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 ErrIntOverflowTx
			}
			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: MsgSwapWithinBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSwapWithinBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapRequesterAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SwapRequesterAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapTypeId", wireType)
			}
			m.SwapTypeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SwapTypeId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OfferCoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OfferCoin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DemandCoinDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DemandCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OfferCoinFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OfferCoinFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OrderPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func (m *MsgSwapWithinBatchResponse) 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 ErrIntOverflowTx
			}
			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: MsgSwapWithinBatchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSwapWithinBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)