tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: shentu/shield/v1alpha1/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"
	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

// MsgCreatePool defines the attributes of a create-pool transaction.
type MsgCreatePool struct {
	From        string                                   `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Shield      github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=shield,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"shield"`
	Deposit     github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=deposit,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"deposit"`
	Sponsor     string                                   `protobuf:"bytes,4,opt,name=sponsor,proto3" json:"sponsor,omitempty" yaml:"sponsor"`
	SponsorAddr string                                   `protobuf:"bytes,5,opt,name=sponsor_addr,json=sponsorAddr,proto3" json:"sponsor_addr,omitempty" yaml:"sponsor_addr"`
	Description string                                   `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	ShieldLimit github_com_cosmos_cosmos_sdk_types.Int   `protobuf:"bytes,7,opt,name=shield_limit,json=shieldLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"shield_limit"`
}

func (m *MsgCreatePool) Reset()         { *m = MsgCreatePool{} }
func (m *MsgCreatePool) String() string { return proto.CompactTextString(m) }
func (*MsgCreatePool) ProtoMessage()    {}
func (*MsgCreatePool) Descriptor() ([]byte, []int) {
	return fileDescriptor_e048a9056d0d0343, []int{0}
}
func (m *MsgCreatePool) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreatePool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreatePool.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreatePool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreatePool.Merge(m, src)
}
func (m *MsgCreatePool) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreatePool) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreatePool.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreatePool proto.InternalMessageInfo

type MsgCreatePoolResponse struct {
}

func (m *MsgCreatePoolResponse) Reset()         { *m = MsgCreatePoolResponse{} }
func (m *MsgCreatePoolResponse) String() string { return proto.CompactTextString(m) }
func (*MsgCreatePoolResponse) ProtoMessage()    {}
func (*MsgCreatePoolResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e048a9056d0d0343, []int{1}
}
func (m *MsgCreatePoolResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgCreatePoolResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgCreatePoolResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MsgCreatePoolResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgCreatePoolResponse.Merge(m, src)
}
func (m *MsgCreatePoolResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgCreatePoolResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgCreatePoolResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgCreatePoolResponse proto.InternalMessageInfo

// MsgUpdatePool defines the attributes of a shield pool update transaction.
type MsgUpdatePool struct {
	From        string                                   `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Shield      github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=shield,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"shield"`
	ServiceFees github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=service_fees,json=serviceFees,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"service_fees"`
	PoolId      uint64                                   `protobuf:"varint,4,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	Description string                                   `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	ShieldLimit github_com_cosmos_cosmos_sdk_types.Int   `protobuf:"bytes,6,opt,name=shield_limit,json=shieldLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"shield_limit"`
}

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

var xxx_messageInfo_MsgUpdatePool proto.InternalMessageInfo

type MsgUpdatePoolResponse struct {
}

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

var xxx_messageInfo_MsgUpdatePoolResponse proto.InternalMessageInfo

// MsgPausePool defines the attributes of a pausing a shield pool.
type MsgPausePool struct {
	From   string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
}

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

var xxx_messageInfo_MsgPausePool proto.InternalMessageInfo

type MsgPausePoolResponse struct {
}

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

var xxx_messageInfo_MsgPausePoolResponse proto.InternalMessageInfo

// MsgResumePool defines the attributes of a resuming a shield pool.
type MsgResumePool struct {
	From   string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
}

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

var xxx_messageInfo_MsgResumePool proto.InternalMessageInfo

type MsgResumePoolResponse struct {
}

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

var xxx_messageInfo_MsgResumePoolResponse proto.InternalMessageInfo

// MsgDepositCollateral defines the attributes of a depositing collaterals.
type MsgDepositCollateral struct {
	From       string                                   `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Collateral github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=collateral,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"collateral"`
}

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

var xxx_messageInfo_MsgDepositCollateral proto.InternalMessageInfo

type MsgDepositCollateralResponse struct {
}

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

var xxx_messageInfo_MsgDepositCollateralResponse proto.InternalMessageInfo

// NewMsgWithdrawCollateral defines the attributes of a withdrawing collaterals.
type MsgWithdrawCollateral struct {
	From       string                                   `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Collateral github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=collateral,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"collateral"`
}

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

var xxx_messageInfo_MsgWithdrawCollateral proto.InternalMessageInfo

type MsgWithdrawCollateralResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawCollateralResponse proto.InternalMessageInfo

// MsgWithdrawForeignRewards defines attribute of withdraw rewards transaction.
type MsgWithdrawRewards struct {
	From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgWithdrawRewards proto.InternalMessageInfo

type MsgWithdrawRewardsResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawRewardsResponse proto.InternalMessageInfo

// MsgWithdrawForeignRewards defines attributes of withdraw foreign rewards transaction.
type MsgWithdrawForeignRewards struct {
	From   string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Denom  string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
	ToAddr string `protobuf:"bytes,3,opt,name=to_addr,json=toAddr,proto3" json:"to_addr,omitempty" yaml:"to_addr"`
}

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

var xxx_messageInfo_MsgWithdrawForeignRewards proto.InternalMessageInfo

type MsgWithdrawForeignRewardsResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawForeignRewardsResponse proto.InternalMessageInfo

// MsgClearPayouts defines attributes of clear payouts transaction.
type MsgClearPayouts struct {
	From  string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
	Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
}

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

var xxx_messageInfo_MsgClearPayouts proto.InternalMessageInfo

type MsgClearPayoutsResponse struct {
}

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

var xxx_messageInfo_MsgClearPayoutsResponse proto.InternalMessageInfo

// MsgPurchaseShield defines the attributes of purchase shield transaction.
type MsgPurchaseShield struct {
	PoolId      uint64                                   `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	Shield      github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=shield,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"shield"`
	Description string                                   `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	From        string                                   `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgPurchaseShield proto.InternalMessageInfo

type MsgPurchaseShieldResponse struct {
}

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

var xxx_messageInfo_MsgPurchaseShieldResponse proto.InternalMessageInfo

// MsgWithdrawReimburse defines the attributes of withdraw reimbursement transaction.
type MsgWithdrawReimbursement struct {
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty" yaml:"proposal_id"`
	From       string `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgWithdrawReimbursement proto.InternalMessageInfo

type MsgWithdrawReimbursementResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawReimbursementResponse proto.InternalMessageInfo

// TODO: eliminate this msg type
// MsgStakeForShield defines the attributes of staking for purchase transaction.
type MsgStakeForShield struct {
	PoolId      uint64                                   `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	Shield      github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=shield,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"shield"`
	Description string                                   `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	From        string                                   `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgStakeForShield proto.InternalMessageInfo

type MsgStakeForShieldResponse struct {
}

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

var xxx_messageInfo_MsgStakeForShieldResponse proto.InternalMessageInfo

// MsgUnstakeFromShield defines the attributes of staking for purchase transaction.
type MsgUnstakeFromShield struct {
	PoolId uint64                                   `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	Shield github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=shield,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"shield"`
	From   string                                   `protobuf:"bytes,3,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgUnstakeFromShield proto.InternalMessageInfo

type MsgUnstakeFromShieldResponse struct {
}

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

var xxx_messageInfo_MsgUnstakeFromShieldResponse proto.InternalMessageInfo

// MsgUpdateSponsor defines the attributes of a update-sponsor transaction.
type MsgUpdateSponsor struct {
	PoolId      uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
	Sponsor     string `protobuf:"bytes,2,opt,name=sponsor,proto3" json:"sponsor,omitempty" yaml:"from"`
	SponsorAddr string `protobuf:"bytes,3,opt,name=sponsor_addr,json=sponsorAddr,proto3" json:"sponsor_addr,omitempty" yaml:"sponsor_addr"`
	From        string `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty" yaml:"from"`
}

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

var xxx_messageInfo_MsgUpdateSponsor proto.InternalMessageInfo

type MsgUpdateSponsorResponse struct {
}

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

var xxx_messageInfo_MsgUpdateSponsorResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreatePool)(nil), "shentu.shield.v1alpha1.MsgCreatePool")
	proto.RegisterType((*MsgCreatePoolResponse)(nil), "shentu.shield.v1alpha1.MsgCreatePoolResponse")
	proto.RegisterType((*MsgUpdatePool)(nil), "shentu.shield.v1alpha1.MsgUpdatePool")
	proto.RegisterType((*MsgUpdatePoolResponse)(nil), "shentu.shield.v1alpha1.MsgUpdatePoolResponse")
	proto.RegisterType((*MsgPausePool)(nil), "shentu.shield.v1alpha1.MsgPausePool")
	proto.RegisterType((*MsgPausePoolResponse)(nil), "shentu.shield.v1alpha1.MsgPausePoolResponse")
	proto.RegisterType((*MsgResumePool)(nil), "shentu.shield.v1alpha1.MsgResumePool")
	proto.RegisterType((*MsgResumePoolResponse)(nil), "shentu.shield.v1alpha1.MsgResumePoolResponse")
	proto.RegisterType((*MsgDepositCollateral)(nil), "shentu.shield.v1alpha1.MsgDepositCollateral")
	proto.RegisterType((*MsgDepositCollateralResponse)(nil), "shentu.shield.v1alpha1.MsgDepositCollateralResponse")
	proto.RegisterType((*MsgWithdrawCollateral)(nil), "shentu.shield.v1alpha1.MsgWithdrawCollateral")
	proto.RegisterType((*MsgWithdrawCollateralResponse)(nil), "shentu.shield.v1alpha1.MsgWithdrawCollateralResponse")
	proto.RegisterType((*MsgWithdrawRewards)(nil), "shentu.shield.v1alpha1.MsgWithdrawRewards")
	proto.RegisterType((*MsgWithdrawRewardsResponse)(nil), "shentu.shield.v1alpha1.MsgWithdrawRewardsResponse")
	proto.RegisterType((*MsgWithdrawForeignRewards)(nil), "shentu.shield.v1alpha1.MsgWithdrawForeignRewards")
	proto.RegisterType((*MsgWithdrawForeignRewardsResponse)(nil), "shentu.shield.v1alpha1.MsgWithdrawForeignRewardsResponse")
	proto.RegisterType((*MsgClearPayouts)(nil), "shentu.shield.v1alpha1.MsgClearPayouts")
	proto.RegisterType((*MsgClearPayoutsResponse)(nil), "shentu.shield.v1alpha1.MsgClearPayoutsResponse")
	proto.RegisterType((*MsgPurchaseShield)(nil), "shentu.shield.v1alpha1.MsgPurchaseShield")
	proto.RegisterType((*MsgPurchaseShieldResponse)(nil), "shentu.shield.v1alpha1.MsgPurchaseShieldResponse")
	proto.RegisterType((*MsgWithdrawReimbursement)(nil), "shentu.shield.v1alpha1.MsgWithdrawReimbursement")
	proto.RegisterType((*MsgWithdrawReimbursementResponse)(nil), "shentu.shield.v1alpha1.MsgWithdrawReimbursementResponse")
	proto.RegisterType((*MsgStakeForShield)(nil), "shentu.shield.v1alpha1.MsgStakeForShield")
	proto.RegisterType((*MsgStakeForShieldResponse)(nil), "shentu.shield.v1alpha1.MsgStakeForShieldResponse")
	proto.RegisterType((*MsgUnstakeFromShield)(nil), "shentu.shield.v1alpha1.MsgUnstakeFromShield")
	proto.RegisterType((*MsgUnstakeFromShieldResponse)(nil), "shentu.shield.v1alpha1.MsgUnstakeFromShieldResponse")
	proto.RegisterType((*MsgUpdateSponsor)(nil), "shentu.shield.v1alpha1.MsgUpdateSponsor")
	proto.RegisterType((*MsgUpdateSponsorResponse)(nil), "shentu.shield.v1alpha1.MsgUpdateSponsorResponse")
}

func init() { proto.RegisterFile("shentu/shield/v1alpha1/tx.proto", fileDescriptor_e048a9056d0d0343) }

var fileDescriptor_e048a9056d0d0343 = []byte{
	// 1133 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcf, 0x6f, 0xe3, 0xc4,
	0x17, 0x8f, 0x9b, 0x36, 0xfd, 0xf6, 0x25, 0xbb, 0xdd, 0xf5, 0x77, 0xb7, 0x4d, 0xcd, 0x12, 0x17,
	0x17, 0x56, 0x5d, 0xd8, 0xb5, 0x9b, 0x02, 0x62, 0xe9, 0x8d, 0x16, 0x55, 0xaa, 0xa0, 0x52, 0x71,
	0xb5, 0x42, 0xe2, 0x12, 0x39, 0xf1, 0x34, 0x31, 0x89, 0x3d, 0xc6, 0xe3, 0xb4, 0x5b, 0x6e, 0x80,
	0x84, 0x38, 0x21, 0xfe, 0x03, 0xf6, 0xcc, 0x11, 0xfe, 0x89, 0xbd, 0x20, 0xf6, 0x82, 0x40, 0x1c,
	0x02, 0x6a, 0x2f, 0x9c, 0xf3, 0x17, 0x20, 0x8f, 0xed, 0xc9, 0x38, 0x3f, 0x5c, 0x07, 0xb5, 0x68,
	0x91, 0x38, 0xc5, 0xc9, 0x7c, 0xde, 0x7b, 0x9f, 0xcf, 0x9b, 0x37, 0xf3, 0x5e, 0x0c, 0x32, 0x69,
	0x21, 0xc7, 0xef, 0x6a, 0xa4, 0x65, 0xa1, 0x8e, 0xa9, 0x1d, 0x57, 0x8d, 0x8e, 0xdb, 0x32, 0xaa,
	0x9a, 0xff, 0x58, 0x75, 0x3d, 0xec, 0x63, 0x71, 0x29, 0x04, 0xa8, 0x21, 0x40, 0x8d, 0x01, 0xd2,
	0xad, 0x26, 0x6e, 0x62, 0x0a, 0xd1, 0x82, 0xa7, 0x10, 0x2d, 0x55, 0x1a, 0x98, 0xd8, 0x98, 0x68,
	0x75, 0x83, 0x20, 0xed, 0xb8, 0x5a, 0x47, 0xbe, 0x51, 0xd5, 0x1a, 0xd8, 0x72, 0xa2, 0xf5, 0xb5,
	0x09, 0xe1, 0x22, 0xef, 0x14, 0xa4, 0x7c, 0x36, 0x0b, 0xd7, 0xf6, 0x49, 0x73, 0xc7, 0x43, 0x86,
	0x8f, 0x0e, 0x30, 0xee, 0x88, 0x6b, 0x30, 0x7b, 0xe4, 0x61, 0xbb, 0x2c, 0xac, 0x0a, 0xeb, 0x0b,
	0xdb, 0x8b, 0xfd, 0x9e, 0x5c, 0x3c, 0x35, 0xec, 0xce, 0x96, 0x12, 0xfc, 0xaa, 0xe8, 0x74, 0x51,
	0x6c, 0x40, 0x21, 0x74, 0x53, 0x9e, 0x59, 0xcd, 0xaf, 0x17, 0x37, 0x57, 0xd4, 0x90, 0x8c, 0x1a,
	0x90, 0x51, 0x23, 0x32, 0xea, 0x0e, 0xb6, 0x9c, 0xed, 0x8d, 0xa7, 0x3d, 0x39, 0xf7, 0xdd, 0xef,
	0xf2, 0x7a, 0xd3, 0xf2, 0x5b, 0xdd, 0xba, 0xda, 0xc0, 0xb6, 0x16, 0x31, 0x0f, 0x3f, 0x1e, 0x10,
	0xb3, 0xad, 0xf9, 0xa7, 0x2e, 0x22, 0xd4, 0x80, 0xe8, 0x91, 0x6b, 0x11, 0xc1, 0xbc, 0x89, 0x5c,
	0x4c, 0x2c, 0xbf, 0x9c, 0xbf, 0xfc, 0x28, 0xb1, 0x6f, 0xf1, 0x3e, 0xcc, 0x13, 0x17, 0x3b, 0x04,
	0x7b, 0xe5, 0x59, 0xaa, 0x59, 0xec, 0xf7, 0xe4, 0xeb, 0xa1, 0xe6, 0x68, 0x41, 0xd1, 0x63, 0x88,
	0xb8, 0x05, 0xa5, 0xe8, 0xb1, 0x66, 0x98, 0xa6, 0x57, 0x9e, 0xa3, 0x26, 0xcb, 0xfd, 0x9e, 0xfc,
	0xff, 0x84, 0x09, 0x5d, 0x55, 0xf4, 0x62, 0xf4, 0xf5, 0x1d, 0xd3, 0xf4, 0xc4, 0x87, 0x50, 0x34,
	0x11, 0x69, 0x78, 0x96, 0xeb, 0x5b, 0xd8, 0x29, 0x17, 0xa8, 0xe9, 0x52, 0xbf, 0x27, 0x8b, 0xa1,
	0x29, 0xb7, 0xa8, 0xe8, 0x3c, 0x54, 0xfc, 0x00, 0x4a, 0x61, 0x52, 0x6a, 0x1d, 0xcb, 0xb6, 0xfc,
	0xf2, 0x3c, 0x35, 0x55, 0x03, 0xd1, 0xbf, 0xf5, 0xe4, 0xbb, 0x19, 0x44, 0xef, 0x39, 0xbe, 0x5e,
	0x0c, 0x7d, 0xbc, 0x1f, 0xb8, 0xd8, 0xfa, 0xdf, 0x57, 0x4f, 0xe4, 0xdc, 0x9f, 0x4f, 0xe4, 0x9c,
	0xb2, 0x0c, 0xb7, 0x13, 0x25, 0xa0, 0x23, 0x4a, 0x1a, 0x29, 0x3f, 0xe6, 0x69, 0x71, 0x3c, 0x72,
	0xcd, 0xe7, 0xaf, 0x38, 0x1c, 0x28, 0x11, 0xe4, 0x1d, 0x5b, 0x0d, 0x54, 0x3b, 0x42, 0x88, 0x5c,
	0x45, 0x85, 0x14, 0xa3, 0x00, 0xbb, 0x08, 0x11, 0xf1, 0x35, 0x98, 0x77, 0x31, 0xee, 0xd4, 0x2c,
	0x93, 0x56, 0xc9, 0x2c, 0x5f, 0x25, 0xd1, 0x82, 0xa2, 0x17, 0x82, 0xa7, 0x3d, 0x73, 0x78, 0xa3,
	0xe7, 0xfe, 0xfe, 0x46, 0x17, 0x2e, 0x7f, 0xa3, 0x07, 0xdb, 0xc9, 0x36, 0xfa, 0x63, 0x28, 0xed,
	0x93, 0xe6, 0x81, 0xd1, 0x25, 0x53, 0x6c, 0x33, 0x97, 0x91, 0x99, 0x8b, 0x32, 0xc2, 0x91, 0x58,
	0x82, 0x5b, 0x7c, 0x2c, 0xc6, 0xa1, 0x4d, 0x6b, 0x4d, 0x47, 0xa4, 0x6b, 0x5f, 0x3d, 0x89, 0x30,
	0x13, 0x83, 0x60, 0x8c, 0xc5, 0xf7, 0x02, 0xa5, 0xf7, 0x6e, 0x78, 0x37, 0xec, 0xe0, 0x4e, 0xc7,
	0xf0, 0x91, 0x67, 0x64, 0x64, 0xd3, 0x06, 0x68, 0x30, 0x93, 0xab, 0xa8, 0x7e, 0xce, 0x3d, 0xa7,
	0xa6, 0x02, 0x77, 0xc6, 0x71, 0x66, 0xa2, 0x7e, 0x10, 0xa8, 0xdc, 0x0f, 0x2d, 0xbf, 0x65, 0x7a,
	0xc6, 0xc9, 0xbf, 0x44, 0x95, 0x0c, 0x2f, 0x8e, 0x25, 0xcd, 0x64, 0xed, 0x80, 0xc8, 0x01, 0x74,
	0x74, 0x62, 0x78, 0x26, 0xc9, 0x24, 0x89, 0x8b, 0x72, 0x07, 0xa4, 0x51, 0x27, 0x2c, 0xc4, 0xb7,
	0x02, 0xac, 0x70, 0xcb, 0xbb, 0xd8, 0x43, 0x56, 0xd3, 0x99, 0x26, 0x94, 0x78, 0x17, 0xe6, 0x4c,
	0xe4, 0x60, 0x9b, 0xd6, 0xe7, 0xc2, 0xf6, 0x8d, 0x7e, 0x4f, 0x2e, 0xc5, 0xb7, 0x80, 0x13, 0xc0,
	0xc2, 0xe5, 0xa0, 0x92, 0x7d, 0x1c, 0xf6, 0x94, 0xfc, 0x70, 0x1b, 0x8a, 0x16, 0x14, 0xbd, 0xe0,
	0xe3, 0xa0, 0x93, 0x70, 0xfc, 0xd7, 0xe0, 0xa5, 0x89, 0x04, 0x99, 0x8c, 0x16, 0x2c, 0x06, 0x37,
	0x7c, 0x07, 0x19, 0xde, 0x81, 0x71, 0x8a, 0xbb, 0xfe, 0xe5, 0x72, 0xe7, 0xe8, 0xac, 0xc0, 0xf2,
	0x50, 0x24, 0x46, 0xe2, 0xeb, 0x19, 0xb8, 0x19, 0x9c, 0xfc, 0xae, 0xd7, 0x68, 0x19, 0x04, 0x1d,
	0x86, 0xf7, 0x38, 0x77, 0x80, 0x85, 0x0b, 0xef, 0xd5, 0x7f, 0xa4, 0xb3, 0x0c, 0x5d, 0xde, 0xf9,
	0xec, 0x97, 0x77, 0x9c, 0xd3, 0xd9, 0x6c, 0xa5, 0xf7, 0x02, 0xad, 0xad, 0x64, 0x3e, 0x58, 0xb6,
	0x3e, 0x17, 0xa0, 0x9c, 0x28, 0x4c, 0xcb, 0xae, 0x77, 0x3d, 0x82, 0x6c, 0xe4, 0xf8, 0xe2, 0x5b,
	0x50, 0x74, 0x3d, 0xec, 0x62, 0x62, 0x70, 0x89, 0xe3, 0x28, 0x72, 0x8b, 0x8a, 0x0e, 0xf1, 0xb7,
	0x3d, 0x93, 0x31, 0x9c, 0xc9, 0xc6, 0x50, 0x81, 0xd5, 0x49, 0x1c, 0x86, 0xb7, 0xf5, 0xd0, 0x37,
	0xda, 0x68, 0x17, 0x7b, 0xff, 0x6d, 0x6b, 0xb8, 0xad, 0xc9, 0x7c, 0xb0, 0x6c, 0xfd, 0x12, 0xf6,
	0x97, 0x47, 0x0e, 0xa1, 0xeb, 0x1e, 0xb6, 0x9f, 0xdb, 0x84, 0xc5, 0xb2, 0xf3, 0xd9, 0x64, 0x87,
	0x4d, 0x68, 0x44, 0x18, 0x53, 0xfe, 0xb3, 0x00, 0x37, 0xd8, 0xf4, 0x71, 0x18, 0x4d, 0xd3, 0x53,
	0xa9, 0xbe, 0x37, 0x18, 0xd4, 0x27, 0xd4, 0xef, 0xc4, 0x29, 0x3d, 0x3f, 0xc5, 0x94, 0x3e, 0xe5,
	0x76, 0x4b, 0xf4, 0x9c, 0x26, 0x64, 0xc5, 0x9a, 0x37, 0x7f, 0x2a, 0x42, 0x7e, 0x9f, 0x34, 0xc5,
	0x3a, 0x00, 0xf7, 0x0f, 0xeb, 0x15, 0x75, 0xfc, 0xff, 0x3c, 0x35, 0x31, 0x85, 0x4b, 0x0f, 0x32,
	0xc1, 0xe2, 0x58, 0x41, 0x0c, 0x6e, 0x50, 0x4f, 0x8b, 0x31, 0x80, 0xa5, 0xc6, 0x18, 0x9d, 0x13,
	0xc5, 0x1a, 0x2c, 0x0c, 0x86, 0xc4, 0x97, 0x53, 0x6c, 0x19, 0x4a, 0xba, 0x9f, 0x05, 0xc5, 0x8b,
	0xe0, 0x26, 0xc0, 0x34, 0x11, 0x03, 0x58, 0xaa, 0x88, 0xd1, 0x11, 0x4f, 0x3c, 0x81, 0x9b, 0xa3,
	0xe3, 0x5d, 0x1a, 0xcd, 0x11, 0xb4, 0xf4, 0xc6, 0x34, 0x68, 0x16, 0xf8, 0x53, 0x10, 0xc7, 0x8c,
	0x60, 0x69, 0xec, 0x47, 0xe1, 0xd2, 0x9b, 0x53, 0xc1, 0x59, 0xec, 0x4f, 0x60, 0x71, 0x78, 0x50,
	0x7a, 0x35, 0x83, 0xa7, 0x08, 0x2b, 0x6d, 0x66, 0xc7, 0xb2, 0x90, 0x5f, 0x0a, 0xb0, 0x34, 0x61,
	0x70, 0xaa, 0x66, 0x70, 0x97, 0x34, 0x91, 0xde, 0x9e, 0xda, 0x84, 0x11, 0x71, 0xe0, 0xfa, 0xd0,
	0xd0, 0x71, 0x2f, 0xad, 0x28, 0x13, 0x50, 0xa9, 0x9a, 0x19, 0xca, 0xe2, 0x7d, 0x21, 0xc0, 0xed,
	0xf1, 0x7d, 0x7b, 0x23, 0x53, 0x1a, 0x39, 0x0b, 0xe9, 0xe1, 0xb4, 0x16, 0x8c, 0x45, 0x1b, 0xae,
	0x25, 0xef, 0xda, 0xf5, 0x0b, 0xcf, 0x7a, 0x84, 0x94, 0x36, 0xb2, 0x22, 0xf9, 0x14, 0x0f, 0x0d,
	0x00, 0x69, 0x29, 0x4e, 0x42, 0x53, 0x53, 0x3c, 0xbe, 0x8d, 0x06, 0x67, 0x78, 0xb4, 0x85, 0xa6,
	0x9d, 0xe1, 0x11, 0x74, 0xea, 0x19, 0x9e, 0xd8, 0xc5, 0xb6, 0xdf, 0x7b, 0x7a, 0x56, 0x11, 0x9e,
	0x9d, 0x55, 0x84, 0x3f, 0xce, 0x2a, 0xc2, 0x37, 0xe7, 0x95, 0xdc, 0xb3, 0xf3, 0x4a, 0xee, 0xd7,
	0xf3, 0x4a, 0xee, 0xa3, 0x2a, 0xd7, 0x60, 0x43, 0xcf, 0x47, 0xb8, 0xeb, 0x98, 0x46, 0x30, 0x42,
	0x44, 0x3f, 0x68, 0x8f, 0xe3, 0x97, 0x71, 0xb4, 0xdf, 0xd6, 0x0b, 0xf4, 0x1d, 0xdc, 0xeb, 0x7f,
	0x05, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x58, 0x87, 0xd4, 0x19, 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 {
	CreatePool(ctx context.Context, in *MsgCreatePool, opts ...grpc.CallOption) (*MsgCreatePoolResponse, error)
	UpdatePool(ctx context.Context, in *MsgUpdatePool, opts ...grpc.CallOption) (*MsgUpdatePoolResponse, error)
	PausePool(ctx context.Context, in *MsgPausePool, opts ...grpc.CallOption) (*MsgPausePoolResponse, error)
	ResumePool(ctx context.Context, in *MsgResumePool, opts ...grpc.CallOption) (*MsgResumePoolResponse, error)
	DepositCollateral(ctx context.Context, in *MsgDepositCollateral, opts ...grpc.CallOption) (*MsgDepositCollateralResponse, error)
	WithdrawCollateral(ctx context.Context, in *MsgWithdrawCollateral, opts ...grpc.CallOption) (*MsgWithdrawCollateralResponse, error)
	WithdrawRewards(ctx context.Context, in *MsgWithdrawRewards, opts ...grpc.CallOption) (*MsgWithdrawRewardsResponse, error)
	WithdrawForeignRewards(ctx context.Context, in *MsgWithdrawForeignRewards, opts ...grpc.CallOption) (*MsgWithdrawForeignRewardsResponse, error)
	PurchaseShield(ctx context.Context, in *MsgPurchaseShield, opts ...grpc.CallOption) (*MsgPurchaseShieldResponse, error)
	WithdrawReimbursement(ctx context.Context, in *MsgWithdrawReimbursement, opts ...grpc.CallOption) (*MsgWithdrawReimbursementResponse, error)
	UpdateSponsor(ctx context.Context, in *MsgUpdateSponsor, opts ...grpc.CallOption) (*MsgUpdateSponsorResponse, error)
	StakeForShield(ctx context.Context, in *MsgStakeForShield, opts ...grpc.CallOption) (*MsgStakeForShieldResponse, error)
	UnstakeFromShield(ctx context.Context, in *MsgUnstakeFromShield, opts ...grpc.CallOption) (*MsgUnstakeFromShieldResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

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

func (c *msgClient) UpdatePool(ctx context.Context, in *MsgUpdatePool, opts ...grpc.CallOption) (*MsgUpdatePoolResponse, error) {
	out := new(MsgUpdatePoolResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/UpdatePool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) PausePool(ctx context.Context, in *MsgPausePool, opts ...grpc.CallOption) (*MsgPausePoolResponse, error) {
	out := new(MsgPausePoolResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/PausePool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ResumePool(ctx context.Context, in *MsgResumePool, opts ...grpc.CallOption) (*MsgResumePoolResponse, error) {
	out := new(MsgResumePoolResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/ResumePool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DepositCollateral(ctx context.Context, in *MsgDepositCollateral, opts ...grpc.CallOption) (*MsgDepositCollateralResponse, error) {
	out := new(MsgDepositCollateralResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/DepositCollateral", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawCollateral(ctx context.Context, in *MsgWithdrawCollateral, opts ...grpc.CallOption) (*MsgWithdrawCollateralResponse, error) {
	out := new(MsgWithdrawCollateralResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/WithdrawCollateral", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawRewards(ctx context.Context, in *MsgWithdrawRewards, opts ...grpc.CallOption) (*MsgWithdrawRewardsResponse, error) {
	out := new(MsgWithdrawRewardsResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/WithdrawRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawForeignRewards(ctx context.Context, in *MsgWithdrawForeignRewards, opts ...grpc.CallOption) (*MsgWithdrawForeignRewardsResponse, error) {
	out := new(MsgWithdrawForeignRewardsResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/WithdrawForeignRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) PurchaseShield(ctx context.Context, in *MsgPurchaseShield, opts ...grpc.CallOption) (*MsgPurchaseShieldResponse, error) {
	out := new(MsgPurchaseShieldResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/PurchaseShield", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawReimbursement(ctx context.Context, in *MsgWithdrawReimbursement, opts ...grpc.CallOption) (*MsgWithdrawReimbursementResponse, error) {
	out := new(MsgWithdrawReimbursementResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/WithdrawReimbursement", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateSponsor(ctx context.Context, in *MsgUpdateSponsor, opts ...grpc.CallOption) (*MsgUpdateSponsorResponse, error) {
	out := new(MsgUpdateSponsorResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/UpdateSponsor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) StakeForShield(ctx context.Context, in *MsgStakeForShield, opts ...grpc.CallOption) (*MsgStakeForShieldResponse, error) {
	out := new(MsgStakeForShieldResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/StakeForShield", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UnstakeFromShield(ctx context.Context, in *MsgUnstakeFromShield, opts ...grpc.CallOption) (*MsgUnstakeFromShieldResponse, error) {
	out := new(MsgUnstakeFromShieldResponse)
	err := c.cc.Invoke(ctx, "/shentu.shield.v1alpha1.Msg/UnstakeFromShield", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	CreatePool(context.Context, *MsgCreatePool) (*MsgCreatePoolResponse, error)
	UpdatePool(context.Context, *MsgUpdatePool) (*MsgUpdatePoolResponse, error)
	PausePool(context.Context, *MsgPausePool) (*MsgPausePoolResponse, error)
	ResumePool(context.Context, *MsgResumePool) (*MsgResumePoolResponse, error)
	DepositCollateral(context.Context, *MsgDepositCollateral) (*MsgDepositCollateralResponse, error)
	WithdrawCollateral(context.Context, *MsgWithdrawCollateral) (*MsgWithdrawCollateralResponse, error)
	WithdrawRewards(context.Context, *MsgWithdrawRewards) (*MsgWithdrawRewardsResponse, error)
	WithdrawForeignRewards(context.Context, *MsgWithdrawForeignRewards) (*MsgWithdrawForeignRewardsResponse, error)
	PurchaseShield(context.Context, *MsgPurchaseShield) (*MsgPurchaseShieldResponse, error)
	WithdrawReimbursement(context.Context, *MsgWithdrawReimbursement) (*MsgWithdrawReimbursementResponse, error)
	UpdateSponsor(context.Context, *MsgUpdateSponsor) (*MsgUpdateSponsorResponse, error)
	StakeForShield(context.Context, *MsgStakeForShield) (*MsgStakeForShieldResponse, error)
	UnstakeFromShield(context.Context, *MsgUnstakeFromShield) (*MsgUnstakeFromShieldResponse, error)
}

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

func (*UnimplementedMsgServer) CreatePool(ctx context.Context, req *MsgCreatePool) (*MsgCreatePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePool not implemented")
}
func (*UnimplementedMsgServer) UpdatePool(ctx context.Context, req *MsgUpdatePool) (*MsgUpdatePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePool not implemented")
}
func (*UnimplementedMsgServer) PausePool(ctx context.Context, req *MsgPausePool) (*MsgPausePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PausePool not implemented")
}
func (*UnimplementedMsgServer) ResumePool(ctx context.Context, req *MsgResumePool) (*MsgResumePoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResumePool not implemented")
}
func (*UnimplementedMsgServer) DepositCollateral(ctx context.Context, req *MsgDepositCollateral) (*MsgDepositCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DepositCollateral not implemented")
}
func (*UnimplementedMsgServer) WithdrawCollateral(ctx context.Context, req *MsgWithdrawCollateral) (*MsgWithdrawCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawCollateral not implemented")
}
func (*UnimplementedMsgServer) WithdrawRewards(ctx context.Context, req *MsgWithdrawRewards) (*MsgWithdrawRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawRewards not implemented")
}
func (*UnimplementedMsgServer) WithdrawForeignRewards(ctx context.Context, req *MsgWithdrawForeignRewards) (*MsgWithdrawForeignRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawForeignRewards not implemented")
}
func (*UnimplementedMsgServer) PurchaseShield(ctx context.Context, req *MsgPurchaseShield) (*MsgPurchaseShieldResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PurchaseShield not implemented")
}
func (*UnimplementedMsgServer) WithdrawReimbursement(ctx context.Context, req *MsgWithdrawReimbursement) (*MsgWithdrawReimbursementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawReimbursement not implemented")
}
func (*UnimplementedMsgServer) UpdateSponsor(ctx context.Context, req *MsgUpdateSponsor) (*MsgUpdateSponsorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSponsor not implemented")
}
func (*UnimplementedMsgServer) StakeForShield(ctx context.Context, req *MsgStakeForShield) (*MsgStakeForShieldResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StakeForShield not implemented")
}
func (*UnimplementedMsgServer) UnstakeFromShield(ctx context.Context, req *MsgUnstakeFromShield) (*MsgUnstakeFromShieldResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnstakeFromShield not implemented")
}

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

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

func _Msg_UpdatePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdatePool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdatePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/UpdatePool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdatePool(ctx, req.(*MsgUpdatePool))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_PausePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgPausePool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).PausePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/PausePool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).PausePool(ctx, req.(*MsgPausePool))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ResumePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgResumePool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ResumePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/ResumePool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ResumePool(ctx, req.(*MsgResumePool))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DepositCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDepositCollateral)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DepositCollateral(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/DepositCollateral",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DepositCollateral(ctx, req.(*MsgDepositCollateral))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawCollateral)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawCollateral(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/WithdrawCollateral",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawCollateral(ctx, req.(*MsgWithdrawCollateral))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawRewards)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/WithdrawRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawRewards(ctx, req.(*MsgWithdrawRewards))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawForeignRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawForeignRewards)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawForeignRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/WithdrawForeignRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawForeignRewards(ctx, req.(*MsgWithdrawForeignRewards))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_PurchaseShield_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgPurchaseShield)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).PurchaseShield(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/PurchaseShield",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).PurchaseShield(ctx, req.(*MsgPurchaseShield))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawReimbursement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawReimbursement)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawReimbursement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/WithdrawReimbursement",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawReimbursement(ctx, req.(*MsgWithdrawReimbursement))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateSponsor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateSponsor)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateSponsor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/UpdateSponsor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateSponsor(ctx, req.(*MsgUpdateSponsor))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_StakeForShield_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgStakeForShield)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).StakeForShield(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/StakeForShield",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).StakeForShield(ctx, req.(*MsgStakeForShield))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UnstakeFromShield_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnstakeFromShield)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UnstakeFromShield(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/shentu.shield.v1alpha1.Msg/UnstakeFromShield",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UnstakeFromShield(ctx, req.(*MsgUnstakeFromShield))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "shentu.shield.v1alpha1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreatePool",
			Handler:    _Msg_CreatePool_Handler,
		},
		{
			MethodName: "UpdatePool",
			Handler:    _Msg_UpdatePool_Handler,
		},
		{
			MethodName: "PausePool",
			Handler:    _Msg_PausePool_Handler,
		},
		{
			MethodName: "ResumePool",
			Handler:    _Msg_ResumePool_Handler,
		},
		{
			MethodName: "DepositCollateral",
			Handler:    _Msg_DepositCollateral_Handler,
		},
		{
			MethodName: "WithdrawCollateral",
			Handler:    _Msg_WithdrawCollateral_Handler,
		},
		{
			MethodName: "WithdrawRewards",
			Handler:    _Msg_WithdrawRewards_Handler,
		},
		{
			MethodName: "WithdrawForeignRewards",
			Handler:    _Msg_WithdrawForeignRewards_Handler,
		},
		{
			MethodName: "PurchaseShield",
			Handler:    _Msg_PurchaseShield_Handler,
		},
		{
			MethodName: "WithdrawReimbursement",
			Handler:    _Msg_WithdrawReimbursement_Handler,
		},
		{
			MethodName: "UpdateSponsor",
			Handler:    _Msg_UpdateSponsor_Handler,
		},
		{
			MethodName: "StakeForShield",
			Handler:    _Msg_StakeForShield_Handler,
		},
		{
			MethodName: "UnstakeFromShield",
			Handler:    _Msg_UnstakeFromShield_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "shentu/shield/v1alpha1/tx.proto",
}

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

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

func (m *MsgCreatePool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ShieldLimit.Size()
		i -= size
		if _, err := m.ShieldLimit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.SponsorAddr) > 0 {
		i -= len(m.SponsorAddr)
		copy(dAtA[i:], m.SponsorAddr)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SponsorAddr)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Sponsor) > 0 {
		i -= len(m.Sponsor)
		copy(dAtA[i:], m.Sponsor)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sponsor)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Deposit) > 0 {
		for iNdEx := len(m.Deposit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Deposit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Shield) > 0 {
		for iNdEx := len(m.Shield) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Shield[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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *MsgUpdatePool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ShieldLimit.Size()
		i -= size
		if _, err := m.ShieldLimit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ServiceFees) > 0 {
		for iNdEx := len(m.ServiceFees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ServiceFees[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Shield) > 0 {
		for iNdEx := len(m.Shield) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Shield[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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgPausePool) 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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgResumePool) 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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDepositCollateral) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Collateral) > 0 {
		for iNdEx := len(m.Collateral) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Collateral[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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgWithdrawCollateral) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Collateral) > 0 {
		for iNdEx := len(m.Collateral) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Collateral[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.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgWithdrawForeignRewards) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ToAddr) > 0 {
		i -= len(m.ToAddr)
		copy(dAtA[i:], m.ToAddr)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgClearPayouts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgPurchaseShield) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Shield) > 0 {
		for iNdEx := len(m.Shield) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Shield[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgStakeForShield) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Shield) > 0 {
		for iNdEx := len(m.Shield) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Shield[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgUpdateSponsor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.From) > 0 {
		i -= len(m.From)
		copy(dAtA[i:], m.From)
		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SponsorAddr) > 0 {
		i -= len(m.SponsorAddr)
		copy(dAtA[i:], m.SponsorAddr)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SponsorAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Sponsor) > 0 {
		i -= len(m.Sponsor)
		copy(dAtA[i:], m.Sponsor)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sponsor)))
		i--
		dAtA[i] = 0x12
	}
	if m.PoolId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgCreatePool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Shield) > 0 {
		for _, e := range m.Shield {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.Deposit) > 0 {
		for _, e := range m.Deposit {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Sponsor)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SponsorAddr)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.ShieldLimit.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

func (m *MsgUpdatePool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Shield) > 0 {
		for _, e := range m.Shield {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.ServiceFees) > 0 {
		for _, e := range m.ServiceFees {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if m.PoolId != 0 {
		n += 1 + sovTx(uint64(m.PoolId))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.ShieldLimit.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgWithdrawForeignRewards) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ToAddr)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgCreatePool) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreatePool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreatePool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shield", 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.Shield = append(m.Shield, types.Coin{})
			if err := m.Shield[len(m.Shield)-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 Deposit", 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.Deposit = append(m.Deposit, types.Coin{})
			if err := m.Deposit[len(m.Deposit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sponsor", 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.Sponsor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SponsorAddr", 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.SponsorAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShieldLimit", 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.ShieldLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreatePoolResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreatePoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreatePoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdatePool) 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: MsgUpdatePool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdatePool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shield", 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.Shield = append(m.Shield, types.Coin{})
			if err := m.Shield[len(m.Shield)-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 ServiceFees", 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.ServiceFees = append(m.ServiceFees, types.Coin{})
			if err := m.ServiceFees[len(m.ServiceFees)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShieldLimit", 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.ShieldLimit.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 *MsgUpdatePoolResponse) 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: MsgUpdatePoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdatePoolResponse: 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 *MsgPausePool) 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: MsgPausePool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgPausePool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgPausePoolResponse) 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: MsgPausePoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgPausePoolResponse: 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 *MsgResumePool) 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: MsgResumePool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgResumePool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgResumePoolResponse) 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: MsgResumePoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgResumePoolResponse: 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 *MsgDepositCollateral) 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: MsgDepositCollateral: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositCollateral: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collateral", 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.Collateral = append(m.Collateral, types.Coin{})
			if err := m.Collateral[len(m.Collateral)-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 *MsgDepositCollateralResponse) 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: MsgDepositCollateralResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDepositCollateralResponse: 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 *MsgWithdrawCollateral) 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: MsgWithdrawCollateral: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawCollateral: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collateral", 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.Collateral = append(m.Collateral, types.Coin{})
			if err := m.Collateral[len(m.Collateral)-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 *MsgWithdrawCollateralResponse) 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: MsgWithdrawCollateralResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawCollateralResponse: 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 *MsgWithdrawRewards) 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: MsgWithdrawRewards: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawRewards: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgWithdrawRewardsResponse) 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: MsgWithdrawRewardsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawRewardsResponse: 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 *MsgWithdrawForeignRewards) 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: MsgWithdrawForeignRewards: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawForeignRewards: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddr", 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.ToAddr = 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 *MsgWithdrawForeignRewardsResponse) 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: MsgWithdrawForeignRewardsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawForeignRewardsResponse: 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 *MsgClearPayouts) 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: MsgClearPayouts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClearPayouts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Denom = 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 *MsgClearPayoutsResponse) 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: MsgClearPayoutsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClearPayoutsResponse: 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 *MsgPurchaseShield) 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: MsgPurchaseShield: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgPurchaseShield: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shield", 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.Shield = append(m.Shield, types.Coin{})
			if err := m.Shield[len(m.Shield)-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 Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgPurchaseShieldResponse) 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: MsgPurchaseShieldResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgPurchaseShieldResponse: 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 *MsgWithdrawReimbursement) 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: MsgWithdrawReimbursement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawReimbursement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType)
			}
			m.ProposalId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgWithdrawReimbursementResponse) 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: MsgWithdrawReimbursementResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawReimbursementResponse: 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 *MsgStakeForShield) 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: MsgStakeForShield: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgStakeForShield: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shield", 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.Shield = append(m.Shield, types.Coin{})
			if err := m.Shield[len(m.Shield)-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 Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgStakeForShieldResponse) 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: MsgStakeForShieldResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgStakeForShieldResponse: 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 *MsgUnstakeFromShield) 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: MsgUnstakeFromShield: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnstakeFromShield: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shield", 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.Shield = append(m.Shield, types.Coin{})
			if err := m.Shield[len(m.Shield)-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 From", 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.From = 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 *MsgUnstakeFromShieldResponse) 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: MsgUnstakeFromShieldResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnstakeFromShieldResponse: 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 *MsgUpdateSponsor) 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: MsgUpdateSponsor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateSponsor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sponsor", 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.Sponsor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SponsorAddr", 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.SponsorAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgUpdateSponsorResponse) 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: MsgUpdateSponsorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateSponsorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

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