tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: merlins/superfluid/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/gogo/protobuf/types"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

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

type MsgSuperfluidDelegate struct {
	Sender  string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	LockId  uint64 `protobuf:"varint,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`
	ValAddr string `protobuf:"bytes,3,opt,name=val_addr,json=valAddr,proto3" json:"val_addr,omitempty"`
}

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

var xxx_messageInfo_MsgSuperfluidDelegate proto.InternalMessageInfo

func (m *MsgSuperfluidDelegate) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgSuperfluidDelegate) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

func (m *MsgSuperfluidDelegate) GetValAddr() string {
	if m != nil {
		return m.ValAddr
	}
	return ""
}

type MsgSuperfluidDelegateResponse struct {
}

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

var xxx_messageInfo_MsgSuperfluidDelegateResponse proto.InternalMessageInfo

type MsgSuperfluidUndelegate struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	LockId uint64 `protobuf:"varint,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`
}

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

var xxx_messageInfo_MsgSuperfluidUndelegate proto.InternalMessageInfo

func (m *MsgSuperfluidUndelegate) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgSuperfluidUndelegate) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

type MsgSuperfluidUndelegateResponse struct {
}

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

var xxx_messageInfo_MsgSuperfluidUndelegateResponse proto.InternalMessageInfo

type MsgSuperfluidUnbondLock struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	LockId uint64 `protobuf:"varint,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`
}

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

var xxx_messageInfo_MsgSuperfluidUnbondLock proto.InternalMessageInfo

func (m *MsgSuperfluidUnbondLock) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgSuperfluidUnbondLock) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

type MsgSuperfluidUnbondLockResponse struct {
}

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

var xxx_messageInfo_MsgSuperfluidUnbondLockResponse proto.InternalMessageInfo

type MsgSuperfluidUndelegateAndUnbondLock struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	LockId uint64 `protobuf:"varint,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`
	// Amount of unlocking coin.
	Coin types.Coin `protobuf:"bytes,3,opt,name=coin,proto3" json:"coin" yaml:"coin"`
}

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

var xxx_messageInfo_MsgSuperfluidUndelegateAndUnbondLock proto.InternalMessageInfo

func (m *MsgSuperfluidUndelegateAndUnbondLock) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgSuperfluidUndelegateAndUnbondLock) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

func (m *MsgSuperfluidUndelegateAndUnbondLock) GetCoin() types.Coin {
	if m != nil {
		return m.Coin
	}
	return types.Coin{}
}

type MsgSuperfluidUndelegateAndUnbondLockResponse struct {
	// lock id of the new lock created for the remaining amount.
	// returns the original lockid if the unlocked amount is equal to the
	// original lock's amount.
	LockId uint64 `protobuf:"varint,1,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"`
}

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

var xxx_messageInfo_MsgSuperfluidUndelegateAndUnbondLockResponse proto.InternalMessageInfo

func (m *MsgSuperfluidUndelegateAndUnbondLockResponse) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

// MsgLockAndSuperfluidDelegate locks coins with the unbonding period duration,
// and then does a superfluid lock from the newly created lockup, to the
// specified validator addr.
type MsgLockAndSuperfluidDelegate struct {
	Sender  string                                   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	Coins   github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins"`
	ValAddr string                                   `protobuf:"bytes,3,opt,name=val_addr,json=valAddr,proto3" json:"val_addr,omitempty"`
}

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

var xxx_messageInfo_MsgLockAndSuperfluidDelegate proto.InternalMessageInfo

func (m *MsgLockAndSuperfluidDelegate) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgLockAndSuperfluidDelegate) GetCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *MsgLockAndSuperfluidDelegate) GetValAddr() string {
	if m != nil {
		return m.ValAddr
	}
	return ""
}

type MsgLockAndSuperfluidDelegateResponse struct {
	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
}

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

var xxx_messageInfo_MsgLockAndSuperfluidDelegateResponse proto.InternalMessageInfo

func (m *MsgLockAndSuperfluidDelegateResponse) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

// MsgCreateFullRangePositionAndSuperfluidDelegate creates a full range position
// in a concentrated liquidity pool, then superfluid delegates.
type MsgCreateFullRangePositionAndSuperfluidDelegate struct {
	Sender  string                                   `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	Coins   github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins"`
	ValAddr string                                   `protobuf:"bytes,3,opt,name=val_addr,json=valAddr,proto3" json:"val_addr,omitempty"`
	PoolId  uint64                                   `protobuf:"varint,4,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
}

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

var xxx_messageInfo_MsgCreateFullRangePositionAndSuperfluidDelegate proto.InternalMessageInfo

func (m *MsgCreateFullRangePositionAndSuperfluidDelegate) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgCreateFullRangePositionAndSuperfluidDelegate) GetCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *MsgCreateFullRangePositionAndSuperfluidDelegate) GetValAddr() string {
	if m != nil {
		return m.ValAddr
	}
	return ""
}

func (m *MsgCreateFullRangePositionAndSuperfluidDelegate) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

type MsgCreateFullRangePositionAndSuperfluidDelegateResponse struct {
	LockID     uint64 `protobuf:"varint,1,opt,name=lockID,proto3" json:"lockID,omitempty"`
	PositionID uint64 `protobuf:"varint,2,opt,name=positionID,proto3" json:"positionID,omitempty"`
}

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

var xxx_messageInfo_MsgCreateFullRangePositionAndSuperfluidDelegateResponse proto.InternalMessageInfo

func (m *MsgCreateFullRangePositionAndSuperfluidDelegateResponse) GetLockID() uint64 {
	if m != nil {
		return m.LockID
	}
	return 0
}

func (m *MsgCreateFullRangePositionAndSuperfluidDelegateResponse) GetPositionID() uint64 {
	if m != nil {
		return m.PositionID
	}
	return 0
}

// MsgUnPoolWhitelistedPool Unpools every lock the sender has, that is
// associated with pool pool_id. If pool_id is not approved for unpooling by
// governance, this is a no-op. Unpooling takes the locked gamm shares, and runs
// "ExitPool" on it, to get the constituent tokens. e.g. z gamm/pool/1 tokens
// ExitPools into constituent tokens x uatom, y ufury. Then it creates a new
// lock for every constituent token, with the duration associated with the lock.
// If the lock was unbonding, the new lockup durations should be the time left
// until unbond completion.
type MsgUnPoolWhitelistedPool struct {
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
}

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

var xxx_messageInfo_MsgUnPoolWhitelistedPool proto.InternalMessageInfo

func (m *MsgUnPoolWhitelistedPool) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgUnPoolWhitelistedPool) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

type MsgUnPoolWhitelistedPoolResponse struct {
	ExitedLockIds []uint64 `protobuf:"varint,1,rep,packed,name=exited_lock_ids,json=exitedLockIds,proto3" json:"exited_lock_ids,omitempty"`
}

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

var xxx_messageInfo_MsgUnPoolWhitelistedPoolResponse proto.InternalMessageInfo

func (m *MsgUnPoolWhitelistedPoolResponse) GetExitedLockIds() []uint64 {
	if m != nil {
		return m.ExitedLockIds
	}
	return nil
}

// =====================
// MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition
type MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition struct {
	Sender          string     `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	LockId          int64      `protobuf:"varint,2,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty" yaml:"lock_id"`
	SharesToMigrate types.Coin `protobuf:"bytes,3,opt,name=shares_to_migrate,json=sharesToMigrate,proto3" json:"shares_to_migrate" yaml:"shares_to_migrate"`
	// token_out_mins indicates minimum token to exit Balancer pool with.
	TokenOutMins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,4,rep,name=token_out_mins,json=tokenOutMins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"token_out_mins" yaml:"token_out_mins"`
}

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

var xxx_messageInfo_MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition proto.InternalMessageInfo

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) GetLockId() int64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) GetSharesToMigrate() types.Coin {
	if m != nil {
		return m.SharesToMigrate
	}
	return types.Coin{}
}

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) GetTokenOutMins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.TokenOutMins
	}
	return nil
}

type MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse struct {
	Amount0          github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount0,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount0" yaml:"amount0"`
	Amount1          github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount1,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount1" yaml:"amount1"`
	LiquidityCreated github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=liquidity_created,json=liquidityCreated,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity_created" yaml:"liquidity_created"`
	JoinTime         time.Time                              `protobuf:"bytes,4,opt,name=join_time,json=joinTime,proto3,stdtime" json:"join_time" yaml:"join_time"`
}

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

var xxx_messageInfo_MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse proto.InternalMessageInfo

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse) GetJoinTime() time.Time {
	if m != nil {
		return m.JoinTime
	}
	return time.Time{}
}

// ===================== MsgAddToConcentratedLiquiditySuperfluidPosition
type MsgAddToConcentratedLiquiditySuperfluidPosition struct {
	PositionId    uint64     `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty" yaml:"position_id"`
	Sender        string     `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	TokenDesired0 types.Coin `protobuf:"bytes,3,opt,name=token_desired0,json=tokenDesired0,proto3" json:"token_desired0" yaml:"token_desired0"`
	TokenDesired1 types.Coin `protobuf:"bytes,4,opt,name=token_desired1,json=tokenDesired1,proto3" json:"token_desired1" yaml:"token_desired1"`
}

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

var xxx_messageInfo_MsgAddToConcentratedLiquiditySuperfluidPosition proto.InternalMessageInfo

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) GetPositionId() uint64 {
	if m != nil {
		return m.PositionId
	}
	return 0
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) GetTokenDesired0() types.Coin {
	if m != nil {
		return m.TokenDesired0
	}
	return types.Coin{}
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) GetTokenDesired1() types.Coin {
	if m != nil {
		return m.TokenDesired1
	}
	return types.Coin{}
}

type MsgAddToConcentratedLiquiditySuperfluidPositionResponse struct {
	PositionId uint64                                 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty" yaml:"position_id"`
	Amount0    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount0,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount0" yaml:"amount0"`
	Amount1    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=amount1,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount1" yaml:"amount1"`
	// new_liquidity is the final liquidity after the add.
	// It includes the liquidity that existed before in the position
	// and the new liquidity that was added to the position.
	NewLiquidity github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=new_liquidity,json=newLiquidity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"new_liquidity" yaml:"new_liquidity"`
	LockId       uint64                                 `protobuf:"varint,4,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty" yaml:"lock_id"`
}

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

var xxx_messageInfo_MsgAddToConcentratedLiquiditySuperfluidPositionResponse proto.InternalMessageInfo

func (m *MsgAddToConcentratedLiquiditySuperfluidPositionResponse) GetPositionId() uint64 {
	if m != nil {
		return m.PositionId
	}
	return 0
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPositionResponse) GetLockId() uint64 {
	if m != nil {
		return m.LockId
	}
	return 0
}

func init() {
	proto.RegisterType((*MsgSuperfluidDelegate)(nil), "merlins.superfluid.MsgSuperfluidDelegate")
	proto.RegisterType((*MsgSuperfluidDelegateResponse)(nil), "merlins.superfluid.MsgSuperfluidDelegateResponse")
	proto.RegisterType((*MsgSuperfluidUndelegate)(nil), "merlins.superfluid.MsgSuperfluidUndelegate")
	proto.RegisterType((*MsgSuperfluidUndelegateResponse)(nil), "merlins.superfluid.MsgSuperfluidUndelegateResponse")
	proto.RegisterType((*MsgSuperfluidUnbondLock)(nil), "merlins.superfluid.MsgSuperfluidUnbondLock")
	proto.RegisterType((*MsgSuperfluidUnbondLockResponse)(nil), "merlins.superfluid.MsgSuperfluidUnbondLockResponse")
	proto.RegisterType((*MsgSuperfluidUndelegateAndUnbondLock)(nil), "merlins.superfluid.MsgSuperfluidUndelegateAndUnbondLock")
	proto.RegisterType((*MsgSuperfluidUndelegateAndUnbondLockResponse)(nil), "merlins.superfluid.MsgSuperfluidUndelegateAndUnbondLockResponse")
	proto.RegisterType((*MsgLockAndSuperfluidDelegate)(nil), "merlins.superfluid.MsgLockAndSuperfluidDelegate")
	proto.RegisterType((*MsgLockAndSuperfluidDelegateResponse)(nil), "merlins.superfluid.MsgLockAndSuperfluidDelegateResponse")
	proto.RegisterType((*MsgCreateFullRangePositionAndSuperfluidDelegate)(nil), "merlins.superfluid.MsgCreateFullRangePositionAndSuperfluidDelegate")
	proto.RegisterType((*MsgCreateFullRangePositionAndSuperfluidDelegateResponse)(nil), "merlins.superfluid.MsgCreateFullRangePositionAndSuperfluidDelegateResponse")
	proto.RegisterType((*MsgUnPoolWhitelistedPool)(nil), "merlins.superfluid.MsgUnPoolWhitelistedPool")
	proto.RegisterType((*MsgUnPoolWhitelistedPoolResponse)(nil), "merlins.superfluid.MsgUnPoolWhitelistedPoolResponse")
	proto.RegisterType((*MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition)(nil), "merlins.superfluid.MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition")
	proto.RegisterType((*MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse)(nil), "merlins.superfluid.MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse")
	proto.RegisterType((*MsgAddToConcentratedLiquiditySuperfluidPosition)(nil), "merlins.superfluid.MsgAddToConcentratedLiquiditySuperfluidPosition")
	proto.RegisterType((*MsgAddToConcentratedLiquiditySuperfluidPositionResponse)(nil), "merlins.superfluid.MsgAddToConcentratedLiquiditySuperfluidPositionResponse")
}

func init() { proto.RegisterFile("merlins/superfluid/tx.proto", fileDescriptor_55b645f187d22814) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ 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 {
	// Execute superfluid delegation for a lockup
	SuperfluidDelegate(ctx context.Context, in *MsgSuperfluidDelegate, opts ...grpc.CallOption) (*MsgSuperfluidDelegateResponse, error)
	// Execute superfluid undelegation for a lockup
	SuperfluidUndelegate(ctx context.Context, in *MsgSuperfluidUndelegate, opts ...grpc.CallOption) (*MsgSuperfluidUndelegateResponse, error)
	// For a given lock that is being superfluidly undelegated,
	// also unbond the underlying lock.
	SuperfluidUnbondLock(ctx context.Context, in *MsgSuperfluidUnbondLock, opts ...grpc.CallOption) (*MsgSuperfluidUnbondLockResponse, error)
	// Superfluid undelegate and unbond partial amount of the underlying lock.
	SuperfluidUndelegateAndUnbondLock(ctx context.Context, in *MsgSuperfluidUndelegateAndUnbondLock, opts ...grpc.CallOption) (*MsgSuperfluidUndelegateAndUnbondLockResponse, error)
	// Execute lockup lock and superfluid delegation in a single msg
	LockAndSuperfluidDelegate(ctx context.Context, in *MsgLockAndSuperfluidDelegate, opts ...grpc.CallOption) (*MsgLockAndSuperfluidDelegateResponse, error)
	CreateFullRangePositionAndSuperfluidDelegate(ctx context.Context, in *MsgCreateFullRangePositionAndSuperfluidDelegate, opts ...grpc.CallOption) (*MsgCreateFullRangePositionAndSuperfluidDelegateResponse, error)
	UnPoolWhitelistedPool(ctx context.Context, in *MsgUnPoolWhitelistedPool, opts ...grpc.CallOption) (*MsgUnPoolWhitelistedPoolResponse, error)
	UnlockAndMigrateSharesToFullRangeConcentratedPosition(ctx context.Context, in *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition, opts ...grpc.CallOption) (*MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse, error)
	AddToConcentratedLiquiditySuperfluidPosition(ctx context.Context, in *MsgAddToConcentratedLiquiditySuperfluidPosition, opts ...grpc.CallOption) (*MsgAddToConcentratedLiquiditySuperfluidPositionResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) SuperfluidDelegate(ctx context.Context, in *MsgSuperfluidDelegate, opts ...grpc.CallOption) (*MsgSuperfluidDelegateResponse, error) {
	out := new(MsgSuperfluidDelegateResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/SuperfluidDelegate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SuperfluidUndelegate(ctx context.Context, in *MsgSuperfluidUndelegate, opts ...grpc.CallOption) (*MsgSuperfluidUndelegateResponse, error) {
	out := new(MsgSuperfluidUndelegateResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/SuperfluidUndelegate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SuperfluidUnbondLock(ctx context.Context, in *MsgSuperfluidUnbondLock, opts ...grpc.CallOption) (*MsgSuperfluidUnbondLockResponse, error) {
	out := new(MsgSuperfluidUnbondLockResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/SuperfluidUnbondLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SuperfluidUndelegateAndUnbondLock(ctx context.Context, in *MsgSuperfluidUndelegateAndUnbondLock, opts ...grpc.CallOption) (*MsgSuperfluidUndelegateAndUnbondLockResponse, error) {
	out := new(MsgSuperfluidUndelegateAndUnbondLockResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/SuperfluidUndelegateAndUnbondLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) LockAndSuperfluidDelegate(ctx context.Context, in *MsgLockAndSuperfluidDelegate, opts ...grpc.CallOption) (*MsgLockAndSuperfluidDelegateResponse, error) {
	out := new(MsgLockAndSuperfluidDelegateResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/LockAndSuperfluidDelegate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateFullRangePositionAndSuperfluidDelegate(ctx context.Context, in *MsgCreateFullRangePositionAndSuperfluidDelegate, opts ...grpc.CallOption) (*MsgCreateFullRangePositionAndSuperfluidDelegateResponse, error) {
	out := new(MsgCreateFullRangePositionAndSuperfluidDelegateResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/CreateFullRangePositionAndSuperfluidDelegate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UnPoolWhitelistedPool(ctx context.Context, in *MsgUnPoolWhitelistedPool, opts ...grpc.CallOption) (*MsgUnPoolWhitelistedPoolResponse, error) {
	out := new(MsgUnPoolWhitelistedPoolResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/UnPoolWhitelistedPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UnlockAndMigrateSharesToFullRangeConcentratedPosition(ctx context.Context, in *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition, opts ...grpc.CallOption) (*MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse, error) {
	out := new(MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/UnlockAndMigrateSharesToFullRangeConcentratedPosition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddToConcentratedLiquiditySuperfluidPosition(ctx context.Context, in *MsgAddToConcentratedLiquiditySuperfluidPosition, opts ...grpc.CallOption) (*MsgAddToConcentratedLiquiditySuperfluidPositionResponse, error) {
	out := new(MsgAddToConcentratedLiquiditySuperfluidPositionResponse)
	err := c.cc.Invoke(ctx, "/merlins.superfluid.Msg/AddToConcentratedLiquiditySuperfluidPosition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// Execute superfluid delegation for a lockup
	SuperfluidDelegate(context.Context, *MsgSuperfluidDelegate) (*MsgSuperfluidDelegateResponse, error)
	// Execute superfluid undelegation for a lockup
	SuperfluidUndelegate(context.Context, *MsgSuperfluidUndelegate) (*MsgSuperfluidUndelegateResponse, error)
	// For a given lock that is being superfluidly undelegated,
	// also unbond the underlying lock.
	SuperfluidUnbondLock(context.Context, *MsgSuperfluidUnbondLock) (*MsgSuperfluidUnbondLockResponse, error)
	// Superfluid undelegate and unbond partial amount of the underlying lock.
	SuperfluidUndelegateAndUnbondLock(context.Context, *MsgSuperfluidUndelegateAndUnbondLock) (*MsgSuperfluidUndelegateAndUnbondLockResponse, error)
	// Execute lockup lock and superfluid delegation in a single msg
	LockAndSuperfluidDelegate(context.Context, *MsgLockAndSuperfluidDelegate) (*MsgLockAndSuperfluidDelegateResponse, error)
	CreateFullRangePositionAndSuperfluidDelegate(context.Context, *MsgCreateFullRangePositionAndSuperfluidDelegate) (*MsgCreateFullRangePositionAndSuperfluidDelegateResponse, error)
	UnPoolWhitelistedPool(context.Context, *MsgUnPoolWhitelistedPool) (*MsgUnPoolWhitelistedPoolResponse, error)
	UnlockAndMigrateSharesToFullRangeConcentratedPosition(context.Context, *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) (*MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse, error)
	AddToConcentratedLiquiditySuperfluidPosition(context.Context, *MsgAddToConcentratedLiquiditySuperfluidPosition) (*MsgAddToConcentratedLiquiditySuperfluidPositionResponse, error)
}

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

func (*UnimplementedMsgServer) SuperfluidDelegate(ctx context.Context, req *MsgSuperfluidDelegate) (*MsgSuperfluidDelegateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SuperfluidDelegate not implemented")
}
func (*UnimplementedMsgServer) SuperfluidUndelegate(ctx context.Context, req *MsgSuperfluidUndelegate) (*MsgSuperfluidUndelegateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SuperfluidUndelegate not implemented")
}
func (*UnimplementedMsgServer) SuperfluidUnbondLock(ctx context.Context, req *MsgSuperfluidUnbondLock) (*MsgSuperfluidUnbondLockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SuperfluidUnbondLock not implemented")
}
func (*UnimplementedMsgServer) SuperfluidUndelegateAndUnbondLock(ctx context.Context, req *MsgSuperfluidUndelegateAndUnbondLock) (*MsgSuperfluidUndelegateAndUnbondLockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SuperfluidUndelegateAndUnbondLock not implemented")
}
func (*UnimplementedMsgServer) LockAndSuperfluidDelegate(ctx context.Context, req *MsgLockAndSuperfluidDelegate) (*MsgLockAndSuperfluidDelegateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LockAndSuperfluidDelegate not implemented")
}
func (*UnimplementedMsgServer) CreateFullRangePositionAndSuperfluidDelegate(ctx context.Context, req *MsgCreateFullRangePositionAndSuperfluidDelegate) (*MsgCreateFullRangePositionAndSuperfluidDelegateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateFullRangePositionAndSuperfluidDelegate not implemented")
}
func (*UnimplementedMsgServer) UnPoolWhitelistedPool(ctx context.Context, req *MsgUnPoolWhitelistedPool) (*MsgUnPoolWhitelistedPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnPoolWhitelistedPool not implemented")
}
func (*UnimplementedMsgServer) UnlockAndMigrateSharesToFullRangeConcentratedPosition(ctx context.Context, req *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) (*MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnlockAndMigrateSharesToFullRangeConcentratedPosition not implemented")
}
func (*UnimplementedMsgServer) AddToConcentratedLiquiditySuperfluidPosition(ctx context.Context, req *MsgAddToConcentratedLiquiditySuperfluidPosition) (*MsgAddToConcentratedLiquiditySuperfluidPositionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddToConcentratedLiquiditySuperfluidPosition not implemented")
}

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

func _Msg_SuperfluidDelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSuperfluidDelegate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SuperfluidDelegate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/SuperfluidDelegate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SuperfluidDelegate(ctx, req.(*MsgSuperfluidDelegate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SuperfluidUndelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSuperfluidUndelegate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SuperfluidUndelegate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/SuperfluidUndelegate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SuperfluidUndelegate(ctx, req.(*MsgSuperfluidUndelegate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SuperfluidUnbondLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSuperfluidUnbondLock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SuperfluidUnbondLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/SuperfluidUnbondLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SuperfluidUnbondLock(ctx, req.(*MsgSuperfluidUnbondLock))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SuperfluidUndelegateAndUnbondLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSuperfluidUndelegateAndUnbondLock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SuperfluidUndelegateAndUnbondLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/SuperfluidUndelegateAndUnbondLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SuperfluidUndelegateAndUnbondLock(ctx, req.(*MsgSuperfluidUndelegateAndUnbondLock))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_LockAndSuperfluidDelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgLockAndSuperfluidDelegate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).LockAndSuperfluidDelegate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/LockAndSuperfluidDelegate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).LockAndSuperfluidDelegate(ctx, req.(*MsgLockAndSuperfluidDelegate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateFullRangePositionAndSuperfluidDelegate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateFullRangePositionAndSuperfluidDelegate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateFullRangePositionAndSuperfluidDelegate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/CreateFullRangePositionAndSuperfluidDelegate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateFullRangePositionAndSuperfluidDelegate(ctx, req.(*MsgCreateFullRangePositionAndSuperfluidDelegate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UnPoolWhitelistedPool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnPoolWhitelistedPool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UnPoolWhitelistedPool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/UnPoolWhitelistedPool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UnPoolWhitelistedPool(ctx, req.(*MsgUnPoolWhitelistedPool))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UnlockAndMigrateSharesToFullRangeConcentratedPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UnlockAndMigrateSharesToFullRangeConcentratedPosition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/UnlockAndMigrateSharesToFullRangeConcentratedPosition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UnlockAndMigrateSharesToFullRangeConcentratedPosition(ctx, req.(*MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AddToConcentratedLiquiditySuperfluidPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddToConcentratedLiquiditySuperfluidPosition)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddToConcentratedLiquiditySuperfluidPosition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/merlins.superfluid.Msg/AddToConcentratedLiquiditySuperfluidPosition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddToConcentratedLiquiditySuperfluidPosition(ctx, req.(*MsgAddToConcentratedLiquiditySuperfluidPosition))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "merlins.superfluid.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SuperfluidDelegate",
			Handler:    _Msg_SuperfluidDelegate_Handler,
		},
		{
			MethodName: "SuperfluidUndelegate",
			Handler:    _Msg_SuperfluidUndelegate_Handler,
		},
		{
			MethodName: "SuperfluidUnbondLock",
			Handler:    _Msg_SuperfluidUnbondLock_Handler,
		},
		{
			MethodName: "SuperfluidUndelegateAndUnbondLock",
			Handler:    _Msg_SuperfluidUndelegateAndUnbondLock_Handler,
		},
		{
			MethodName: "LockAndSuperfluidDelegate",
			Handler:    _Msg_LockAndSuperfluidDelegate_Handler,
		},
		{
			MethodName: "CreateFullRangePositionAndSuperfluidDelegate",
			Handler:    _Msg_CreateFullRangePositionAndSuperfluidDelegate_Handler,
		},
		{
			MethodName: "UnPoolWhitelistedPool",
			Handler:    _Msg_UnPoolWhitelistedPool_Handler,
		},
		{
			MethodName: "UnlockAndMigrateSharesToFullRangeConcentratedPosition",
			Handler:    _Msg_UnlockAndMigrateSharesToFullRangeConcentratedPosition_Handler,
		},
		{
			MethodName: "AddToConcentratedLiquiditySuperfluidPosition",
			Handler:    _Msg_AddToConcentratedLiquiditySuperfluidPosition_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "merlins/superfluid/tx.proto",
}

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

func (m *MsgSuperfluidDelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValAddr) > 0 {
		i -= len(m.ValAddr)
		copy(dAtA[i:], m.ValAddr)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ValAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if m.LockId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.LockId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSuperfluidUndelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LockId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.LockId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSuperfluidUnbondLock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LockId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.LockId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgUnPoolWhitelistedPoolResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ExitedLockIds) > 0 {
		dAtA3 := make([]byte, len(m.ExitedLockIds)*10)
		var j2 int
		for _, num := range m.ExitedLockIds {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintTx(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.JoinTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime):])
	if err5 != nil {
		return 0, err5
	}
	i -= n5
	i = encodeVarintTx(dAtA, i, uint64(n5))
	i--
	dAtA[i] = 0x22
	{
		size := m.LiquidityCreated.Size()
		i -= size
		if _, err := m.LiquidityCreated.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Amount1.Size()
		i -= size
		if _, err := m.Amount1.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Amount0.Size()
		i -= size
		if _, err := m.Amount0.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.TokenDesired1.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.TokenDesired0.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if m.PositionId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PositionId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgAddToConcentratedLiquiditySuperfluidPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.NewLiquidity.Size()
		i -= size
		if _, err := m.NewLiquidity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.LockId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.LockId))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.Amount1.Size()
		i -= size
		if _, err := m.Amount1.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Amount0.Size()
		i -= size
		if _, err := m.Amount0.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.PositionId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PositionId))
		i--
		dAtA[i] = 0x8
	}
	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 *MsgSuperfluidDelegate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	l = len(m.ValAddr)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgSuperfluidUndelegate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	return n
}

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

func (m *MsgSuperfluidUnbondLock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	return n
}

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

func (m *MsgSuperfluidUndelegateAndUnbondLock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	l = m.Coin.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgSuperfluidUndelegateAndUnbondLockResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	return n
}

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

func (m *MsgLockAndSuperfluidDelegateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovTx(uint64(m.ID))
	}
	return n
}

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

func (m *MsgCreateFullRangePositionAndSuperfluidDelegateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LockID != 0 {
		n += 1 + sovTx(uint64(m.LockID))
	}
	if m.PositionID != 0 {
		n += 1 + sovTx(uint64(m.PositionID))
	}
	return n
}

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

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

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	l = m.SharesToMigrate.Size()
	n += 1 + l + sovTx(uint64(l))
	if len(m.TokenOutMins) > 0 {
		for _, e := range m.TokenOutMins {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Amount0.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Amount1.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.LiquidityCreated.Size()
	n += 1 + l + sovTx(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime)
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PositionId != 0 {
		n += 1 + sovTx(uint64(m.PositionId))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TokenDesired0.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.TokenDesired1.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgAddToConcentratedLiquiditySuperfluidPositionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PositionId != 0 {
		n += 1 + sovTx(uint64(m.PositionId))
	}
	l = m.Amount0.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Amount1.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.LockId != 0 {
		n += 1 + sovTx(uint64(m.LockId))
	}
	l = m.NewLiquidity.Size()
	n += 1 + l + sovTx(uint64(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 *MsgSuperfluidDelegate) 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: MsgSuperfluidDelegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidDelegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddr", 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.ValAddr = string(dAtA[iNdEx:postIndex])
			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 *MsgSuperfluidDelegateResponse) 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: MsgSuperfluidDelegateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidDelegateResponse: 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 *MsgSuperfluidUndelegate) 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: MsgSuperfluidUndelegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUndelegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgSuperfluidUndelegateResponse) 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: MsgSuperfluidUndelegateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUndelegateResponse: 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 *MsgSuperfluidUnbondLock) 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: MsgSuperfluidUnbondLock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUnbondLock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgSuperfluidUnbondLockResponse) 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: MsgSuperfluidUnbondLockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUnbondLockResponse: 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 *MsgSuperfluidUndelegateAndUnbondLock) 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: MsgSuperfluidUndelegateAndUnbondLock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUndelegateAndUnbondLock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coin", 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.Coin.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 *MsgSuperfluidUndelegateAndUnbondLockResponse) 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: MsgSuperfluidUndelegateAndUnbondLockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSuperfluidUndelegateAndUnbondLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgLockAndSuperfluidDelegate) 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: MsgLockAndSuperfluidDelegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLockAndSuperfluidDelegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coins", 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.Coins = append(m.Coins, types.Coin{})
			if err := m.Coins[len(m.Coins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddr", 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.ValAddr = string(dAtA[iNdEx:postIndex])
			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 *MsgLockAndSuperfluidDelegateResponse) 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: MsgLockAndSuperfluidDelegateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLockAndSuperfluidDelegateResponse: 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 ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgCreateFullRangePositionAndSuperfluidDelegate) 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: MsgCreateFullRangePositionAndSuperfluidDelegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateFullRangePositionAndSuperfluidDelegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coins", 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.Coins = append(m.Coins, types.Coin{})
			if err := m.Coins[len(m.Coins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddr", 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.ValAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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
				}
			}
		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 *MsgCreateFullRangePositionAndSuperfluidDelegateResponse) 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: MsgCreateFullRangePositionAndSuperfluidDelegateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateFullRangePositionAndSuperfluidDelegateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockID", wireType)
			}
			m.LockID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionID", wireType)
			}
			m.PositionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PositionID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgUnPoolWhitelistedPool) 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: MsgUnPoolWhitelistedPool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnPoolWhitelistedPool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = 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
				}
			}
		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 *MsgUnPoolWhitelistedPoolResponse) 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: MsgUnPoolWhitelistedPoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnPoolWhitelistedPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExitedLockIds = append(m.ExitedLockIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTx
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTx
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTx
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ExitedLockIds) == 0 {
					m.ExitedLockIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTx
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExitedLockIds = append(m.ExitedLockIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExitedLockIds", wireType)
			}
		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 *MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition) 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: MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnlockAndMigrateSharesToFullRangeConcentratedPosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharesToMigrate", 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.SharesToMigrate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenOutMins", 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.TokenOutMins = append(m.TokenOutMins, types.Coin{})
			if err := m.TokenOutMins[len(m.TokenOutMins)-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 *MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse) 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: MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnlockAndMigrateSharesToFullRangeConcentratedPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount0", 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.Amount0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount1", 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.Amount1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidityCreated", 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.LiquidityCreated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinTime", 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 := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.JoinTime, 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 *MsgAddToConcentratedLiquiditySuperfluidPosition) 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: MsgAddToConcentratedLiquiditySuperfluidPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddToConcentratedLiquiditySuperfluidPosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType)
			}
			m.PositionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PositionId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenDesired0", 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.TokenDesired0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenDesired1", 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.TokenDesired1.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 *MsgAddToConcentratedLiquiditySuperfluidPositionResponse) 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: MsgAddToConcentratedLiquiditySuperfluidPositionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddToConcentratedLiquiditySuperfluidPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType)
			}
			m.PositionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PositionId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount0", 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.Amount0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount1", 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.Amount1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType)
			}
			m.LockId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewLiquidity", 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.NewLiquidity.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 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")
)