// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: base/types/gfspserver/sign.proto

package gfspserver

import (
	context "context"
	fmt "fmt"
	gfsperrors "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsperrors"
	gfspp2p "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspp2p"
	gfsptask "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask"
	types3 "github.com/bnb-chain/greenfield/x/sp/types"
	types1 "github.com/bnb-chain/greenfield/x/storage/types"
	types2 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	types "github.com/cosmos/cosmos-sdk/types"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type GfSpSignSecondarySealBls struct {
	ObjectId             uint64   `protobuf:"varint,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
	GlobalVirtualGroupId uint32   `protobuf:"varint,2,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"`
	Checksums            [][]byte `protobuf:"bytes,3,rep,name=checksums,proto3" json:"checksums,omitempty"`
}

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

var xxx_messageInfo_GfSpSignSecondarySealBls proto.InternalMessageInfo

func (m *GfSpSignSecondarySealBls) GetObjectId() uint64 {
	if m != nil {
		return m.ObjectId
	}
	return 0
}

func (m *GfSpSignSecondarySealBls) GetGlobalVirtualGroupId() uint32 {
	if m != nil {
		return m.GlobalVirtualGroupId
	}
	return 0
}

func (m *GfSpSignSecondarySealBls) GetChecksums() [][]byte {
	if m != nil {
		return m.Checksums
	}
	return nil
}

// TODO: use chain MsgCreateGlobalVirtualGroup replace it.
type GfSpCreateGlobalVirtualGroup struct {
	VirtualGroupFamilyId uint32      `protobuf:"varint,1,opt,name=virtual_group_family_id,json=virtualGroupFamilyId,proto3" json:"virtual_group_family_id,omitempty"`
	PrimarySpAddress     string      `protobuf:"bytes,2,opt,name=primary_sp_address,json=primarySpAddress,proto3" json:"primary_sp_address,omitempty"`
	SecondarySpIds       []uint32    `protobuf:"varint,3,rep,packed,name=secondary_sp_ids,json=secondarySpIds,proto3" json:"secondary_sp_ids,omitempty"`
	Deposit              *types.Coin `protobuf:"bytes,4,opt,name=deposit,proto3" json:"deposit,omitempty"`
}

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

var xxx_messageInfo_GfSpCreateGlobalVirtualGroup proto.InternalMessageInfo

func (m *GfSpCreateGlobalVirtualGroup) GetVirtualGroupFamilyId() uint32 {
	if m != nil {
		return m.VirtualGroupFamilyId
	}
	return 0
}

func (m *GfSpCreateGlobalVirtualGroup) GetPrimarySpAddress() string {
	if m != nil {
		return m.PrimarySpAddress
	}
	return ""
}

func (m *GfSpCreateGlobalVirtualGroup) GetSecondarySpIds() []uint32 {
	if m != nil {
		return m.SecondarySpIds
	}
	return nil
}

func (m *GfSpCreateGlobalVirtualGroup) GetDeposit() *types.Coin {
	if m != nil {
		return m.Deposit
	}
	return nil
}

type GfSpSignRequest struct {
	// Types that are valid to be assigned to Request:
	//	*GfSpSignRequest_CreateBucketInfo
	//	*GfSpSignRequest_MigrateBucketInfo
	//	*GfSpSignRequest_CreateObjectInfo
	//	*GfSpSignRequest_SealObjectInfo
	//	*GfSpSignRequest_DiscontinueBucketInfo
	//	*GfSpSignRequest_SignSecondarySealBls
	//	*GfSpSignRequest_PingMsg
	//	*GfSpSignRequest_PongMsg
	//	*GfSpSignRequest_GfspReplicatePieceApprovalTask
	//	*GfSpSignRequest_GfspReceivePieceTask
	//	*GfSpSignRequest_GfspRecoverPieceTask
	//	*GfSpSignRequest_RejectObjectInfo
	//	*GfSpSignRequest_CreateGlobalVirtualGroup
	//	*GfSpSignRequest_GfspMigratePieceTask
	//	*GfSpSignRequest_CompleteMigrateBucket
	//	*GfSpSignRequest_SignSecondarySpMigrationBucket
	//	*GfSpSignRequest_SwapOut
	//	*GfSpSignRequest_SignSwapOut
	//	*GfSpSignRequest_CompleteSwapOut
	//	*GfSpSignRequest_SpExit
	//	*GfSpSignRequest_CompleteSpExit
	//	*GfSpSignRequest_SpStoragePrice
	//	*GfSpSignRequest_GfspMigrateGvgTask
	//	*GfSpSignRequest_GfspBucketMigrateInfo
	//	*GfSpSignRequest_RejectMigrateBucket
	//	*GfSpSignRequest_Deposit
	//	*GfSpSignRequest_DeleteGlobalVirtualGroup
	//	*GfSpSignRequest_ReserveSwapIn
	//	*GfSpSignRequest_CompleteSwapIn
	//	*GfSpSignRequest_CancelSwapIn
	//	*GfSpSignRequest_DelegateCreateObject
	//	*GfSpSignRequest_DelegateUpdateObjectContent
	//	*GfSpSignRequest_SealObjectInfoV2
	Request isGfSpSignRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_GfSpSignRequest proto.InternalMessageInfo

type isGfSpSignRequest_Request interface {
	isGfSpSignRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GfSpSignRequest_CreateBucketInfo struct {
	CreateBucketInfo *types1.MsgCreateBucket `protobuf:"bytes,1,opt,name=create_bucket_info,json=createBucketInfo,proto3,oneof" json:"create_bucket_info,omitempty"`
}
type GfSpSignRequest_MigrateBucketInfo struct {
	MigrateBucketInfo *types1.MsgMigrateBucket `protobuf:"bytes,2,opt,name=migrate_bucket_info,json=migrateBucketInfo,proto3,oneof" json:"migrate_bucket_info,omitempty"`
}
type GfSpSignRequest_CreateObjectInfo struct {
	CreateObjectInfo *types1.MsgCreateObject `protobuf:"bytes,3,opt,name=create_object_info,json=createObjectInfo,proto3,oneof" json:"create_object_info,omitempty"`
}
type GfSpSignRequest_SealObjectInfo struct {
	SealObjectInfo *types1.MsgSealObject `protobuf:"bytes,4,opt,name=seal_object_info,json=sealObjectInfo,proto3,oneof" json:"seal_object_info,omitempty"`
}
type GfSpSignRequest_DiscontinueBucketInfo struct {
	DiscontinueBucketInfo *types1.MsgDiscontinueBucket `protobuf:"bytes,5,opt,name=discontinue_bucket_info,json=discontinueBucketInfo,proto3,oneof" json:"discontinue_bucket_info,omitempty"`
}
type GfSpSignRequest_SignSecondarySealBls struct {
	SignSecondarySealBls *GfSpSignSecondarySealBls `protobuf:"bytes,6,opt,name=sign_secondary_seal_bls,json=signSecondarySealBls,proto3,oneof" json:"sign_secondary_seal_bls,omitempty"`
}
type GfSpSignRequest_PingMsg struct {
	PingMsg *gfspp2p.GfSpPing `protobuf:"bytes,7,opt,name=ping_msg,json=pingMsg,proto3,oneof" json:"ping_msg,omitempty"`
}
type GfSpSignRequest_PongMsg struct {
	PongMsg *gfspp2p.GfSpPong `protobuf:"bytes,8,opt,name=pong_msg,json=pongMsg,proto3,oneof" json:"pong_msg,omitempty"`
}
type GfSpSignRequest_GfspReplicatePieceApprovalTask struct {
	GfspReplicatePieceApprovalTask *gfsptask.GfSpReplicatePieceApprovalTask `protobuf:"bytes,9,opt,name=gfsp_replicate_piece_approval_task,json=gfspReplicatePieceApprovalTask,proto3,oneof" json:"gfsp_replicate_piece_approval_task,omitempty"`
}
type GfSpSignRequest_GfspReceivePieceTask struct {
	GfspReceivePieceTask *gfsptask.GfSpReceivePieceTask `protobuf:"bytes,10,opt,name=gfsp_receive_piece_task,json=gfspReceivePieceTask,proto3,oneof" json:"gfsp_receive_piece_task,omitempty"`
}
type GfSpSignRequest_GfspRecoverPieceTask struct {
	GfspRecoverPieceTask *gfsptask.GfSpRecoverPieceTask `protobuf:"bytes,11,opt,name=gfsp_recover_piece_task,json=gfspRecoverPieceTask,proto3,oneof" json:"gfsp_recover_piece_task,omitempty"`
}
type GfSpSignRequest_RejectObjectInfo struct {
	RejectObjectInfo *types1.MsgRejectSealObject `protobuf:"bytes,12,opt,name=reject_object_info,json=rejectObjectInfo,proto3,oneof" json:"reject_object_info,omitempty"`
}
type GfSpSignRequest_CreateGlobalVirtualGroup struct {
	CreateGlobalVirtualGroup *GfSpCreateGlobalVirtualGroup `protobuf:"bytes,13,opt,name=create_global_virtual_group,json=createGlobalVirtualGroup,proto3,oneof" json:"create_global_virtual_group,omitempty"`
}
type GfSpSignRequest_GfspMigratePieceTask struct {
	GfspMigratePieceTask *gfsptask.GfSpMigratePieceTask `protobuf:"bytes,14,opt,name=gfsp_migrate_piece_task,json=gfspMigratePieceTask,proto3,oneof" json:"gfsp_migrate_piece_task,omitempty"`
}
type GfSpSignRequest_CompleteMigrateBucket struct {
	CompleteMigrateBucket *types1.MsgCompleteMigrateBucket `protobuf:"bytes,15,opt,name=complete_migrate_bucket,json=completeMigrateBucket,proto3,oneof" json:"complete_migrate_bucket,omitempty"`
}
type GfSpSignRequest_SignSecondarySpMigrationBucket struct {
	SignSecondarySpMigrationBucket *types1.SecondarySpMigrationBucketSignDoc `protobuf:"bytes,16,opt,name=sign_secondary_sp_migration_bucket,json=signSecondarySpMigrationBucket,proto3,oneof" json:"sign_secondary_sp_migration_bucket,omitempty"`
}
type GfSpSignRequest_SwapOut struct {
	SwapOut *types2.MsgSwapOut `protobuf:"bytes,17,opt,name=swap_out,json=swapOut,proto3,oneof" json:"swap_out,omitempty"`
}
type GfSpSignRequest_SignSwapOut struct {
	SignSwapOut *types2.MsgSwapOut `protobuf:"bytes,18,opt,name=sign_swap_out,json=signSwapOut,proto3,oneof" json:"sign_swap_out,omitempty"`
}
type GfSpSignRequest_CompleteSwapOut struct {
	CompleteSwapOut *types2.MsgCompleteSwapOut `protobuf:"bytes,19,opt,name=complete_swap_out,json=completeSwapOut,proto3,oneof" json:"complete_swap_out,omitempty"`
}
type GfSpSignRequest_SpExit struct {
	SpExit *types2.MsgStorageProviderExit `protobuf:"bytes,20,opt,name=sp_exit,json=spExit,proto3,oneof" json:"sp_exit,omitempty"`
}
type GfSpSignRequest_CompleteSpExit struct {
	CompleteSpExit *types2.MsgCompleteStorageProviderExit `protobuf:"bytes,21,opt,name=complete_sp_exit,json=completeSpExit,proto3,oneof" json:"complete_sp_exit,omitempty"`
}
type GfSpSignRequest_SpStoragePrice struct {
	SpStoragePrice *types3.MsgUpdateSpStoragePrice `protobuf:"bytes,22,opt,name=sp_storage_price,json=spStoragePrice,proto3,oneof" json:"sp_storage_price,omitempty"`
}
type GfSpSignRequest_GfspMigrateGvgTask struct {
	GfspMigrateGvgTask *gfsptask.GfSpMigrateGVGTask `protobuf:"bytes,23,opt,name=gfsp_migrate_gvg_task,json=gfspMigrateGvgTask,proto3,oneof" json:"gfsp_migrate_gvg_task,omitempty"`
}
type GfSpSignRequest_GfspBucketMigrateInfo struct {
	GfspBucketMigrateInfo *gfsptask.GfSpBucketMigrationInfo `protobuf:"bytes,24,opt,name=gfsp_bucket_migrate_info,json=gfspBucketMigrateInfo,proto3,oneof" json:"gfsp_bucket_migrate_info,omitempty"`
}
type GfSpSignRequest_RejectMigrateBucket struct {
	RejectMigrateBucket *types1.MsgRejectMigrateBucket `protobuf:"bytes,25,opt,name=reject_migrate_bucket,json=rejectMigrateBucket,proto3,oneof" json:"reject_migrate_bucket,omitempty"`
}
type GfSpSignRequest_Deposit struct {
	Deposit *types2.MsgDeposit `protobuf:"bytes,26,opt,name=deposit,proto3,oneof" json:"deposit,omitempty"`
}
type GfSpSignRequest_DeleteGlobalVirtualGroup struct {
	DeleteGlobalVirtualGroup *types2.MsgDeleteGlobalVirtualGroup `protobuf:"bytes,27,opt,name=delete_global_virtual_group,json=deleteGlobalVirtualGroup,proto3,oneof" json:"delete_global_virtual_group,omitempty"`
}
type GfSpSignRequest_ReserveSwapIn struct {
	ReserveSwapIn *types2.MsgReserveSwapIn `protobuf:"bytes,28,opt,name=reserve_swap_in,json=reserveSwapIn,proto3,oneof" json:"reserve_swap_in,omitempty"`
}
type GfSpSignRequest_CompleteSwapIn struct {
	CompleteSwapIn *types2.MsgCompleteSwapIn `protobuf:"bytes,29,opt,name=complete_swap_in,json=completeSwapIn,proto3,oneof" json:"complete_swap_in,omitempty"`
}
type GfSpSignRequest_CancelSwapIn struct {
	CancelSwapIn *types2.MsgCancelSwapIn `protobuf:"bytes,30,opt,name=cancel_swap_in,json=cancelSwapIn,proto3,oneof" json:"cancel_swap_in,omitempty"`
}
type GfSpSignRequest_DelegateCreateObject struct {
	DelegateCreateObject *types1.MsgDelegateCreateObject `protobuf:"bytes,31,opt,name=delegate_create_object,json=delegateCreateObject,proto3,oneof" json:"delegate_create_object,omitempty"`
}
type GfSpSignRequest_DelegateUpdateObjectContent struct {
	DelegateUpdateObjectContent *types1.MsgDelegateUpdateObjectContent `protobuf:"bytes,32,opt,name=delegate_update_object_content,json=delegateUpdateObjectContent,proto3,oneof" json:"delegate_update_object_content,omitempty"`
}
type GfSpSignRequest_SealObjectInfoV2 struct {
	SealObjectInfoV2 *types1.MsgSealObjectV2 `protobuf:"bytes,33,opt,name=seal_object_info_v2,json=sealObjectInfoV2,proto3,oneof" json:"seal_object_info_v2,omitempty"`
}

func (*GfSpSignRequest_CreateBucketInfo) isGfSpSignRequest_Request()               {}
func (*GfSpSignRequest_MigrateBucketInfo) isGfSpSignRequest_Request()              {}
func (*GfSpSignRequest_CreateObjectInfo) isGfSpSignRequest_Request()               {}
func (*GfSpSignRequest_SealObjectInfo) isGfSpSignRequest_Request()                 {}
func (*GfSpSignRequest_DiscontinueBucketInfo) isGfSpSignRequest_Request()          {}
func (*GfSpSignRequest_SignSecondarySealBls) isGfSpSignRequest_Request()           {}
func (*GfSpSignRequest_PingMsg) isGfSpSignRequest_Request()                        {}
func (*GfSpSignRequest_PongMsg) isGfSpSignRequest_Request()                        {}
func (*GfSpSignRequest_GfspReplicatePieceApprovalTask) isGfSpSignRequest_Request() {}
func (*GfSpSignRequest_GfspReceivePieceTask) isGfSpSignRequest_Request()           {}
func (*GfSpSignRequest_GfspRecoverPieceTask) isGfSpSignRequest_Request()           {}
func (*GfSpSignRequest_RejectObjectInfo) isGfSpSignRequest_Request()               {}
func (*GfSpSignRequest_CreateGlobalVirtualGroup) isGfSpSignRequest_Request()       {}
func (*GfSpSignRequest_GfspMigratePieceTask) isGfSpSignRequest_Request()           {}
func (*GfSpSignRequest_CompleteMigrateBucket) isGfSpSignRequest_Request()          {}
func (*GfSpSignRequest_SignSecondarySpMigrationBucket) isGfSpSignRequest_Request() {}
func (*GfSpSignRequest_SwapOut) isGfSpSignRequest_Request()                        {}
func (*GfSpSignRequest_SignSwapOut) isGfSpSignRequest_Request()                    {}
func (*GfSpSignRequest_CompleteSwapOut) isGfSpSignRequest_Request()                {}
func (*GfSpSignRequest_SpExit) isGfSpSignRequest_Request()                         {}
func (*GfSpSignRequest_CompleteSpExit) isGfSpSignRequest_Request()                 {}
func (*GfSpSignRequest_SpStoragePrice) isGfSpSignRequest_Request()                 {}
func (*GfSpSignRequest_GfspMigrateGvgTask) isGfSpSignRequest_Request()             {}
func (*GfSpSignRequest_GfspBucketMigrateInfo) isGfSpSignRequest_Request()          {}
func (*GfSpSignRequest_RejectMigrateBucket) isGfSpSignRequest_Request()            {}
func (*GfSpSignRequest_Deposit) isGfSpSignRequest_Request()                        {}
func (*GfSpSignRequest_DeleteGlobalVirtualGroup) isGfSpSignRequest_Request()       {}
func (*GfSpSignRequest_ReserveSwapIn) isGfSpSignRequest_Request()                  {}
func (*GfSpSignRequest_CompleteSwapIn) isGfSpSignRequest_Request()                 {}
func (*GfSpSignRequest_CancelSwapIn) isGfSpSignRequest_Request()                   {}
func (*GfSpSignRequest_DelegateCreateObject) isGfSpSignRequest_Request()           {}
func (*GfSpSignRequest_DelegateUpdateObjectContent) isGfSpSignRequest_Request()    {}
func (*GfSpSignRequest_SealObjectInfoV2) isGfSpSignRequest_Request()               {}

func (m *GfSpSignRequest) GetRequest() isGfSpSignRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *GfSpSignRequest) GetCreateBucketInfo() *types1.MsgCreateBucket {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CreateBucketInfo); ok {
		return x.CreateBucketInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetMigrateBucketInfo() *types1.MsgMigrateBucket {
	if x, ok := m.GetRequest().(*GfSpSignRequest_MigrateBucketInfo); ok {
		return x.MigrateBucketInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetCreateObjectInfo() *types1.MsgCreateObject {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CreateObjectInfo); ok {
		return x.CreateObjectInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetSealObjectInfo() *types1.MsgSealObject {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SealObjectInfo); ok {
		return x.SealObjectInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetDiscontinueBucketInfo() *types1.MsgDiscontinueBucket {
	if x, ok := m.GetRequest().(*GfSpSignRequest_DiscontinueBucketInfo); ok {
		return x.DiscontinueBucketInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetSignSecondarySealBls() *GfSpSignSecondarySealBls {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SignSecondarySealBls); ok {
		return x.SignSecondarySealBls
	}
	return nil
}

func (m *GfSpSignRequest) GetPingMsg() *gfspp2p.GfSpPing {
	if x, ok := m.GetRequest().(*GfSpSignRequest_PingMsg); ok {
		return x.PingMsg
	}
	return nil
}

func (m *GfSpSignRequest) GetPongMsg() *gfspp2p.GfSpPong {
	if x, ok := m.GetRequest().(*GfSpSignRequest_PongMsg); ok {
		return x.PongMsg
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspReplicatePieceApprovalTask() *gfsptask.GfSpReplicatePieceApprovalTask {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspReplicatePieceApprovalTask); ok {
		return x.GfspReplicatePieceApprovalTask
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspReceivePieceTask() *gfsptask.GfSpReceivePieceTask {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspReceivePieceTask); ok {
		return x.GfspReceivePieceTask
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspRecoverPieceTask() *gfsptask.GfSpRecoverPieceTask {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspRecoverPieceTask); ok {
		return x.GfspRecoverPieceTask
	}
	return nil
}

func (m *GfSpSignRequest) GetRejectObjectInfo() *types1.MsgRejectSealObject {
	if x, ok := m.GetRequest().(*GfSpSignRequest_RejectObjectInfo); ok {
		return x.RejectObjectInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetCreateGlobalVirtualGroup() *GfSpCreateGlobalVirtualGroup {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CreateGlobalVirtualGroup); ok {
		return x.CreateGlobalVirtualGroup
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspMigratePieceTask() *gfsptask.GfSpMigratePieceTask {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspMigratePieceTask); ok {
		return x.GfspMigratePieceTask
	}
	return nil
}

func (m *GfSpSignRequest) GetCompleteMigrateBucket() *types1.MsgCompleteMigrateBucket {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CompleteMigrateBucket); ok {
		return x.CompleteMigrateBucket
	}
	return nil
}

func (m *GfSpSignRequest) GetSignSecondarySpMigrationBucket() *types1.SecondarySpMigrationBucketSignDoc {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SignSecondarySpMigrationBucket); ok {
		return x.SignSecondarySpMigrationBucket
	}
	return nil
}

func (m *GfSpSignRequest) GetSwapOut() *types2.MsgSwapOut {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SwapOut); ok {
		return x.SwapOut
	}
	return nil
}

func (m *GfSpSignRequest) GetSignSwapOut() *types2.MsgSwapOut {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SignSwapOut); ok {
		return x.SignSwapOut
	}
	return nil
}

func (m *GfSpSignRequest) GetCompleteSwapOut() *types2.MsgCompleteSwapOut {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CompleteSwapOut); ok {
		return x.CompleteSwapOut
	}
	return nil
}

func (m *GfSpSignRequest) GetSpExit() *types2.MsgStorageProviderExit {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SpExit); ok {
		return x.SpExit
	}
	return nil
}

func (m *GfSpSignRequest) GetCompleteSpExit() *types2.MsgCompleteStorageProviderExit {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CompleteSpExit); ok {
		return x.CompleteSpExit
	}
	return nil
}

func (m *GfSpSignRequest) GetSpStoragePrice() *types3.MsgUpdateSpStoragePrice {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SpStoragePrice); ok {
		return x.SpStoragePrice
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspMigrateGvgTask() *gfsptask.GfSpMigrateGVGTask {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspMigrateGvgTask); ok {
		return x.GfspMigrateGvgTask
	}
	return nil
}

func (m *GfSpSignRequest) GetGfspBucketMigrateInfo() *gfsptask.GfSpBucketMigrationInfo {
	if x, ok := m.GetRequest().(*GfSpSignRequest_GfspBucketMigrateInfo); ok {
		return x.GfspBucketMigrateInfo
	}
	return nil
}

func (m *GfSpSignRequest) GetRejectMigrateBucket() *types1.MsgRejectMigrateBucket {
	if x, ok := m.GetRequest().(*GfSpSignRequest_RejectMigrateBucket); ok {
		return x.RejectMigrateBucket
	}
	return nil
}

func (m *GfSpSignRequest) GetDeposit() *types2.MsgDeposit {
	if x, ok := m.GetRequest().(*GfSpSignRequest_Deposit); ok {
		return x.Deposit
	}
	return nil
}

func (m *GfSpSignRequest) GetDeleteGlobalVirtualGroup() *types2.MsgDeleteGlobalVirtualGroup {
	if x, ok := m.GetRequest().(*GfSpSignRequest_DeleteGlobalVirtualGroup); ok {
		return x.DeleteGlobalVirtualGroup
	}
	return nil
}

func (m *GfSpSignRequest) GetReserveSwapIn() *types2.MsgReserveSwapIn {
	if x, ok := m.GetRequest().(*GfSpSignRequest_ReserveSwapIn); ok {
		return x.ReserveSwapIn
	}
	return nil
}

func (m *GfSpSignRequest) GetCompleteSwapIn() *types2.MsgCompleteSwapIn {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CompleteSwapIn); ok {
		return x.CompleteSwapIn
	}
	return nil
}

func (m *GfSpSignRequest) GetCancelSwapIn() *types2.MsgCancelSwapIn {
	if x, ok := m.GetRequest().(*GfSpSignRequest_CancelSwapIn); ok {
		return x.CancelSwapIn
	}
	return nil
}

func (m *GfSpSignRequest) GetDelegateCreateObject() *types1.MsgDelegateCreateObject {
	if x, ok := m.GetRequest().(*GfSpSignRequest_DelegateCreateObject); ok {
		return x.DelegateCreateObject
	}
	return nil
}

func (m *GfSpSignRequest) GetDelegateUpdateObjectContent() *types1.MsgDelegateUpdateObjectContent {
	if x, ok := m.GetRequest().(*GfSpSignRequest_DelegateUpdateObjectContent); ok {
		return x.DelegateUpdateObjectContent
	}
	return nil
}

func (m *GfSpSignRequest) GetSealObjectInfoV2() *types1.MsgSealObjectV2 {
	if x, ok := m.GetRequest().(*GfSpSignRequest_SealObjectInfoV2); ok {
		return x.SealObjectInfoV2
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GfSpSignRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GfSpSignRequest_CreateBucketInfo)(nil),
		(*GfSpSignRequest_MigrateBucketInfo)(nil),
		(*GfSpSignRequest_CreateObjectInfo)(nil),
		(*GfSpSignRequest_SealObjectInfo)(nil),
		(*GfSpSignRequest_DiscontinueBucketInfo)(nil),
		(*GfSpSignRequest_SignSecondarySealBls)(nil),
		(*GfSpSignRequest_PingMsg)(nil),
		(*GfSpSignRequest_PongMsg)(nil),
		(*GfSpSignRequest_GfspReplicatePieceApprovalTask)(nil),
		(*GfSpSignRequest_GfspReceivePieceTask)(nil),
		(*GfSpSignRequest_GfspRecoverPieceTask)(nil),
		(*GfSpSignRequest_RejectObjectInfo)(nil),
		(*GfSpSignRequest_CreateGlobalVirtualGroup)(nil),
		(*GfSpSignRequest_GfspMigratePieceTask)(nil),
		(*GfSpSignRequest_CompleteMigrateBucket)(nil),
		(*GfSpSignRequest_SignSecondarySpMigrationBucket)(nil),
		(*GfSpSignRequest_SwapOut)(nil),
		(*GfSpSignRequest_SignSwapOut)(nil),
		(*GfSpSignRequest_CompleteSwapOut)(nil),
		(*GfSpSignRequest_SpExit)(nil),
		(*GfSpSignRequest_CompleteSpExit)(nil),
		(*GfSpSignRequest_SpStoragePrice)(nil),
		(*GfSpSignRequest_GfspMigrateGvgTask)(nil),
		(*GfSpSignRequest_GfspBucketMigrateInfo)(nil),
		(*GfSpSignRequest_RejectMigrateBucket)(nil),
		(*GfSpSignRequest_Deposit)(nil),
		(*GfSpSignRequest_DeleteGlobalVirtualGroup)(nil),
		(*GfSpSignRequest_ReserveSwapIn)(nil),
		(*GfSpSignRequest_CompleteSwapIn)(nil),
		(*GfSpSignRequest_CancelSwapIn)(nil),
		(*GfSpSignRequest_DelegateCreateObject)(nil),
		(*GfSpSignRequest_DelegateUpdateObjectContent)(nil),
		(*GfSpSignRequest_SealObjectInfoV2)(nil),
	}
}

type GfSpSignResponse struct {
	Err       *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
	Signature []byte                `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	TxHash    string                `protobuf:"bytes,3,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
}

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

var xxx_messageInfo_GfSpSignResponse proto.InternalMessageInfo

func (m *GfSpSignResponse) GetErr() *gfsperrors.GfSpError {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *GfSpSignResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *GfSpSignResponse) GetTxHash() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

func init() {
	proto.RegisterType((*GfSpSignSecondarySealBls)(nil), "base.types.gfspserver.GfSpSignSecondarySealBls")
	proto.RegisterType((*GfSpCreateGlobalVirtualGroup)(nil), "base.types.gfspserver.GfSpCreateGlobalVirtualGroup")
	proto.RegisterType((*GfSpSignRequest)(nil), "base.types.gfspserver.GfSpSignRequest")
	proto.RegisterType((*GfSpSignResponse)(nil), "base.types.gfspserver.GfSpSignResponse")
}

func init() { proto.RegisterFile("base/types/gfspserver/sign.proto", fileDescriptor_16c5938400680494) }

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

// GfSpSignServiceClient is the client API for GfSpSignService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GfSpSignServiceClient interface {
	GfSpSign(ctx context.Context, in *GfSpSignRequest, opts ...grpc.CallOption) (*GfSpSignResponse, error)
}

type gfSpSignServiceClient struct {
	cc grpc1.ClientConn
}

func NewGfSpSignServiceClient(cc grpc1.ClientConn) GfSpSignServiceClient {
	return &gfSpSignServiceClient{cc}
}

func (c *gfSpSignServiceClient) GfSpSign(ctx context.Context, in *GfSpSignRequest, opts ...grpc.CallOption) (*GfSpSignResponse, error) {
	out := new(GfSpSignResponse)
	err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpSignService/GfSpSign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GfSpSignServiceServer is the server API for GfSpSignService service.
type GfSpSignServiceServer interface {
	GfSpSign(context.Context, *GfSpSignRequest) (*GfSpSignResponse, error)
}

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

func (*UnimplementedGfSpSignServiceServer) GfSpSign(ctx context.Context, req *GfSpSignRequest) (*GfSpSignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GfSpSign not implemented")
}

func RegisterGfSpSignServiceServer(s grpc1.Server, srv GfSpSignServiceServer) {
	s.RegisterService(&_GfSpSignService_serviceDesc, srv)
}

func _GfSpSignService_GfSpSign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GfSpSignRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GfSpSignServiceServer).GfSpSign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/base.types.gfspserver.GfSpSignService/GfSpSign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GfSpSignServiceServer).GfSpSign(ctx, req.(*GfSpSignRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _GfSpSignService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "base.types.gfspserver.GfSpSignService",
	HandlerType: (*GfSpSignServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GfSpSign",
			Handler:    _GfSpSignService_GfSpSign_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "base/types/gfspserver/sign.proto",
}

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

func (m *GfSpSignSecondarySealBls) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Checksums) > 0 {
		for iNdEx := len(m.Checksums) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Checksums[iNdEx])
			copy(dAtA[i:], m.Checksums[iNdEx])
			i = encodeVarintSign(dAtA, i, uint64(len(m.Checksums[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.GlobalVirtualGroupId != 0 {
		i = encodeVarintSign(dAtA, i, uint64(m.GlobalVirtualGroupId))
		i--
		dAtA[i] = 0x10
	}
	if m.ObjectId != 0 {
		i = encodeVarintSign(dAtA, i, uint64(m.ObjectId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GfSpCreateGlobalVirtualGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Deposit != nil {
		{
			size, err := m.Deposit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.SecondarySpIds) > 0 {
		dAtA3 := make([]byte, len(m.SecondarySpIds)*10)
		var j2 int
		for _, num := range m.SecondarySpIds {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintSign(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PrimarySpAddress) > 0 {
		i -= len(m.PrimarySpAddress)
		copy(dAtA[i:], m.PrimarySpAddress)
		i = encodeVarintSign(dAtA, i, uint64(len(m.PrimarySpAddress)))
		i--
		dAtA[i] = 0x12
	}
	if m.VirtualGroupFamilyId != 0 {
		i = encodeVarintSign(dAtA, i, uint64(m.VirtualGroupFamilyId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GfSpSignRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *GfSpSignRequest_CreateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateBucketInfo != nil {
		{
			size, err := m.CreateBucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_MigrateBucketInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_MigrateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MigrateBucketInfo != nil {
		{
			size, err := m.MigrateBucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CreateObjectInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CreateObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateObjectInfo != nil {
		{
			size, err := m.CreateObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SealObjectInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SealObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SealObjectInfo != nil {
		{
			size, err := m.SealObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_DiscontinueBucketInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_DiscontinueBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DiscontinueBucketInfo != nil {
		{
			size, err := m.DiscontinueBucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SignSecondarySealBls) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SignSecondarySealBls) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignSecondarySealBls != nil {
		{
			size, err := m.SignSecondarySealBls.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_PingMsg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_PingMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PingMsg != nil {
		{
			size, err := m.PingMsg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_PongMsg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_PongMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PongMsg != nil {
		{
			size, err := m.PongMsg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspReplicatePieceApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspReplicatePieceApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspReplicatePieceApprovalTask != nil {
		{
			size, err := m.GfspReplicatePieceApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspReceivePieceTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspReceivePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspReceivePieceTask != nil {
		{
			size, err := m.GfspReceivePieceTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspRecoverPieceTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspRecoverPieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspRecoverPieceTask != nil {
		{
			size, err := m.GfspRecoverPieceTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_RejectObjectInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_RejectObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RejectObjectInfo != nil {
		{
			size, err := m.RejectObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CreateGlobalVirtualGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CreateGlobalVirtualGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateGlobalVirtualGroup != nil {
		{
			size, err := m.CreateGlobalVirtualGroup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspMigratePieceTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspMigratePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspMigratePieceTask != nil {
		{
			size, err := m.GfspMigratePieceTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CompleteMigrateBucket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CompleteMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompleteMigrateBucket != nil {
		{
			size, err := m.CompleteMigrateBucket.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SignSecondarySpMigrationBucket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SignSecondarySpMigrationBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignSecondarySpMigrationBucket != nil {
		{
			size, err := m.SignSecondarySpMigrationBucket.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SwapOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SwapOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SwapOut != nil {
		{
			size, err := m.SwapOut.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SignSwapOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SignSwapOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignSwapOut != nil {
		{
			size, err := m.SignSwapOut.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CompleteSwapOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CompleteSwapOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompleteSwapOut != nil {
		{
			size, err := m.CompleteSwapOut.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SpExit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SpExit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SpExit != nil {
		{
			size, err := m.SpExit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CompleteSpExit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CompleteSpExit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompleteSpExit != nil {
		{
			size, err := m.CompleteSpExit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SpStoragePrice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SpStoragePrice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SpStoragePrice != nil {
		{
			size, err := m.SpStoragePrice.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspMigrateGvgTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspMigrateGvgTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspMigrateGvgTask != nil {
		{
			size, err := m.GfspMigrateGvgTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_GfspBucketMigrateInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_GfspBucketMigrateInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GfspBucketMigrateInfo != nil {
		{
			size, err := m.GfspBucketMigrateInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_RejectMigrateBucket) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_RejectMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RejectMigrateBucket != nil {
		{
			size, err := m.RejectMigrateBucket.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_Deposit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_Deposit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Deposit != nil {
		{
			size, err := m.Deposit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_DeleteGlobalVirtualGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_DeleteGlobalVirtualGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DeleteGlobalVirtualGroup != nil {
		{
			size, err := m.DeleteGlobalVirtualGroup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xda
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_ReserveSwapIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_ReserveSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ReserveSwapIn != nil {
		{
			size, err := m.ReserveSwapIn.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CompleteSwapIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CompleteSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompleteSwapIn != nil {
		{
			size, err := m.CompleteSwapIn.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_CancelSwapIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_CancelSwapIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CancelSwapIn != nil {
		{
			size, err := m.CancelSwapIn.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_DelegateCreateObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_DelegateCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DelegateCreateObject != nil {
		{
			size, err := m.DelegateCreateObject.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_DelegateUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_DelegateUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DelegateUpdateObjectContent != nil {
		{
			size, err := m.DelegateUpdateObjectContent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignRequest_SealObjectInfoV2) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignRequest_SealObjectInfoV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SealObjectInfoV2 != nil {
		{
			size, err := m.SealObjectInfoV2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpSignResponse) 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 *GfSpSignResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpSignResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TxHash) > 0 {
		i -= len(m.TxHash)
		copy(dAtA[i:], m.TxHash)
		i = encodeVarintSign(dAtA, i, uint64(len(m.TxHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintSign(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSign(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintSign(dAtA []byte, offset int, v uint64) int {
	offset -= sovSign(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GfSpSignSecondarySealBls) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectId != 0 {
		n += 1 + sovSign(uint64(m.ObjectId))
	}
	if m.GlobalVirtualGroupId != 0 {
		n += 1 + sovSign(uint64(m.GlobalVirtualGroupId))
	}
	if len(m.Checksums) > 0 {
		for _, b := range m.Checksums {
			l = len(b)
			n += 1 + l + sovSign(uint64(l))
		}
	}
	return n
}

func (m *GfSpCreateGlobalVirtualGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VirtualGroupFamilyId != 0 {
		n += 1 + sovSign(uint64(m.VirtualGroupFamilyId))
	}
	l = len(m.PrimarySpAddress)
	if l > 0 {
		n += 1 + l + sovSign(uint64(l))
	}
	if len(m.SecondarySpIds) > 0 {
		l = 0
		for _, e := range m.SecondarySpIds {
			l += sovSign(uint64(e))
		}
		n += 1 + sovSign(uint64(l)) + l
	}
	if m.Deposit != nil {
		l = m.Deposit.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}

func (m *GfSpSignRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *GfSpSignRequest_CreateBucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateBucketInfo != nil {
		l = m.CreateBucketInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_MigrateBucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MigrateBucketInfo != nil {
		l = m.MigrateBucketInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CreateObjectInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateObjectInfo != nil {
		l = m.CreateObjectInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SealObjectInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SealObjectInfo != nil {
		l = m.SealObjectInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_DiscontinueBucketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DiscontinueBucketInfo != nil {
		l = m.DiscontinueBucketInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SignSecondarySealBls) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignSecondarySealBls != nil {
		l = m.SignSecondarySealBls.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_PingMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PingMsg != nil {
		l = m.PingMsg.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_PongMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PongMsg != nil {
		l = m.PongMsg.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspReplicatePieceApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspReplicatePieceApprovalTask != nil {
		l = m.GfspReplicatePieceApprovalTask.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspReceivePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspReceivePieceTask != nil {
		l = m.GfspReceivePieceTask.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspRecoverPieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspRecoverPieceTask != nil {
		l = m.GfspRecoverPieceTask.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_RejectObjectInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RejectObjectInfo != nil {
		l = m.RejectObjectInfo.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CreateGlobalVirtualGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateGlobalVirtualGroup != nil {
		l = m.CreateGlobalVirtualGroup.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspMigratePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspMigratePieceTask != nil {
		l = m.GfspMigratePieceTask.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CompleteMigrateBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompleteMigrateBucket != nil {
		l = m.CompleteMigrateBucket.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SignSecondarySpMigrationBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignSecondarySpMigrationBucket != nil {
		l = m.SignSecondarySpMigrationBucket.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SwapOut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SwapOut != nil {
		l = m.SwapOut.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SignSwapOut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignSwapOut != nil {
		l = m.SignSwapOut.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CompleteSwapOut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompleteSwapOut != nil {
		l = m.CompleteSwapOut.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SpExit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpExit != nil {
		l = m.SpExit.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CompleteSpExit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompleteSpExit != nil {
		l = m.CompleteSpExit.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SpStoragePrice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpStoragePrice != nil {
		l = m.SpStoragePrice.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspMigrateGvgTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspMigrateGvgTask != nil {
		l = m.GfspMigrateGvgTask.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_GfspBucketMigrateInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GfspBucketMigrateInfo != nil {
		l = m.GfspBucketMigrateInfo.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_RejectMigrateBucket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RejectMigrateBucket != nil {
		l = m.RejectMigrateBucket.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_Deposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Deposit != nil {
		l = m.Deposit.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_DeleteGlobalVirtualGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeleteGlobalVirtualGroup != nil {
		l = m.DeleteGlobalVirtualGroup.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_ReserveSwapIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReserveSwapIn != nil {
		l = m.ReserveSwapIn.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CompleteSwapIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompleteSwapIn != nil {
		l = m.CompleteSwapIn.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_CancelSwapIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CancelSwapIn != nil {
		l = m.CancelSwapIn.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_DelegateCreateObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DelegateCreateObject != nil {
		l = m.DelegateCreateObject.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_DelegateUpdateObjectContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DelegateUpdateObjectContent != nil {
		l = m.DelegateUpdateObjectContent.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignRequest_SealObjectInfoV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SealObjectInfoV2 != nil {
		l = m.SealObjectInfoV2.Size()
		n += 2 + l + sovSign(uint64(l))
	}
	return n
}
func (m *GfSpSignResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovSign(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovSign(uint64(l))
	}
	l = len(m.TxHash)
	if l > 0 {
		n += 1 + l + sovSign(uint64(l))
	}
	return n
}

func sovSign(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSign(x uint64) (n int) {
	return sovSign(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GfSpSignSecondarySealBls) 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 ErrIntOverflowSign
			}
			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: GfSpSignSecondarySealBls: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpSignSecondarySealBls: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			m.ObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType)
			}
			m.GlobalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checksums", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Checksums = append(m.Checksums, make([]byte, postIndex-iNdEx))
			copy(m.Checksums[len(m.Checksums)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSign(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSign
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpCreateGlobalVirtualGroup) 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 ErrIntOverflowSign
			}
			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: GfSpCreateGlobalVirtualGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpCreateGlobalVirtualGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupFamilyId", wireType)
			}
			m.VirtualGroupFamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VirtualGroupFamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				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 ErrInvalidLengthSign
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrimarySpAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSign
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.SecondarySpIds = append(m.SecondarySpIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSign
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSign
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSign
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.SecondarySpIds) == 0 {
					m.SecondarySpIds = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSign
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SecondarySpIds = append(m.SecondarySpIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondarySpIds", wireType)
			}
		case 4:
			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 ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Deposit == nil {
				m.Deposit = &types.Coin{}
			}
			if err := m.Deposit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSign(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSign
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpSignRequest) 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 ErrIntOverflowSign
			}
			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: GfSpSignRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpSignRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateBucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgCreateBucket{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CreateBucketInfo{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigrateBucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgMigrateBucket{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_MigrateBucketInfo{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgCreateObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CreateObjectInfo{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SealObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgSealObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SealObjectInfo{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiscontinueBucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgDiscontinueBucket{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_DiscontinueBucketInfo{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignSecondarySealBls", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GfSpSignSecondarySealBls{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SignSecondarySealBls{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PingMsg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfspp2p.GfSpPing{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_PingMsg{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PongMsg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfspp2p.GfSpPong{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_PongMsg{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspReplicatePieceApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpReplicatePieceApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspReplicatePieceApprovalTask{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspReceivePieceTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpReceivePieceTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspReceivePieceTask{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspRecoverPieceTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpRecoverPieceTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspRecoverPieceTask{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgRejectSealObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_RejectObjectInfo{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateGlobalVirtualGroup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GfSpCreateGlobalVirtualGroup{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CreateGlobalVirtualGroup{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspMigratePieceTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpMigratePieceTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspMigratePieceTask{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteMigrateBucket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgCompleteMigrateBucket{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CompleteMigrateBucket{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignSecondarySpMigrationBucket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.SecondarySpMigrationBucketSignDoc{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SignSecondarySpMigrationBucket{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapOut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgSwapOut{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SwapOut{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignSwapOut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgSwapOut{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SignSwapOut{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteSwapOut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgCompleteSwapOut{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CompleteSwapOut{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpExit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgStorageProviderExit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SpExit{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteSpExit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgCompleteStorageProviderExit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CompleteSpExit{v}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpStoragePrice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types3.MsgUpdateSpStoragePrice{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SpStoragePrice{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspMigrateGvgTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpMigrateGVGTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspMigrateGvgTask{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GfspBucketMigrateInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpBucketMigrationInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_GfspBucketMigrateInfo{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectMigrateBucket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgRejectMigrateBucket{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_RejectMigrateBucket{v}
			iNdEx = postIndex
		case 26:
			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 ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgDeposit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_Deposit{v}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteGlobalVirtualGroup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgDeleteGlobalVirtualGroup{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_DeleteGlobalVirtualGroup{v}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReserveSwapIn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgReserveSwapIn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_ReserveSwapIn{v}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompleteSwapIn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgCompleteSwapIn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CompleteSwapIn{v}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelSwapIn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types2.MsgCancelSwapIn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_CancelSwapIn{v}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateCreateObject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgDelegateCreateObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_DelegateCreateObject{v}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateUpdateObjectContent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgDelegateUpdateObjectContent{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_DelegateUpdateObjectContent{v}
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SealObjectInfoV2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSign
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSign
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSign
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types1.MsgSealObjectV2{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpSignRequest_SealObjectInfoV2{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSign(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSign
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthSign        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSign          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSign = fmt.Errorf("proto: unexpected end of group")
)
