tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: mokita/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/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "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"
)

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

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

type 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

// 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{6}
}
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{7}
}
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
}

// 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 umoki. 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{8}
}
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{9}
}
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
}

func init() {
	proto.RegisterType((*MsgSuperfluidDelegate)(nil), "mokita.superfluid.MsgSuperfluidDelegate")
	proto.RegisterType((*MsgSuperfluidDelegateResponse)(nil), "mokita.superfluid.MsgSuperfluidDelegateResponse")
	proto.RegisterType((*MsgSuperfluidUndelegate)(nil), "mokita.superfluid.MsgSuperfluidUndelegate")
	proto.RegisterType((*MsgSuperfluidUndelegateResponse)(nil), "mokita.superfluid.MsgSuperfluidUndelegateResponse")
	proto.RegisterType((*MsgSuperfluidUnbondLock)(nil), "mokita.superfluid.MsgSuperfluidUnbondLock")
	proto.RegisterType((*MsgSuperfluidUnbondLockResponse)(nil), "mokita.superfluid.MsgSuperfluidUnbondLockResponse")
	proto.RegisterType((*MsgLockAndSuperfluidDelegate)(nil), "mokita.superfluid.MsgLockAndSuperfluidDelegate")
	proto.RegisterType((*MsgLockAndSuperfluidDelegateResponse)(nil), "mokita.superfluid.MsgLockAndSuperfluidDelegateResponse")
	proto.RegisterType((*MsgUnPoolWhitelistedPool)(nil), "mokita.superfluid.MsgUnPoolWhitelistedPool")
	proto.RegisterType((*MsgUnPoolWhitelistedPoolResponse)(nil), "mokita.superfluid.MsgUnPoolWhitelistedPoolResponse")
}

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

var fileDescriptor_55b645f187d22814 = []byte{
	// 608 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
	0x10, 0x8e, 0x93, 0x90, 0xc0, 0xa2, 0x16, 0x61, 0xb5, 0xaa, 0x63, 0xc0, 0x0e, 0x06, 0xa1, 0xa0,
	0x52, 0x6f, 0xd3, 0xa0, 0x0a, 0x71, 0x6b, 0xc8, 0x25, 0xa8, 0x91, 0x2a, 0xa3, 0x0a, 0x09, 0x09,
	0x45, 0x76, 0x76, 0xeb, 0x5a, 0xd9, 0x78, 0x23, 0xaf, 0x63, 0xa5, 0xe2, 0x01, 0xb8, 0xf2, 0x1c,
	0xbc, 0x08, 0x3d, 0xf6, 0xc8, 0x29, 0xa0, 0xe4, 0x0d, 0x2a, 0x1e, 0x00, 0xf9, 0x37, 0x14, 0xec,
	0x90, 0x08, 0x7a, 0xf2, 0xce, 0xcc, 0xb7, 0xdf, 0x7c, 0xa3, 0x99, 0xf1, 0x82, 0x7b, 0x94, 0x0d,
	0x28, 0xb3, 0x18, 0x64, 0xa3, 0x21, 0x76, 0x4e, 0xc8, 0xc8, 0x42, 0xd0, 0x1d, 0xab, 0x43, 0x87,
	0xba, 0x94, 0xe7, 0xa3, 0xa0, 0x3a, 0x0f, 0x8a, 0x1b, 0x26, 0x35, 0x69, 0x10, 0x86, 0xfe, 0x29,
	0x44, 0x8a, 0x92, 0x49, 0xa9, 0x49, 0x30, 0x0c, 0x2c, 0x63, 0x74, 0x02, 0xd1, 0xc8, 0xd1, 0x5d,
	0x8b, 0xda, 0x71, 0xbc, 0x17, 0x50, 0x41, 0x43, 0x67, 0x18, 0x7a, 0x75, 0x03, 0xbb, 0x7a, 0x1d,
	0xf6, 0xa8, 0x15, 0xc7, 0x1f, 0xa5, 0xc8, 0x98, 0x1f, 0x43, 0x90, 0xe2, 0x81, 0xcd, 0x0e, 0x33,
	0xdf, 0x24, 0xee, 0x16, 0x26, 0xd8, 0xd4, 0x5d, 0xcc, 0x3f, 0x05, 0x25, 0x86, 0x6d, 0x84, 0x1d,
	0x81, 0xab, 0x72, 0xb5, 0x5b, 0xcd, 0xbb, 0x97, 0x13, 0x79, 0xed, 0x4c, 0x1f, 0x90, 0x97, 0x4a,
	0xe8, 0x57, 0xb4, 0x08, 0xc0, 0x6f, 0x81, 0x32, 0xa1, 0xbd, 0x7e, 0xd7, 0x42, 0x42, 0xbe, 0xca,
	0xd5, 0x8a, 0x5a, 0xc9, 0x37, 0xdb, 0x88, 0xaf, 0x80, 0x9b, 0x9e, 0x4e, 0xba, 0x3a, 0x42, 0x8e,
	0x50, 0xf0, 0x59, 0xb4, 0xb2, 0xa7, 0x93, 0x03, 0x84, 0x1c, 0x45, 0x06, 0x0f, 0x52, 0xf3, 0x6a,
	0x98, 0x0d, 0xa9, 0xcd, 0xb0, 0xf2, 0x1e, 0x6c, 0x5d, 0x01, 0x1c, 0xdb, 0xe8, 0x3f, 0x4a, 0x53,
	0x1e, 0x02, 0x39, 0x83, 0x7e, 0x81, 0x02, 0x83, 0xda, 0xe8, 0x90, 0xf6, 0xfa, 0xd7, 0xa4, 0x20,
	0xa6, 0x4f, 0x14, 0x7c, 0xe1, 0xc0, 0xfd, 0x0e, 0x33, 0x7d, 0xdf, 0x81, 0x8d, 0xfe, 0xad, 0x49,
	0x3a, 0xb8, 0xe1, 0xcf, 0x06, 0x13, 0xf2, 0xd5, 0x42, 0xed, 0xf6, 0x5e, 0x45, 0x0d, 0xa7, 0x47,
	0xf5, 0xa7, 0x47, 0x8d, 0xa6, 0x47, 0x7d, 0x45, 0x2d, 0xbb, 0xb9, 0x7b, 0x3e, 0x91, 0x73, 0x9f,
	0xbf, 0xc9, 0x35, 0xd3, 0x72, 0x4f, 0x47, 0x86, 0xda, 0xa3, 0x03, 0x18, 0x8d, 0x5a, 0xf8, 0xd9,
	0x61, 0xa8, 0x0f, 0xdd, 0xb3, 0x21, 0x66, 0xc1, 0x05, 0xa6, 0x85, 0xcc, 0x8b, 0xda, 0xbd, 0x0f,
	0x1e, 0x2f, 0x2a, 0x24, 0xae, 0x98, 0x5f, 0x07, 0xf9, 0x76, 0x2b, 0x28, 0xa6, 0xa8, 0xe5, 0xdb,
	0x2d, 0xc5, 0x01, 0x42, 0x87, 0x99, 0xc7, 0xf6, 0x11, 0xa5, 0xe4, 0xed, 0xa9, 0xe5, 0x62, 0x62,
	0x31, 0x17, 0x23, 0xdf, 0x5c, 0xa5, 0xf8, 0x6d, 0x50, 0x1e, 0x52, 0x4a, 0x92, 0x26, 0x34, 0xf9,
	0xcb, 0x89, 0xbc, 0x1e, 0x62, 0xa3, 0x80, 0xa2, 0x95, 0xfc, 0x53, 0x1b, 0x29, 0xaf, 0x41, 0x35,
	0x2b, 0x67, 0xa2, 0xf3, 0x09, 0xb8, 0x83, 0xc7, 0x96, 0x8b, 0x51, 0x37, 0x6a, 0x2e, 0x13, 0xb8,
	0x6a, 0xa1, 0x56, 0xd4, 0xd6, 0x42, 0xf7, 0x61, 0xd0, 0x63, 0xb6, 0xf7, 0xa3, 0x08, 0x0a, 0x1d,
	0x66, 0xf2, 0x0e, 0xe0, 0xd3, 0xda, 0xa7, 0xfe, 0xf9, 0x33, 0x50, 0x53, 0xd7, 0x42, 0xac, 0x2f,
	0x0d, 0x4d, 0x34, 0x8e, 0xc1, 0x46, 0xea, 0xfa, 0x6c, 0xff, 0x95, 0x6a, 0x0e, 0x16, 0x1b, 0x2b,
	0x80, 0xb3, 0x32, 0x27, 0x6b, 0xb3, 0x4c, 0xe6, 0x18, 0xbc, 0x54, 0xe6, 0xdf, 0x37, 0x86, 0xff,
	0xc8, 0x81, 0x4a, 0xf6, 0xba, 0xec, 0x66, 0x50, 0x66, 0xde, 0x10, 0x5f, 0xac, 0x7a, 0x23, 0x51,
	0xf2, 0x01, 0x6c, 0xa6, 0x8f, 0xed, 0xb3, 0x0c, 0xca, 0x54, 0xb4, 0xf8, 0x7c, 0x15, 0x74, 0x9c,
	0xbc, 0x79, 0x74, 0x3e, 0x95, 0xb8, 0x8b, 0xa9, 0xc4, 0x7d, 0x9f, 0x4a, 0xdc, 0xa7, 0x99, 0x94,
	0xbb, 0x98, 0x49, 0xb9, 0xaf, 0x33, 0x29, 0xf7, 0x6e, 0xff, 0x97, 0xa5, 0x8e, 0x98, 0x77, 0x88,
	0x6e, 0xb0, 0xd8, 0x80, 0x5e, 0xbd, 0x01, 0xc7, 0x57, 0x5e, 0x2e, 0x7f, 0xd1, 0x8d, 0x52, 0xf0,
	0x5c, 0x34, 0x7e, 0x06, 0x00, 0x00, 0xff, 0xff, 0x64, 0xb3, 0x1a, 0x05, 0xdc, 0x06, 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)
	// Execute lockup lock and superfluid delegation in a single msg
	LockAndSuperfluidDelegate(ctx context.Context, in *MsgLockAndSuperfluidDelegate, opts ...grpc.CallOption) (*MsgLockAndSuperfluidDelegateResponse, error)
	UnPoolWhitelistedPool(ctx context.Context, in *MsgUnPoolWhitelistedPool, opts ...grpc.CallOption) (*MsgUnPoolWhitelistedPoolResponse, 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, "/mokita.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, "/mokita.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, "/mokita.superfluid.Msg/SuperfluidUnbondLock", 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, "/mokita.superfluid.Msg/LockAndSuperfluidDelegate", 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, "/mokita.superfluid.Msg/UnPoolWhitelistedPool", 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)
	// Execute lockup lock and superfluid delegation in a single msg
	LockAndSuperfluidDelegate(context.Context, *MsgLockAndSuperfluidDelegate) (*MsgLockAndSuperfluidDelegateResponse, error)
	UnPoolWhitelistedPool(context.Context, *MsgUnPoolWhitelistedPool) (*MsgUnPoolWhitelistedPoolResponse, 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) LockAndSuperfluidDelegate(ctx context.Context, req *MsgLockAndSuperfluidDelegate) (*MsgLockAndSuperfluidDelegateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LockAndSuperfluidDelegate not implemented")
}
func (*UnimplementedMsgServer) UnPoolWhitelistedPool(ctx context.Context, req *MsgUnPoolWhitelistedPool) (*MsgUnPoolWhitelistedPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnPoolWhitelistedPool 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: "/mokita.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: "/mokita.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: "/mokita.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_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: "/mokita.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_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: "/mokita.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)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "mokita.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: "LockAndSuperfluidDelegate",
			Handler:    _Msg_LockAndSuperfluidDelegate_Handler,
		},
		{
			MethodName: "UnPoolWhitelistedPool",
			Handler:    _Msg_UnPoolWhitelistedPool_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mokita/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 *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 *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 {
		dAtA2 := make([]byte, len(m.ExitedLockIds)*10)
		var j1 int
		for _, num := range m.ExitedLockIds {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintTx(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0xa
	}
	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 *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 *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 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 *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 *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 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")
)