diff --git a/protos/guard/guard.pb.go b/protos/guard/guard.pb.go
index 59b8c6c..aa5fc87 100644
--- a/protos/guard/guard.pb.go
+++ b/protos/guard/guard.pb.go
@@ -103,6 +103,7 @@ const (
 	Contract_CLOSED   Contract_ContractState = 5
 	Contract_RENEWED  Contract_ContractState = 6
 	Contract_OBSOLETE Contract_ContractState = 7
+	Contract_WARN     Contract_ContractState = 8
 )
 
 var Contract_ContractState_name = map[int32]string{
@@ -114,6 +115,7 @@ var Contract_ContractState_name = map[int32]string{
 	5: "CLOSED",
 	6: "RENEWED",
 	7: "OBSOLETE",
+	8: "WARN",
 }
 
 var Contract_ContractState_value = map[string]int32{
@@ -125,6 +127,7 @@ var Contract_ContractState_value = map[string]int32{
 	"CLOSED":   5,
 	"RENEWED":  6,
 	"OBSOLETE": 7,
+	"WARN":     8,
 }
 
 func (x Contract_ContractState) String() string {
@@ -453,20 +456,25 @@ func (*ContractMeta) XXX_MessageName() string {
 
 type Contract struct {
 	//the contract executor record, changed frequently after proposal
-	ContractMeta         `protobuf:"bytes,1,opt,name=contract,proto3,embedded=contract" json:"contract" pg:"contract"`
-	State                Contract_ContractState `protobuf:"varint,2,opt,name=state,proto3,enum=guard.Contract_ContractState" json:"state,omitempty" pg:"state"`
-	RenterSignature      []byte                 `protobuf:"bytes,3,opt,name=renter_signature,json=renterSignature,proto3" json:"renter_signature,omitempty" pg:"renter_signature"`
-	HostSignature        []byte                 `protobuf:"bytes,4,opt,name=host_signature,json=hostSignature,proto3" json:"host_signature,omitempty" pg:"host_signature"`
-	EscrowSignedTime     time.Time              `protobuf:"bytes,5,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
-	EscrowSignature      []byte                 `protobuf:"bytes,6,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
-	ChangeLog            []*Log                 `protobuf:"bytes,7,rep,name=change_log,json=changeLog,proto3" json:"change_log,omitempty" pg:"change_log"`
-	LastModifyTime       time.Time              `protobuf:"bytes,8,opt,name=last_modify_time,json=lastModifyTime,proto3,stdtime" json:"last_modify_time" pg:"last_modify_time"`
-	GuardSignature       []byte                 `protobuf:"bytes,9,opt,name=guard_signature,json=guardSignature,proto3" json:"guard_signature,omitempty" pg:"guard_signature"`
-	PreparerPid          string                 `protobuf:"bytes,10,opt,name=preparer_pid,json=preparerPid,proto3" json:"preparer_pid,omitempty" pg:"preparer_pid"`
-	PreparerSignature    []byte                 `protobuf:"bytes,11,opt,name=preparer_signature,json=preparerSignature,proto3" json:"preparer_signature,omitempty" pg:"preparer_signature"`
-	XXX_NoUnkeyedLiteral struct{}               `json:"-" pg:"-"`
-	XXX_unrecognized     []byte                 `json:"-" pg:"-"`
-	XXX_sizecache        int32                  `json:"-" pg:"-"`
+	ContractMeta             `protobuf:"bytes,1,opt,name=contract,proto3,embedded=contract" json:"contract" pg:"contract"`
+	State                    Contract_ContractState `protobuf:"varint,2,opt,name=state,proto3,enum=guard.Contract_ContractState" json:"state,omitempty" pg:"state"`
+	RenterSignature          []byte                 `protobuf:"bytes,3,opt,name=renter_signature,json=renterSignature,proto3" json:"renter_signature,omitempty" pg:"renter_signature"`
+	HostSignature            []byte                 `protobuf:"bytes,4,opt,name=host_signature,json=hostSignature,proto3" json:"host_signature,omitempty" pg:"host_signature"`
+	EscrowSignedTime         time.Time              `protobuf:"bytes,5,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
+	EscrowSignature          []byte                 `protobuf:"bytes,6,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
+	ChangeLog                []*Log                 `protobuf:"bytes,7,rep,name=change_log,json=changeLog,proto3" json:"change_log,omitempty" pg:"change_log"`
+	LastModifyTime           time.Time              `protobuf:"bytes,8,opt,name=last_modify_time,json=lastModifyTime,proto3,stdtime" json:"last_modify_time" pg:"last_modify_time"`
+	GuardSignature           []byte                 `protobuf:"bytes,9,opt,name=guard_signature,json=guardSignature,proto3" json:"guard_signature,omitempty" pg:"guard_signature"`
+	PreparerPid              string                 `protobuf:"bytes,10,opt,name=preparer_pid,json=preparerPid,proto3" json:"preparer_pid,omitempty" pg:"preparer_pid"`
+	PreparerSignature        []byte                 `protobuf:"bytes,11,opt,name=preparer_signature,json=preparerSignature,proto3" json:"preparer_signature,omitempty" pg:"preparer_signature"`
+	LastSuccessChallengeTime time.Time              `protobuf:"bytes,12,opt,name=last_success_challenge_time,json=lastSuccessChallengeTime,proto3,stdtime" json:"last_success_challenge_time" pg:"last_success_challenge_time"`
+	LastChallengeTime        time.Time              `protobuf:"bytes,13,opt,name=last_challenge_time,json=lastChallengeTime,proto3,stdtime" json:"last_challenge_time" pg:"last_challenge_time"`
+	ChallengeTimes           int32                  `protobuf:"varint,14,opt,name=challenge_times,json=challengeTimes,proto3" json:"challenge_times,omitempty" pg:"challenge_times"`
+	ChallengeWarnTimes       int32                  `protobuf:"varint,15,opt,name=challenge_warn_times,json=challengeWarnTimes,proto3" json:"challenge_warn_times,omitempty" pg:"challenge_warn_times"`
+	ChallengeSuccessTimes    int32                  `protobuf:"varint,16,opt,name=challenge_success_times,json=challengeSuccessTimes,proto3" json:"challenge_success_times,omitempty" pg:"challenge_success_times"`
+	XXX_NoUnkeyedLiteral     struct{}               `json:"-" pg:"-"`
+	XXX_unrecognized         []byte                 `json:"-" pg:"-"`
+	XXX_sizecache            int32                  `json:"-" pg:"-"`
 }
 
 func (m *Contract) Reset()         { *m = Contract{} }
@@ -572,28 +580,66 @@ func (m *Contract) GetPreparerSignature() []byte {
 	return nil
 }
 
+func (m *Contract) GetLastSuccessChallengeTime() time.Time {
+	if m != nil {
+		return m.LastSuccessChallengeTime
+	}
+	return time.Time{}
+}
+
+func (m *Contract) GetLastChallengeTime() time.Time {
+	if m != nil {
+		return m.LastChallengeTime
+	}
+	return time.Time{}
+}
+
+func (m *Contract) GetChallengeTimes() int32 {
+	if m != nil {
+		return m.ChallengeTimes
+	}
+	return 0
+}
+
+func (m *Contract) GetChallengeWarnTimes() int32 {
+	if m != nil {
+		return m.ChallengeWarnTimes
+	}
+	return 0
+}
+
+func (m *Contract) GetChallengeSuccessTimes() int32 {
+	if m != nil {
+		return m.ChallengeSuccessTimes
+	}
+	return 0
+}
+
 func (*Contract) XXX_MessageName() string {
 	return "guard.Contract"
 }
 
 type FileStoreMeta struct {
 	//file store meta prepared by renter, will not changed after proposal
-	RenterPid            string    `protobuf:"bytes,1,opt,name=renter_pid,json=renterPid,proto3" json:"renter_pid,omitempty" pg:"renter_pid"`
-	FileHash             string    `protobuf:"bytes,2,opt,name=file_hash,json=fileHash,proto3" json:"file_hash,omitempty" pg:"file_hash"`
-	FileSize             int64     `protobuf:"varint,3,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty" pg:"file_size"`
-	RentStart            time.Time `protobuf:"bytes,4,opt,name=rent_start,json=rentStart,proto3,stdtime" json:"rent_start" pg:"rent_start"`
-	RentEnd              time.Time `protobuf:"bytes,5,opt,name=rent_end,json=rentEnd,proto3,stdtime" json:"rent_end" pg:"rent_end"`
-	CheckFrequency       int32     `protobuf:"varint,6,opt,name=check_frequency,json=checkFrequency,proto3" json:"check_frequency,omitempty" pg:"check_frequency"`
-	GuardFee             int64     `protobuf:"varint,7,opt,name=guard_fee,json=guardFee,proto3" json:"guard_fee,omitempty" pg:"guard_fee"`
-	EscrowFee            int64     `protobuf:"varint,8,opt,name=escrow_fee,json=escrowFee,proto3" json:"escrow_fee,omitempty" pg:"escrow_fee"`
-	ShardCount           int32     `protobuf:"varint,9,opt,name=shard_count,json=shardCount,proto3" json:"shard_count,omitempty" pg:"shard_count"`
-	MinimumShards        int32     `protobuf:"varint,10,opt,name=minimum_shards,json=minimumShards,proto3" json:"minimum_shards,omitempty" pg:"minimum_shards"`
-	RecoverThreshold     int32     `protobuf:"varint,11,opt,name=recover_threshold,json=recoverThreshold,proto3" json:"recover_threshold,omitempty" pg:"recover_threshold"`
-	EscrowPid            string    `protobuf:"bytes,12,opt,name=escrow_pid,json=escrowPid,proto3" json:"escrow_pid,omitempty" pg:"escrow_pid"`
-	GuardPid             string    `protobuf:"bytes,13,opt,name=guard_pid,json=guardPid,proto3" json:"guard_pid,omitempty" pg:"guard_pid"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
-	XXX_unrecognized     []byte    `json:"-" pg:"-"`
-	XXX_sizecache        int32     `json:"-" pg:"-"`
+	RenterPid                  string    `protobuf:"bytes,1,opt,name=renter_pid,json=renterPid,proto3" json:"renter_pid,omitempty" pg:"renter_pid"`
+	FileHash                   string    `protobuf:"bytes,2,opt,name=file_hash,json=fileHash,proto3" json:"file_hash,omitempty" pg:"file_hash"`
+	FileSize                   int64     `protobuf:"varint,3,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty" pg:"file_size"`
+	RentStart                  time.Time `protobuf:"bytes,4,opt,name=rent_start,json=rentStart,proto3,stdtime" json:"rent_start" pg:"rent_start"`
+	RentEnd                    time.Time `protobuf:"bytes,5,opt,name=rent_end,json=rentEnd,proto3,stdtime" json:"rent_end" pg:"rent_end"`
+	CheckFrequency             int32     `protobuf:"varint,6,opt,name=check_frequency,json=checkFrequency,proto3" json:"check_frequency,omitempty" pg:"check_frequency"`
+	GuardFee                   int64     `protobuf:"varint,7,opt,name=guard_fee,json=guardFee,proto3" json:"guard_fee,omitempty" pg:"guard_fee"`
+	EscrowFee                  int64     `protobuf:"varint,8,opt,name=escrow_fee,json=escrowFee,proto3" json:"escrow_fee,omitempty" pg:"escrow_fee"`
+	ShardCount                 int32     `protobuf:"varint,9,opt,name=shard_count,json=shardCount,proto3" json:"shard_count,omitempty" pg:"shard_count"`
+	MinimumShards              int32     `protobuf:"varint,10,opt,name=minimum_shards,json=minimumShards,proto3" json:"minimum_shards,omitempty" pg:"minimum_shards"`
+	RecoverThreshold           int32     `protobuf:"varint,11,opt,name=recover_threshold,json=recoverThreshold,proto3" json:"recover_threshold,omitempty" pg:"recover_threshold"`
+	EscrowPid                  string    `protobuf:"bytes,12,opt,name=escrow_pid,json=escrowPid,proto3" json:"escrow_pid,omitempty" pg:"escrow_pid"`
+	GuardPid                   string    `protobuf:"bytes,13,opt,name=guard_pid,json=guardPid,proto3" json:"guard_pid,omitempty" pg:"guard_pid"`
+	WarnChallengeTimesLimit    int32     `protobuf:"varint,14,opt,name=warn_challenge_times_limit,json=warnChallengeTimesLimit,proto3" json:"warn_challenge_times_limit,omitempty" pg:"warn_challenge_times_limit"`
+	SuccessChallengeTimesLimit int32     `protobuf:"varint,15,opt,name=success_challenge_times_limit,json=successChallengeTimesLimit,proto3" json:"success_challenge_times_limit,omitempty" pg:"success_challenge_times_limit"`
+	CheckFrequencyWarn         int32     `protobuf:"varint,16,opt,name=check_frequency_warn,json=checkFrequencyWarn,proto3" json:"check_frequency_warn,omitempty" pg:"check_frequency_warn"`
+	XXX_NoUnkeyedLiteral       struct{}  `json:"-" pg:"-"`
+	XXX_unrecognized           []byte    `json:"-" pg:"-"`
+	XXX_sizecache              int32     `json:"-" pg:"-"`
 }
 
 func (m *FileStoreMeta) Reset()         { *m = FileStoreMeta{} }
@@ -720,6 +766,27 @@ func (m *FileStoreMeta) GetGuardPid() string {
 	return ""
 }
 
+func (m *FileStoreMeta) GetWarnChallengeTimesLimit() int32 {
+	if m != nil {
+		return m.WarnChallengeTimesLimit
+	}
+	return 0
+}
+
+func (m *FileStoreMeta) GetSuccessChallengeTimesLimit() int32 {
+	if m != nil {
+		return m.SuccessChallengeTimesLimit
+	}
+	return 0
+}
+
+func (m *FileStoreMeta) GetCheckFrequencyWarn() int32 {
+	if m != nil {
+		return m.CheckFrequencyWarn
+	}
+	return 0
+}
+
 func (*FileStoreMeta) XXX_MessageName() string {
 	return "guard.FileStoreMeta"
 }
@@ -1369,121 +1436,130 @@ func init() { proto.RegisterFile("protos/guard/guard.proto", fileDescriptor_ad5b
 func init() { golang_proto.RegisterFile("protos/guard/guard.proto", fileDescriptor_ad5b6eccdc9ebee8) }
 
 var fileDescriptor_ad5b6eccdc9ebee8 = []byte{
-	// 1810 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0xdb, 0xc8,
-	0x15, 0x37, 0x25, 0x51, 0x12, 0x9f, 0xbe, 0x98, 0xd9, 0x34, 0x65, 0xdc, 0x8d, 0xed, 0x6a, 0x91,
-	0xc6, 0x69, 0x11, 0xa5, 0xf0, 0x16, 0x0b, 0x14, 0xd8, 0x76, 0xa1, 0x48, 0xb4, 0xe3, 0x56, 0x96,
-	0xb4, 0x43, 0x19, 0xdb, 0xf4, 0x42, 0xd0, 0xd4, 0x48, 0x22, 0x56, 0x22, 0xb5, 0xfc, 0xc8, 0x6e,
-	0xf6, 0xd0, 0x43, 0xd1, 0x5b, 0x2f, 0x3d, 0x15, 0x3d, 0xf5, 0xbe, 0xff, 0x40, 0xcf, 0x3d, 0xe6,
-	0xd6, 0xbd, 0x17, 0xd8, 0x16, 0xf1, 0x3f, 0x52, 0xcc, 0x1b, 0x52, 0x14, 0x65, 0x39, 0x85, 0x52,
-	0xf4, 0x62, 0x68, 0x7e, 0xef, 0xbd, 0x99, 0x37, 0xef, 0xe3, 0x37, 0x8f, 0x06, 0x6d, 0xe9, 0x7b,
-	0xa1, 0x17, 0x3c, 0x9d, 0x46, 0x96, 0x3f, 0x16, 0x7f, 0x5b, 0x08, 0x11, 0x19, 0x17, 0xfb, 0x3f,
-	0x9d, 0x3a, 0xe1, 0x2c, 0xba, 0x6a, 0xd9, 0xde, 0xe2, 0x69, 0xe8, 0x7b, 0xee, 0x93, 0x28, 0x78,
-	0x8a, 0x0a, 0x57, 0xd1, 0xe4, 0xe9, 0xd4, 0x9b, 0x7a, 0xb8, 0xc0, 0x5f, 0xc2, 0x70, 0xff, 0x70,
-	0xea, 0x79, 0xd3, 0x39, 0x4b, 0xb5, 0x42, 0x67, 0xc1, 0x82, 0xd0, 0x5a, 0x2c, 0x85, 0x42, 0xf3,
-	0x8f, 0x12, 0xe4, 0x7b, 0xde, 0x94, 0xe8, 0x50, 0xb1, 0x67, 0x96, 0x3b, 0x65, 0x26, 0xd7, 0xd0,
-	0xa4, 0x23, 0xe9, 0xb8, 0x72, 0xb2, 0xdf, 0x12, 0xe6, 0xad, 0xc4, 0xbc, 0x35, 0x4a, 0xcc, 0x9f,
-	0x95, 0x5f, 0x7f, 0x77, 0xb8, 0xf7, 0xa7, 0x7f, 0x1d, 0x4a, 0x14, 0x84, 0x21, 0x17, 0x91, 0x87,
-	0x50, 0xf7, 0x7c, 0x67, 0xea, 0xb8, 0x56, 0xe8, 0xf9, 0xe6, 0xd2, 0x19, 0x6b, 0xb9, 0x23, 0xe9,
-	0x58, 0xa1, 0xb5, 0x14, 0x1d, 0x3a, 0x63, 0x72, 0x0f, 0x8a, 0xc2, 0x48, 0xcb, 0xa3, 0x38, 0x5e,
-	0x35, 0xbf, 0x91, 0xa1, 0xda, 0xf1, 0xdc, 0xd0, 0xb7, 0xec, 0xf0, 0x82, 0x85, 0x16, 0x39, 0x84,
-	0x8a, 0x1d, 0xaf, 0x4d, 0x67, 0x8c, 0x6e, 0x29, 0x14, 0x12, 0xe8, 0x7c, 0x4c, 0x1e, 0x00, 0xf8,
-	0xcc, 0x0d, 0xd9, 0xfa, 0x61, 0x8a, 0x40, 0xf8, 0x41, 0xf7, 0xa1, 0x3c, 0xf3, 0x82, 0x10, 0x85,
-	0xe2, 0xa8, 0x12, 0x5f, 0x73, 0xd1, 0x03, 0x80, 0x60, 0x66, 0xf9, 0x63, 0x73, 0x66, 0x05, 0x33,
-	0xad, 0x20, 0x2c, 0x11, 0x79, 0x6e, 0x05, 0x33, 0x7e, 0xb2, 0x10, 0x3b, 0xee, 0x98, 0x7d, 0xa5,
-	0xc9, 0x47, 0xd2, 0xb1, 0x4c, 0x85, 0xc5, 0x39, 0x47, 0xc8, 0x8f, 0xa0, 0x21, 0x14, 0x26, 0xce,
-	0x9c, 0x99, 0x81, 0xf3, 0x35, 0xd3, 0x8a, 0x47, 0xd2, 0x71, 0x9e, 0xd6, 0x10, 0x3e, 0x75, 0xe6,
-	0xcc, 0x70, 0xbe, 0x66, 0xe4, 0x07, 0xa0, 0xa0, 0x06, 0x1e, 0x53, 0xc2, 0x63, 0xca, 0x1c, 0xc0,
-	0x53, 0x3a, 0xc2, 0x7d, 0x33, 0x08, 0x2d, 0x3f, 0xd4, 0xca, 0x3b, 0x44, 0x1d, 0x2f, 0x69, 0x70,
-	0x33, 0xf2, 0x09, 0x94, 0x71, 0x13, 0xe6, 0x8e, 0x35, 0x65, 0x87, 0x2d, 0x4a, 0xdc, 0x4a, 0x77,
-	0xc7, 0xdc, 0x45, 0x2c, 0x30, 0x0c, 0x13, 0x08, 0x17, 0x11, 0x88, 0xe3, 0xc4, 0x02, 0xdb, 0xf7,
-	0xbe, 0x44, 0x69, 0x45, 0xc4, 0x49, 0x20, 0x5c, 0x7c, 0x17, 0xe4, 0xa5, 0xef, 0xd8, 0x4c, 0xab,
-	0xe2, 0xe5, 0xc5, 0x82, 0x27, 0xd8, 0x5a, 0x78, 0x91, 0x1b, 0x6a, 0x35, 0x84, 0xe3, 0x15, 0xf9,
-	0x09, 0xdc, 0xb1, 0xbd, 0xf9, 0xdc, 0x0a, 0x99, 0x6f, 0xcd, 0xcd, 0x58, 0xa5, 0x8e, 0x2a, 0x6a,
-	0x2a, 0x68, 0x0b, 0x65, 0x1d, 0x1a, 0x4b, 0xeb, 0x95, 0x17, 0x85, 0x66, 0x60, 0xcf, 0xd8, 0x38,
-	0x9a, 0x33, 0xad, 0x71, 0x24, 0x1d, 0xd7, 0x4f, 0xde, 0x6f, 0x89, 0xe6, 0x58, 0x2f, 0x95, 0x96,
-	0x11, 0xeb, 0xd0, 0xba, 0x30, 0x4a, 0xd6, 0x3c, 0x93, 0x6e, 0xb4, 0x30, 0x05, 0x1a, 0x68, 0xaa,
-	0xc8, 0xa4, 0x1b, 0x2d, 0x86, 0x02, 0x69, 0xfe, 0x0c, 0xca, 0x2b, 0xe5, 0x0a, 0x94, 0x2e, 0x06,
-	0xfd, 0xd1, 0xf3, 0xde, 0x0b, 0x75, 0x8f, 0xd4, 0x40, 0xf9, 0xf4, 0xb2, 0x4d, 0x47, 0x3a, 0xed,
-	0xbd, 0x50, 0x25, 0x52, 0x85, 0x72, 0xbb, 0xdf, 0xbf, 0x6c, 0xf7, 0x7a, 0x2f, 0xd4, 0x5c, 0xf3,
-	0x6f, 0x32, 0x94, 0x13, 0x07, 0xc8, 0xcf, 0xa1, 0x9c, 0x14, 0x65, 0xdc, 0x3b, 0xef, 0x6d, 0xf1,
-	0x51, 0xc4, 0xfe, 0xdb, 0xef, 0x0e, 0x25, 0xba, 0x52, 0x27, 0x1f, 0x82, 0x1c, 0x84, 0x56, 0xc8,
-	0xb0, 0x78, 0xeb, 0x27, 0x0f, 0x36, 0xec, 0x56, 0x3f, 0x0c, 0xae, 0x44, 0x85, 0x2e, 0x79, 0x0c,
-	0x6a, 0x5c, 0xf6, 0x81, 0x33, 0x75, 0xad, 0x30, 0xf2, 0x45, 0x2b, 0x55, 0x69, 0x43, 0xe0, 0x46,
-	0x02, 0xf3, 0x96, 0xc4, 0x16, 0x48, 0x15, 0x0b, 0xa8, 0x58, 0xe3, 0x68, 0xaa, 0x46, 0x81, 0xc4,
-	0x69, 0xe6, 0x8a, 0x6c, 0x2c, 0x78, 0x40, 0xde, 0xa1, 0x9c, 0x54, 0x61, 0x6f, 0xa0, 0x39, 0xb2,
-	0xc1, 0x63, 0x50, 0xd7, 0xf6, 0x14, 0x87, 0x17, 0x85, 0x97, 0xa9, 0xae, 0x38, 0xfe, 0x31, 0xc4,
-	0x34, 0x62, 0xce, 0xbd, 0xa9, 0x56, 0x3a, 0xca, 0x1f, 0x57, 0x4e, 0x20, 0x0e, 0x45, 0xcf, 0x9b,
-	0x52, 0x45, 0x48, 0x39, 0x55, 0xf5, 0x41, 0x9d, 0x5b, 0x41, 0x68, 0x2e, 0xbc, 0xb1, 0x33, 0x79,
-	0x25, 0xfc, 0xdc, 0xa5, 0x73, 0xea, 0xdc, 0xfa, 0x02, 0x8d, 0xd1, 0xcb, 0x47, 0xd0, 0x10, 0xd5,
-	0x9f, 0x3a, 0xa9, 0xa0, 0x93, 0x75, 0x84, 0x53, 0x1f, 0x7f, 0x08, 0xd5, 0xa5, 0xcf, 0x96, 0x96,
-	0x1f, 0xb3, 0x8d, 0xe8, 0x94, 0x4a, 0x82, 0xf1, 0x6e, 0x78, 0x02, 0x64, 0xa5, 0x92, 0x6e, 0x57,
-	0xc1, 0xed, 0xee, 0x24, 0x92, 0xd5, 0x8e, 0xcd, 0x00, 0x6a, 0x99, 0xf4, 0x12, 0x05, 0xe4, 0x2e,
-	0x6d, 0x9f, 0x8e, 0xd4, 0x3d, 0x02, 0x50, 0x34, 0xce, 0xcf, 0xfa, 0x7a, 0x57, 0x54, 0xde, 0xe5,
-	0xb0, 0x37, 0x68, 0x77, 0xf5, 0xae, 0x9a, 0x23, 0x65, 0x28, 0xf4, 0x06, 0xc6, 0x48, 0xcd, 0x73,
-	0xbc, 0xd3, 0xee, 0x77, 0xf4, 0x9e, 0xde, 0x55, 0x0b, 0xdc, 0xa2, 0xd3, 0x1b, 0x18, 0x7a, 0x57,
-	0x95, 0x79, 0x1d, 0x53, 0xbd, 0xaf, 0x7f, 0xa6, 0x77, 0xd5, 0x22, 0x57, 0x1b, 0x3c, 0x33, 0x06,
-	0x3d, 0x7d, 0xa4, 0xab, 0xa5, 0xe6, 0x1f, 0x0a, 0x50, 0x43, 0x76, 0x0a, 0x3d, 0x9f, 0x21, 0xcb,
-	0x66, 0x49, 0x54, 0xda, 0x24, 0xd1, 0x0c, 0x83, 0xe5, 0x36, 0x18, 0x2c, 0x11, 0x22, 0x01, 0xe6,
-	0xb1, 0x93, 0x51, 0x88, 0xdc, 0x97, 0xa5, 0xb7, 0xc2, 0xff, 0x4e, 0x6f, 0xf2, 0xbb, 0xd0, 0xdb,
-	0x23, 0x68, 0xd8, 0x33, 0x66, 0x7f, 0x6e, 0x4e, 0x7c, 0xf6, 0x45, 0xc4, 0x5c, 0xfb, 0x15, 0x56,
-	0xa1, 0x4c, 0xeb, 0x08, 0x9f, 0x26, 0x68, 0xca, 0x83, 0x13, 0xc6, 0x90, 0xaa, 0xf3, 0x31, 0x0f,
-	0x9e, 0x32, 0xb6, 0xc6, 0x83, 0x5c, 0x5a, 0x46, 0x69, 0xcc, 0x83, 0x5c, 0xbc, 0x7a, 0x2f, 0x6c,
-	0xe4, 0x34, 0x65, 0xed, 0xbd, 0xe8, 0x20, 0x9b, 0x3d, 0x84, 0xfa, 0xc2, 0x71, 0x9d, 0x45, 0xb4,
-	0x30, 0x11, 0x0d, 0xb0, 0x7e, 0x64, 0x5a, 0x8b, 0x51, 0x03, 0x41, 0xce, 0x90, 0x3e, 0xb3, 0xbd,
-	0x97, 0xcc, 0x37, 0xc3, 0x99, 0xcf, 0x82, 0x99, 0x37, 0x17, 0xac, 0x2b, 0x53, 0x35, 0x16, 0x8c,
-	0x12, 0x7c, 0x83, 0x9b, 0xab, 0x9b, 0xdc, 0x9c, 0xe1, 0xf5, 0x5a, 0x96, 0xd7, 0x9b, 0x7f, 0x2d,
-	0x42, 0x63, 0x55, 0x06, 0xbc, 0xfa, 0xa2, 0x80, 0x9c, 0x42, 0x43, 0x24, 0x93, 0x63, 0xe6, 0x82,
-	0x85, 0x56, 0xcc, 0x66, 0x77, 0xe3, 0x56, 0xcc, 0xd4, 0xcd, 0x1a, 0x9d, 0xd5, 0x26, 0x99, 0x82,
-	0xfa, 0x28, 0xcb, 0x69, 0x47, 0x9b, 0xd6, 0xe2, 0xb8, 0x16, 0xd7, 0xcd, 0xd0, 0xda, 0x13, 0x50,
-	0x12, 0x5e, 0x0c, 0xb4, 0x3c, 0x92, 0x40, 0x63, 0x83, 0x0f, 0x69, 0xaa, 0xb1, 0x95, 0x05, 0x0b,
-	0xdb, 0x59, 0x90, 0x02, 0x11, 0xa1, 0xf0, 0x99, 0xcd, 0x9c, 0x97, 0xec, 0x1d, 0xe8, 0x0d, 0xed,
-	0xa9, 0x30, 0x8f, 0xe9, 0x6d, 0x9d, 0xb3, 0x8a, 0x6f, 0xe3, 0xac, 0x33, 0xa8, 0xda, 0x91, 0x8f,
-	0x65, 0x8c, 0x07, 0x97, 0x76, 0x38, 0xb8, 0x12, 0x5b, 0xde, 0x46, 0x56, 0xe5, 0xad, 0x64, 0xa5,
-	0x43, 0x95, 0x1b, 0x59, 0x73, 0x53, 0x64, 0x42, 0xc1, 0x4c, 0x34, 0x6f, 0xc9, 0x04, 0x45, 0x55,
-	0x91, 0x8b, 0x8a, 0x9f, 0x2e, 0xfe, 0x0f, 0x9c, 0x37, 0x01, 0x65, 0x95, 0xf7, 0x75, 0xbe, 0xab,
-	0x81, 0x22, 0x38, 0xee, 0xbc, 0x7f, 0xa6, 0x4a, 0x48, 0x60, 0x97, 0xfd, 0x3e, 0x5f, 0xe4, 0x88,
-	0x0a, 0xd5, 0x61, 0x9b, 0x8e, 0xce, 0xdb, 0x3d, 0x33, 0x66, 0xbe, 0x84, 0x03, 0x0b, 0xfc, 0x57,
-	0x77, 0xd0, 0xd7, 0x55, 0x39, 0xc3, 0x86, 0xc5, 0xe6, 0x27, 0x50, 0x59, 0xbb, 0x15, 0x29, 0x41,
-	0xbe, 0xaf, 0x7f, 0xa6, 0xee, 0x91, 0x06, 0x54, 0x92, 0xbd, 0x38, 0x80, 0x27, 0xe9, 0xbf, 0x19,
-	0x9e, 0x53, 0xe4, 0x56, 0x05, 0x64, 0xe4, 0x4d, 0x35, 0xdf, 0xfc, 0x46, 0x82, 0x3b, 0x9d, 0x99,
-	0x35, 0x9f, 0x33, 0x77, 0xca, 0x3e, 0x8d, 0x58, 0x10, 0x3a, 0x9e, 0xbb, 0x31, 0x36, 0x4a, 0x9b,
-	0x63, 0xe3, 0xfa, 0xc0, 0x99, 0xcb, 0x0e, 0x9c, 0x7c, 0x96, 0x9d, 0x45, 0xee, 0xe7, 0xf1, 0x44,
-	0x99, 0x17, 0x0c, 0x81, 0x90, 0x98, 0x28, 0xef, 0x82, 0xec, 0x7a, 0xae, 0xcd, 0xe2, 0x61, 0x54,
-	0x2c, 0xc8, 0x07, 0x50, 0x63, 0x5f, 0x2d, 0x99, 0x1d, 0x9a, 0x96, 0x1b, 0x7c, 0xc9, 0x7c, 0x2c,
-	0x5a, 0x85, 0x56, 0x05, 0xd8, 0x46, 0xac, 0xf9, 0xfb, 0x3c, 0xdc, 0x1f, 0xfa, 0x9e, 0x37, 0x19,
-	0x4c, 0x28, 0x5b, 0xce, 0x1d, 0xdb, 0x0a, 0xd9, 0xca, 0x77, 0xf2, 0x4b, 0x28, 0x7f, 0x11, 0xfb,
-	0x1f, 0xf7, 0xb3, 0x96, 0x74, 0xd5, 0xe6, 0xfd, 0xd6, 0x47, 0x94, 0xc4, 0x86, 0xfc, 0x1a, 0xea,
-	0x76, 0xa2, 0x28, 0xea, 0x37, 0xb7, 0x43, 0xfd, 0xd6, 0x56, 0xb6, 0x58, 0xc1, 0x19, 0x52, 0xca,
-	0x6f, 0x0c, 0x9b, 0x5b, 0xca, 0xbb, 0xb0, 0xb5, 0xbc, 0x0f, 0xa1, 0x82, 0x71, 0xce, 0xc4, 0x04,
-	0x38, 0x24, 0x22, 0x42, 0x7e, 0xb5, 0x36, 0xf6, 0x08, 0x9f, 0x8b, 0x3b, 0xf8, 0x5c, 0x4d, 0x86,
-	0xa3, 0xe4, 0xab, 0x66, 0x63, 0x84, 0x2a, 0x6d, 0x19, 0xa1, 0x9a, 0xbf, 0x83, 0x7b, 0xbc, 0xaf,
-	0x6e, 0xc4, 0x34, 0xc8, 0xbe, 0xa0, 0xd2, 0xc6, 0x0b, 0x7a, 0x96, 0x7c, 0x48, 0x24, 0xf1, 0x0e,
-	0xb4, 0x1c, 0x72, 0xc9, 0x41, 0x9c, 0x24, 0x7c, 0x19, 0x6e, 0xee, 0x4a, 0xeb, 0x68, 0xb6, 0x5a,
-	0x37, 0xff, 0x91, 0x83, 0xef, 0xdf, 0xa2, 0xfb, 0x76, 0x0f, 0xb2, 0x35, 0x9d, 0xdb, 0xac, 0xe9,
-	0x4d, 0x0e, 0xc8, 0xdf, 0xe4, 0x80, 0x87, 0x50, 0x4f, 0xbc, 0x8f, 0x1f, 0xc0, 0x82, 0x78, 0xdc,
-	0x12, 0x54, 0xbc, 0x81, 0x1f, 0x81, 0x92, 0x5e, 0x52, 0xc6, 0x4b, 0xde, 0x5a, 0x89, 0x34, 0x55,
-	0xe5, 0xf4, 0x19, 0x9f, 0xb6, 0x7b, 0x2a, 0x13, 0x3f, 0x31, 0x93, 0xdb, 0xb9, 0xaa, 0x74, 0x1b,
-	0x57, 0x5d, 0x4b, 0x70, 0xbf, 0x83, 0x33, 0xc2, 0xfa, 0xf3, 0x46, 0x19, 0x7a, 0xf6, 0x5f, 0x63,
-	0xfa, 0xb6, 0x0f, 0xd3, 0x0f, 0xa0, 0xe6, 0x8b, 0x6d, 0x32, 0x41, 0xad, 0xae, 0x40, 0xae, 0x74,
-	0x06, 0xc9, 0x5a, 0x5c, 0x7b, 0x97, 0x01, 0xaa, 0x12, 0x5b, 0xe2, 0xb5, 0xdf, 0x07, 0x25, 0xbd,
-	0xad, 0x8c, 0xb7, 0x4d, 0x81, 0xe6, 0x9f, 0x25, 0x28, 0x52, 0x16, 0x44, 0xf3, 0x90, 0x3c, 0x82,
-	0x82, 0xed, 0x8d, 0xc5, 0xf7, 0x7f, 0x7d, 0xf5, 0x0d, 0x43, 0x59, 0xb0, 0xf4, 0xdc, 0x80, 0x75,
-	0xbc, 0x31, 0xa3, 0xa8, 0x40, 0x34, 0x28, 0x2d, 0x58, 0x10, 0x58, 0x53, 0x96, 0xd0, 0x5c, 0xbc,
-	0x24, 0xe7, 0xfc, 0x66, 0x42, 0x5f, 0x78, 0x9d, 0xdf, 0xa5, 0xef, 0x12, 0x53, 0x2e, 0xfc, 0xb1,
-	0x0d, 0xd5, 0xf5, 0xa3, 0x39, 0x53, 0x1b, 0x97, 0x9d, 0x8e, 0x6e, 0x18, 0xea, 0x1e, 0xd9, 0x87,
-	0x7b, 0x7c, 0x3e, 0x6e, 0x8f, 0x2e, 0xa9, 0x6e, 0x9e, 0x0e, 0xe8, 0x45, 0x7b, 0x64, 0xea, 0x94,
-	0x0e, 0xa8, 0x2a, 0x91, 0xfb, 0xf0, 0xbd, 0xce, 0xe0, 0x62, 0x78, 0x39, 0xd2, 0xcd, 0x76, 0xb7,
-	0x4b, 0x75, 0xc3, 0x88, 0x45, 0x39, 0x4e, 0xff, 0x83, 0xd1, 0x73, 0x9d, 0xc6, 0xc0, 0xdd, 0x93,
-	0x7f, 0x4a, 0x50, 0x3d, 0x43, 0x72, 0x61, 0xfe, 0x4b, 0xfe, 0xed, 0xfa, 0x31, 0xbc, 0x67, 0x44,
-	0x57, 0x0b, 0x27, 0xcc, 0x0e, 0xc9, 0xf7, 0xb6, 0x3f, 0x9d, 0xfb, 0xb5, 0x34, 0x48, 0x3c, 0x82,
-	0xbf, 0x80, 0x9a, 0xc1, 0xdc, 0xb4, 0x2b, 0xc9, 0x83, 0x35, 0xbb, 0x9b, 0x8d, 0xb9, 0x69, 0xde,
-	0x07, 0x72, 0xb3, 0xe0, 0xc8, 0xd1, 0xaa, 0x49, 0x6e, 0xa9, 0xc5, 0xfd, 0x5b, 0xbc, 0x7b, 0xf6,
-	0xf1, 0xeb, 0x37, 0x07, 0xd2, 0xb7, 0x6f, 0x0e, 0xa4, 0x7f, 0xbf, 0x39, 0x90, 0xfe, 0x72, 0x7d,
-	0x20, 0xfd, 0xfd, 0xfa, 0x40, 0x7a, 0x7d, 0x7d, 0x20, 0x41, 0xcd, 0xf1, 0x5a, 0x57, 0xe1, 0x24,
-	0x10, 0x86, 0xcf, 0x00, 0x63, 0x30, 0xe4, 0xc9, 0x19, 0x4a, 0xbf, 0x15, 0xff, 0x70, 0xba, 0x2a,
-	0x62, 0xb2, 0x3e, 0xfc, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9, 0x27, 0xa3, 0x99, 0x9a, 0x12,
-	0x00, 0x00,
+	// 1962 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0xdb, 0xc8,
+	0x15, 0x0f, 0x25, 0x51, 0x1f, 0x4f, 0x5f, 0xcc, 0xc4, 0x9b, 0x30, 0xde, 0xf5, 0x47, 0xb5, 0x48,
+	0xe3, 0xb4, 0x88, 0xb3, 0xf0, 0x16, 0x01, 0x8a, 0x6e, 0xbb, 0x50, 0x24, 0xda, 0x71, 0x2b, 0x4b,
+	0xde, 0xa1, 0x8c, 0x34, 0xbd, 0x10, 0x34, 0x35, 0x92, 0x88, 0x48, 0xa4, 0x96, 0x1f, 0xc9, 0x66,
+	0x81, 0xf6, 0xd0, 0x6b, 0x81, 0xa2, 0xa7, 0xa2, 0xa7, 0xde, 0xf7, 0x1f, 0xe8, 0xb9, 0xc7, 0xdc,
+	0xba, 0xf7, 0x02, 0xdb, 0x22, 0xf9, 0x47, 0x8a, 0x79, 0x43, 0x8a, 0x22, 0x2d, 0xa7, 0xd0, 0xb6,
+	0x17, 0xc3, 0xf3, 0xde, 0xfb, 0xbd, 0x79, 0x33, 0xef, 0xe3, 0xc7, 0x11, 0xa8, 0x0b, 0xcf, 0x0d,
+	0x5c, 0xff, 0xd1, 0x24, 0x34, 0xbd, 0x91, 0xf8, 0x7b, 0x88, 0x22, 0x22, 0xe3, 0x62, 0xfb, 0x93,
+	0x89, 0x1d, 0x4c, 0xc3, 0xcb, 0x43, 0xcb, 0x9d, 0x3f, 0x0a, 0x3c, 0xd7, 0x79, 0x18, 0xfa, 0x8f,
+	0xd0, 0xe0, 0x32, 0x1c, 0x3f, 0x9a, 0xb8, 0x13, 0x17, 0x17, 0xf8, 0x9f, 0x00, 0x6e, 0xef, 0x4d,
+	0x5c, 0x77, 0x32, 0x63, 0x89, 0x55, 0x60, 0xcf, 0x99, 0x1f, 0x98, 0xf3, 0x85, 0x30, 0x68, 0xfd,
+	0x41, 0x82, 0x7c, 0xcf, 0x9d, 0x10, 0x0d, 0xaa, 0xd6, 0xd4, 0x74, 0x26, 0xcc, 0xe0, 0x16, 0xaa,
+	0xb4, 0x2f, 0x1d, 0x54, 0x8f, 0xb6, 0x0f, 0x05, 0xfc, 0x30, 0x86, 0x1f, 0x0e, 0x63, 0xf8, 0x93,
+	0xf2, 0x9b, 0xef, 0xf6, 0x6e, 0xfc, 0xe9, 0x5f, 0x7b, 0x12, 0x05, 0x01, 0xe4, 0x2a, 0x72, 0x0f,
+	0x1a, 0xae, 0x67, 0x4f, 0x6c, 0xc7, 0x0c, 0x5c, 0xcf, 0x58, 0xd8, 0x23, 0x35, 0xb7, 0x2f, 0x1d,
+	0x54, 0x68, 0x3d, 0x91, 0x9e, 0xdb, 0x23, 0x72, 0x1b, 0x8a, 0x02, 0xa4, 0xe6, 0x51, 0x1d, 0xad,
+	0x5a, 0xdf, 0xc8, 0x50, 0xeb, 0xb8, 0x4e, 0xe0, 0x99, 0x56, 0x70, 0xc6, 0x02, 0x93, 0xec, 0x41,
+	0xd5, 0x8a, 0xd6, 0x86, 0x3d, 0xc2, 0xb0, 0x2a, 0x14, 0x62, 0xd1, 0xe9, 0x88, 0xec, 0x00, 0x78,
+	0xcc, 0x09, 0xd8, 0xea, 0x66, 0x15, 0x21, 0xe1, 0x1b, 0xdd, 0x85, 0xf2, 0xd4, 0xf5, 0x03, 0x54,
+	0x8a, 0xad, 0x4a, 0x7c, 0xcd, 0x55, 0x3b, 0x00, 0xfe, 0xd4, 0xf4, 0x46, 0xc6, 0xd4, 0xf4, 0xa7,
+	0x6a, 0x41, 0x20, 0x51, 0xf2, 0xd4, 0xf4, 0xa7, 0x7c, 0x67, 0xa1, 0xb6, 0x9d, 0x11, 0xfb, 0x4a,
+	0x95, 0xf7, 0xa5, 0x03, 0x99, 0x0a, 0xc4, 0x29, 0x97, 0x90, 0x1f, 0x42, 0x53, 0x18, 0x8c, 0xed,
+	0x19, 0x33, 0x7c, 0xfb, 0x6b, 0xa6, 0x16, 0xf7, 0xa5, 0x83, 0x3c, 0xad, 0xa3, 0xf8, 0xd8, 0x9e,
+	0x31, 0xdd, 0xfe, 0x9a, 0x91, 0x0f, 0xa1, 0x82, 0x16, 0xb8, 0x4d, 0x09, 0xb7, 0x29, 0x73, 0x01,
+	0xee, 0xd2, 0x11, 0xe1, 0x1b, 0x7e, 0x60, 0x7a, 0x81, 0x5a, 0xde, 0xe0, 0xd6, 0xf1, 0x90, 0x3a,
+	0x87, 0x91, 0xcf, 0xa1, 0x8c, 0x4e, 0x98, 0x33, 0x52, 0x2b, 0x1b, 0xb8, 0x28, 0x71, 0x94, 0xe6,
+	0x8c, 0x78, 0x88, 0x58, 0x60, 0x78, 0x4d, 0x20, 0x42, 0x44, 0x41, 0x74, 0x4f, 0xcc, 0xb7, 0x3c,
+	0xf7, 0x15, 0x6a, 0xab, 0xe2, 0x9e, 0x84, 0x84, 0xab, 0xb7, 0x40, 0x5e, 0x78, 0xb6, 0xc5, 0xd4,
+	0x1a, 0x1e, 0x5e, 0x2c, 0x78, 0x82, 0xcd, 0xb9, 0x1b, 0x3a, 0x81, 0x5a, 0x47, 0x71, 0xb4, 0x22,
+	0x3f, 0x86, 0x9b, 0x96, 0x3b, 0x9b, 0x99, 0x01, 0xf3, 0xcc, 0x99, 0x11, 0x99, 0x34, 0xd0, 0x44,
+	0x49, 0x14, 0x6d, 0x61, 0xac, 0x41, 0x73, 0x61, 0xbe, 0x76, 0xc3, 0xc0, 0xf0, 0xad, 0x29, 0x1b,
+	0x85, 0x33, 0xa6, 0x36, 0xf7, 0xa5, 0x83, 0xc6, 0xd1, 0x47, 0x87, 0xa2, 0x39, 0x56, 0x4b, 0xe5,
+	0x50, 0x8f, 0x6c, 0x68, 0x43, 0x80, 0xe2, 0x35, 0xcf, 0xa4, 0x13, 0xce, 0x0d, 0x21, 0xf5, 0x55,
+	0x45, 0x64, 0xd2, 0x09, 0xe7, 0xe7, 0x42, 0xd2, 0xfa, 0x09, 0x94, 0x97, 0xc6, 0x55, 0x28, 0x9d,
+	0x0d, 0xfa, 0xc3, 0xa7, 0xbd, 0xe7, 0xca, 0x0d, 0x52, 0x87, 0xca, 0x17, 0x17, 0x6d, 0x3a, 0xd4,
+	0x68, 0xef, 0xb9, 0x22, 0x91, 0x1a, 0x94, 0xdb, 0xfd, 0xfe, 0x45, 0xbb, 0xd7, 0x7b, 0xae, 0xe4,
+	0x5a, 0x7f, 0x2c, 0x43, 0x39, 0x0e, 0x80, 0xfc, 0x14, 0xca, 0x71, 0x51, 0x46, 0xbd, 0x73, 0x6b,
+	0x4d, 0x8c, 0xe2, 0xee, 0xbf, 0xfd, 0x6e, 0x4f, 0xa2, 0x4b, 0x73, 0xf2, 0x29, 0xc8, 0x7e, 0x60,
+	0x06, 0x0c, 0x8b, 0xb7, 0x71, 0xb4, 0x93, 0xc1, 0x2d, 0xff, 0xd1, 0xb9, 0x11, 0x15, 0xb6, 0xe4,
+	0x01, 0x28, 0x51, 0xd9, 0xfb, 0xf6, 0xc4, 0x31, 0x83, 0xd0, 0x13, 0xad, 0x54, 0xa3, 0x4d, 0x21,
+	0xd7, 0x63, 0x31, 0x6f, 0x49, 0x6c, 0x81, 0xc4, 0xb0, 0x80, 0x86, 0x75, 0x2e, 0x4d, 0xcc, 0x28,
+	0x90, 0x28, 0xcd, 0xdc, 0x90, 0x8d, 0xc4, 0x1c, 0x90, 0x37, 0x28, 0x27, 0x45, 0xe0, 0x75, 0x84,
+	0xe3, 0x34, 0x78, 0x00, 0xca, 0x8a, 0x4f, 0xb1, 0x79, 0x51, 0x44, 0x99, 0xd8, 0x8a, 0xed, 0x1f,
+	0x40, 0x34, 0x46, 0x8c, 0x99, 0x3b, 0x51, 0x4b, 0xfb, 0xf9, 0x83, 0xea, 0x11, 0x44, 0x57, 0xd1,
+	0x73, 0x27, 0xb4, 0x22, 0xb4, 0x7c, 0x54, 0xf5, 0x41, 0x99, 0x99, 0x7e, 0x60, 0xcc, 0xdd, 0x91,
+	0x3d, 0x7e, 0x2d, 0xe2, 0xdc, 0xa4, 0x73, 0x1a, 0x1c, 0x7d, 0x86, 0x60, 0x8c, 0xf2, 0x3e, 0x34,
+	0x45, 0xf5, 0x27, 0x41, 0x56, 0x30, 0xc8, 0x06, 0x8a, 0x93, 0x18, 0x7f, 0x00, 0xb5, 0x85, 0xc7,
+	0x16, 0xa6, 0x17, 0x4d, 0x1b, 0xd1, 0x29, 0xd5, 0x58, 0xc6, 0xbb, 0xe1, 0x21, 0x90, 0xa5, 0x49,
+	0xe2, 0xae, 0x8a, 0xee, 0x6e, 0xc6, 0x9a, 0xc4, 0xa3, 0x05, 0x1f, 0xe2, 0x51, 0xfc, 0xd0, 0xb2,
+	0x98, 0xef, 0x1b, 0xd6, 0xd4, 0x9c, 0xcd, 0xd8, 0x72, 0x0a, 0xd7, 0x36, 0x38, 0x95, 0xca, 0x1d,
+	0xe9, 0xc2, 0x4f, 0x27, 0x76, 0x83, 0xe7, 0x1b, 0xc2, 0x2d, 0xdc, 0x24, 0xe3, 0xbc, 0xbe, 0x81,
+	0xf3, 0x9b, 0xdc, 0x41, 0xda, 0xeb, 0x7d, 0x68, 0xa6, 0x1d, 0xfa, 0xd8, 0xc7, 0x32, 0x6d, 0x58,
+	0xab, 0x76, 0x3e, 0xf9, 0x04, 0xb6, 0x12, 0xc3, 0x57, 0xa6, 0xe7, 0x44, 0xd6, 0x4d, 0xb4, 0x26,
+	0x4b, 0xdd, 0x33, 0xd3, 0x73, 0x04, 0xe2, 0x31, 0xdc, 0x49, 0x10, 0xf1, 0xd5, 0x08, 0x90, 0x68,
+	0xde, 0x0f, 0x96, 0xea, 0xe8, 0xc0, 0x88, 0x6b, 0xfd, 0x16, 0xea, 0xa9, 0x66, 0x21, 0x15, 0x90,
+	0xbb, 0xb4, 0x7d, 0x3c, 0x54, 0x6e, 0x10, 0x80, 0xa2, 0x7e, 0x7a, 0xd2, 0xd7, 0xba, 0xa2, 0x8f,
+	0x2f, 0xce, 0x7b, 0x83, 0x76, 0x57, 0xeb, 0x2a, 0x39, 0x52, 0x86, 0x42, 0x6f, 0xa0, 0x0f, 0x95,
+	0x3c, 0x97, 0x77, 0xda, 0xfd, 0x8e, 0xd6, 0xd3, 0xba, 0x4a, 0x81, 0x23, 0x3a, 0xbd, 0x81, 0xae,
+	0x75, 0x15, 0x99, 0x4f, 0x05, 0xaa, 0xf5, 0xb5, 0x67, 0x5a, 0x57, 0x29, 0x72, 0xb3, 0xc1, 0x13,
+	0x7d, 0xd0, 0xd3, 0x86, 0x9a, 0x52, 0xe2, 0xf0, 0x67, 0x6d, 0xda, 0x57, 0xca, 0xad, 0xbf, 0xc9,
+	0x50, 0xc7, 0xa9, 0x1f, 0xb8, 0x1e, 0x43, 0xf6, 0x4a, 0x93, 0x93, 0x94, 0x25, 0xa7, 0x14, 0x33,
+	0xe4, 0x32, 0xcc, 0x10, 0x2b, 0x91, 0x58, 0xf2, 0x38, 0x21, 0x51, 0x89, 0x9c, 0x92, 0xa6, 0x8d,
+	0xc2, 0xff, 0x4e, 0x1b, 0xf2, 0xf7, 0xa1, 0x0d, 0x2c, 0x01, 0x66, 0xbd, 0x30, 0xc6, 0x1e, 0xfb,
+	0x32, 0x64, 0x8e, 0xf5, 0x1a, 0xbb, 0x1b, 0x4b, 0x80, 0x59, 0x2f, 0x8e, 0x63, 0x69, 0xc2, 0x2f,
+	0x63, 0xc6, 0x90, 0x02, 0xf3, 0x11, 0xbf, 0x1c, 0x33, 0xb6, 0xc2, 0x2f, 0x5c, 0x5b, 0x46, 0x6d,
+	0xc4, 0x2f, 0x5c, 0xbd, 0xe4, 0x61, 0x0b, 0xb9, 0xa2, 0xb2, 0xc2, 0xc3, 0x1d, 0x64, 0x89, 0x7b,
+	0xd0, 0x98, 0xdb, 0x8e, 0x3d, 0x0f, 0xe7, 0x06, 0x4a, 0x7d, 0xec, 0x4b, 0x99, 0xd6, 0x23, 0xa9,
+	0x8e, 0x42, 0xce, 0x3c, 0x1e, 0xb3, 0xdc, 0x97, 0xcc, 0x33, 0x82, 0xa9, 0xc7, 0xfc, 0xa9, 0x3b,
+	0x13, 0x6c, 0x26, 0x53, 0x25, 0x52, 0x0c, 0x63, 0x79, 0x86, 0xf3, 0x6a, 0x59, 0xce, 0x4b, 0xf1,
+	0x65, 0x3d, 0xc3, 0x97, 0x3f, 0x83, 0x6d, 0xac, 0xf2, 0x4c, 0x77, 0x18, 0x33, 0x7b, 0x6e, 0x07,
+	0x51, 0x8f, 0xdc, 0xe1, 0x16, 0xa9, 0x7e, 0xf2, 0x7b, 0x5c, 0x4d, 0xda, 0xb0, 0xb3, 0x7e, 0x16,
+	0xc4, 0x78, 0xd1, 0x35, 0xdb, 0xfe, 0x9a, 0x46, 0x8f, 0x5c, 0x60, 0xbf, 0xa5, 0xb2, 0x82, 0x5d,
+	0x17, 0xb5, 0x0e, 0x49, 0xa7, 0x86, 0x37, 0x5d, 0xeb, 0xaf, 0x45, 0x68, 0x2e, 0x0b, 0x97, 0x77,
+	0x4e, 0xe8, 0x93, 0x63, 0x68, 0x8a, 0xf2, 0xe3, 0x32, 0x63, 0xce, 0x02, 0x33, 0xe2, 0xb5, 0xad,
+	0x68, 0x28, 0xa7, 0x2a, 0x7d, 0x85, 0xd8, 0xea, 0xe3, 0x54, 0x0b, 0x3c, 0x4e, 0xb3, 0xdb, 0x7e,
+	0x16, 0x2d, 0xb6, 0x3b, 0xe4, 0xb6, 0x29, 0x82, 0x7b, 0x08, 0x95, 0x98, 0x21, 0x7d, 0x35, 0x8f,
+	0x74, 0xd0, 0xcc, 0x30, 0x23, 0x4d, 0x2c, 0xd6, 0xf2, 0x61, 0x61, 0x3d, 0x1f, 0x52, 0x20, 0x22,
+	0x79, 0x1e, 0xb3, 0x98, 0xfd, 0x92, 0x7d, 0x0f, 0xa2, 0x43, 0x3c, 0x15, 0xf0, 0x88, 0xe8, 0x56,
+	0xd9, 0xab, 0xf8, 0x3e, 0xf6, 0x3a, 0x81, 0x9a, 0x15, 0x7a, 0xd8, 0x78, 0xb8, 0x71, 0x69, 0x83,
+	0x8d, 0xab, 0x11, 0xf2, 0x3a, 0xda, 0x2a, 0xaf, 0xa5, 0x2d, 0x0d, 0x6a, 0x1c, 0x64, 0xce, 0x0c,
+	0x91, 0x89, 0x0a, 0x66, 0xa2, 0x75, 0x4d, 0x26, 0x28, 0x9a, 0x8a, 0x5c, 0x54, 0xbd, 0x64, 0xf1,
+	0xff, 0x67, 0xbf, 0xd6, 0x18, 0x2a, 0xcb, 0xbc, 0xaf, 0xce, 0xea, 0x3a, 0x54, 0xc4, 0x7c, 0x3e,
+	0xed, 0x9f, 0x28, 0x12, 0x0e, 0xdf, 0x8b, 0x7e, 0x9f, 0x2f, 0x72, 0x44, 0x81, 0xda, 0x79, 0x9b,
+	0x0e, 0x4f, 0xdb, 0x3d, 0x23, 0x9a, 0xda, 0xf1, 0xfc, 0x2e, 0xf0, 0xff, 0xba, 0x83, 0xbe, 0xa6,
+	0xc8, 0xa9, 0x49, 0x5e, 0x6c, 0x7d, 0x0e, 0xd5, 0x95, 0x53, 0x91, 0x12, 0xe4, 0xfb, 0xda, 0x33,
+	0xe5, 0x06, 0x69, 0x42, 0x35, 0xf6, 0xc5, 0x05, 0xb8, 0x93, 0xf6, 0xeb, 0xf3, 0x53, 0x8a, 0xbc,
+	0x50, 0x01, 0x19, 0x67, 0xbe, 0x92, 0x6f, 0x7d, 0x23, 0xc1, 0xcd, 0x65, 0xab, 0x7d, 0x11, 0x32,
+	0x3f, 0xb0, 0x5d, 0x27, 0xf3, 0x80, 0x90, 0xb2, 0x0f, 0x88, 0xd5, 0xa7, 0x47, 0x2e, 0xfd, 0xf4,
+	0xe0, 0xaf, 0x9a, 0x69, 0xe8, 0xbc, 0x88, 0xde, 0x16, 0x79, 0x31, 0xd3, 0x50, 0x24, 0xde, 0x16,
+	0x5b, 0x20, 0x3b, 0xae, 0x63, 0xb1, 0xe8, 0x59, 0x22, 0x16, 0xe4, 0x63, 0xa8, 0xb3, 0xaf, 0x16,
+	0xcc, 0x0a, 0x0c, 0xd3, 0xf1, 0x5f, 0x31, 0x0f, 0x8b, 0xb6, 0x42, 0x6b, 0x42, 0xd8, 0x46, 0x59,
+	0xeb, 0xf7, 0x79, 0xb8, 0x7b, 0xee, 0xb9, 0xee, 0x78, 0x30, 0xa6, 0x6c, 0x31, 0xb3, 0x2d, 0x33,
+	0x60, 0xcb, 0xd8, 0xc9, 0x2f, 0xa0, 0xfc, 0x65, 0x14, 0x7f, 0xd4, 0xcf, 0x6a, 0xdc, 0x55, 0xd9,
+	0xf3, 0xad, 0x7e, 0xac, 0xc6, 0x18, 0xf2, 0x2b, 0x68, 0x64, 0x3e, 0x23, 0x72, 0x1b, 0xd4, 0x6f,
+	0x3d, 0xf5, 0x69, 0x90, 0x1e, 0xa3, 0xf9, 0xcc, 0x18, 0x5d, 0x53, 0xde, 0x85, 0xb5, 0xe5, 0xbd,
+	0x07, 0x55, 0xbc, 0xe7, 0xd4, 0x9d, 0x00, 0x17, 0x89, 0x1b, 0x21, 0xbf, 0x5c, 0xf9, 0x00, 0x16,
+	0x31, 0x17, 0x37, 0x88, 0xb9, 0x16, 0x7f, 0x26, 0xc7, 0xef, 0xdb, 0xcc, 0xc7, 0x74, 0x69, 0xcd,
+	0xc7, 0x74, 0xeb, 0x77, 0x70, 0x9b, 0xf7, 0xd5, 0x95, 0x3b, 0xf5, 0xd3, 0x9c, 0x2f, 0x65, 0x38,
+	0xff, 0x24, 0x7e, 0x52, 0xc6, 0xf7, 0xed, 0xab, 0x39, 0x9c, 0x25, 0xbb, 0x51, 0x92, 0x90, 0xcb,
+	0xae, 0x7a, 0xa5, 0x0d, 0x84, 0x2d, 0xd7, 0xad, 0x7f, 0xe4, 0xe0, 0xce, 0x35, 0xb6, 0xef, 0x8f,
+	0x20, 0x5d, 0xd3, 0xb9, 0x6c, 0x4d, 0x67, 0x67, 0x40, 0xfe, 0xea, 0x0c, 0xb8, 0x07, 0x8d, 0x38,
+	0xfa, 0x88, 0xb2, 0x0b, 0x82, 0x8e, 0x63, 0xa9, 0x60, 0xed, 0xc7, 0x50, 0x49, 0x0e, 0x29, 0xe3,
+	0x21, 0xaf, 0xad, 0x44, 0x9a, 0x98, 0xf2, 0xf1, 0x19, 0xed, 0xb6, 0x79, 0x2a, 0xe3, 0x38, 0x31,
+	0x93, 0xeb, 0x67, 0x55, 0xe9, 0xba, 0x59, 0xf5, 0x4e, 0x82, 0xbb, 0x1d, 0xa4, 0xce, 0x55, 0x7a,
+	0xa3, 0x0c, 0x23, 0xfb, 0xaf, 0x77, 0xfa, 0xbe, 0x9f, 0x28, 0x3e, 0x86, 0xba, 0x27, 0xdc, 0xa4,
+	0x2e, 0xb5, 0xb6, 0x14, 0x72, 0xa3, 0x13, 0x88, 0xd7, 0xe2, 0xd8, 0x9b, 0x7c, 0xf2, 0x55, 0x23,
+	0x24, 0x1e, 0xfb, 0x23, 0xa8, 0x24, 0xa7, 0x95, 0xf1, 0xb4, 0x89, 0xa0, 0xf5, 0x67, 0x09, 0x8a,
+	0x94, 0xf9, 0xe1, 0x2c, 0x20, 0xf7, 0xa1, 0x60, 0xb9, 0x23, 0xf1, 0x4b, 0x50, 0x63, 0xf9, 0x9a,
+	0xa5, 0xcc, 0x5f, 0xb8, 0x8e, 0xcf, 0x3a, 0xee, 0x88, 0x51, 0x34, 0x20, 0x2a, 0x94, 0xe6, 0xcc,
+	0xf7, 0xcd, 0x09, 0x8b, 0xc7, 0x5c, 0xb4, 0x24, 0xa7, 0xfc, 0x64, 0xc2, 0x5e, 0x44, 0x9d, 0xdf,
+	0xa4, 0xef, 0x62, 0x28, 0x57, 0xfe, 0xc8, 0x82, 0xda, 0xea, 0xd6, 0x7c, 0x52, 0xeb, 0x17, 0x9d,
+	0x8e, 0xa6, 0xeb, 0xca, 0x0d, 0xb2, 0x0d, 0xb7, 0xf9, 0xb7, 0x7d, 0x7b, 0x78, 0x41, 0x35, 0xe3,
+	0x78, 0x40, 0xcf, 0xda, 0x43, 0x43, 0xa3, 0x74, 0x40, 0x15, 0x89, 0xdc, 0x85, 0x0f, 0x3a, 0x83,
+	0xb3, 0xf3, 0x8b, 0xa1, 0x66, 0xb4, 0xbb, 0x5d, 0xaa, 0xe9, 0x7a, 0xa4, 0xca, 0xf1, 0xf1, 0x3f,
+	0x18, 0x3e, 0xd5, 0x68, 0x24, 0xd8, 0x3a, 0xfa, 0xa7, 0x04, 0xb5, 0x13, 0x1c, 0x2e, 0xcc, 0x7b,
+	0x69, 0x5b, 0x8c, 0x7c, 0x06, 0xb7, 0xf4, 0xf0, 0x72, 0x6e, 0x07, 0xe9, 0xcf, 0xfa, 0xdb, 0xeb,
+	0xa9, 0x73, 0xbb, 0x9e, 0x5c, 0x12, 0xbf, 0xc1, 0x9f, 0x43, 0x5d, 0x67, 0x4e, 0xd2, 0x95, 0x64,
+	0x67, 0x05, 0x77, 0xb5, 0x31, 0xb3, 0xf0, 0x3e, 0x90, 0xab, 0x05, 0x47, 0xf6, 0x97, 0x4d, 0x72,
+	0x4d, 0x2d, 0x6e, 0x5f, 0x13, 0xdd, 0x93, 0xcf, 0xde, 0xbc, 0xdd, 0x95, 0xbe, 0x7d, 0xbb, 0x2b,
+	0xfd, 0xfb, 0xed, 0xae, 0xf4, 0x97, 0x77, 0xbb, 0xd2, 0xdf, 0xdf, 0xed, 0x4a, 0x6f, 0xde, 0xed,
+	0x4a, 0x50, 0xb7, 0xdd, 0xc3, 0xcb, 0x60, 0xec, 0x0b, 0xe0, 0x13, 0xc0, 0x3b, 0x38, 0xe7, 0xc9,
+	0x39, 0x97, 0x7e, 0x23, 0x7e, 0x7a, 0xbc, 0x2c, 0x62, 0xb2, 0x3e, 0xfd, 0x4f, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0x72, 0x90, 0xd9, 0x02, 0xa4, 0x14, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1840,6 +1916,39 @@ func (m *Contract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.ChallengeSuccessTimes != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.ChallengeSuccessTimes))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x80
+	}
+	if m.ChallengeWarnTimes != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.ChallengeWarnTimes))
+		i--
+		dAtA[i] = 0x78
+	}
+	if m.ChallengeTimes != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.ChallengeTimes))
+		i--
+		dAtA[i] = 0x70
+	}
+	n4, err4 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastChallengeTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastChallengeTime):])
+	if err4 != nil {
+		return 0, err4
+	}
+	i -= n4
+	i = encodeVarintGuard(dAtA, i, uint64(n4))
+	i--
+	dAtA[i] = 0x6a
+	n5, err5 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastSuccessChallengeTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastSuccessChallengeTime):])
+	if err5 != nil {
+		return 0, err5
+	}
+	i -= n5
+	i = encodeVarintGuard(dAtA, i, uint64(n5))
+	i--
+	dAtA[i] = 0x62
 	if len(m.PreparerSignature) > 0 {
 		i -= len(m.PreparerSignature)
 		copy(dAtA[i:], m.PreparerSignature)
@@ -1861,12 +1970,12 @@ func (m *Contract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x4a
 	}
-	n4, err4 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastModifyTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastModifyTime):])
-	if err4 != nil {
-		return 0, err4
+	n6, err6 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.LastModifyTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastModifyTime):])
+	if err6 != nil {
+		return 0, err6
 	}
-	i -= n4
-	i = encodeVarintGuard(dAtA, i, uint64(n4))
+	i -= n6
+	i = encodeVarintGuard(dAtA, i, uint64(n6))
 	i--
 	dAtA[i] = 0x42
 	if len(m.ChangeLog) > 0 {
@@ -1890,12 +1999,12 @@ func (m *Contract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x32
 	}
-	n5, err5 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
-	if err5 != nil {
-		return 0, err5
+	n7, err7 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
+	if err7 != nil {
+		return 0, err7
 	}
-	i -= n5
-	i = encodeVarintGuard(dAtA, i, uint64(n5))
+	i -= n7
+	i = encodeVarintGuard(dAtA, i, uint64(n7))
 	i--
 	dAtA[i] = 0x2a
 	if len(m.HostSignature) > 0 {
@@ -1954,6 +2063,23 @@ func (m *FileStoreMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.CheckFrequencyWarn != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.CheckFrequencyWarn))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x80
+	}
+	if m.SuccessChallengeTimesLimit != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.SuccessChallengeTimesLimit))
+		i--
+		dAtA[i] = 0x78
+	}
+	if m.WarnChallengeTimesLimit != 0 {
+		i = encodeVarintGuard(dAtA, i, uint64(m.WarnChallengeTimesLimit))
+		i--
+		dAtA[i] = 0x70
+	}
 	if len(m.GuardPid) > 0 {
 		i -= len(m.GuardPid)
 		copy(dAtA[i:], m.GuardPid)
@@ -1998,20 +2124,20 @@ func (m *FileStoreMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x30
 	}
-	n7, err7 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RentEnd, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RentEnd):])
-	if err7 != nil {
-		return 0, err7
+	n9, err9 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RentEnd, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RentEnd):])
+	if err9 != nil {
+		return 0, err9
 	}
-	i -= n7
-	i = encodeVarintGuard(dAtA, i, uint64(n7))
+	i -= n9
+	i = encodeVarintGuard(dAtA, i, uint64(n9))
 	i--
 	dAtA[i] = 0x2a
-	n8, err8 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RentStart, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RentStart):])
-	if err8 != nil {
-		return 0, err8
+	n10, err10 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RentStart, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RentStart):])
+	if err10 != nil {
+		return 0, err10
 	}
-	i -= n8
-	i = encodeVarintGuard(dAtA, i, uint64(n8))
+	i -= n10
+	i = encodeVarintGuard(dAtA, i, uint64(n10))
 	i--
 	dAtA[i] = 0x22
 	if m.FileSize != 0 {
@@ -2086,12 +2212,12 @@ func (m *FileStoreStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x42
 	}
-	n9, err9 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.CurrentTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.CurrentTime):])
-	if err9 != nil {
-		return 0, err9
+	n11, err11 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.CurrentTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.CurrentTime):])
+	if err11 != nil {
+		return 0, err11
 	}
-	i -= n9
-	i = encodeVarintGuard(dAtA, i, uint64(n9))
+	i -= n11
+	i = encodeVarintGuard(dAtA, i, uint64(n11))
 	i--
 	dAtA[i] = 0x3a
 	if len(m.ChangeLog) > 0 {
@@ -2108,12 +2234,12 @@ func (m *FileStoreStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x32
 		}
 	}
-	n10, err10 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.GuardReceiveTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.GuardReceiveTime):])
-	if err10 != nil {
-		return 0, err10
+	n12, err12 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.GuardReceiveTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.GuardReceiveTime):])
+	if err12 != nil {
+		return 0, err12
 	}
-	i -= n10
-	i = encodeVarintGuard(dAtA, i, uint64(n10))
+	i -= n12
+	i = encodeVarintGuard(dAtA, i, uint64(n12))
 	i--
 	dAtA[i] = 0x2a
 	if len(m.RenterSignature) > 0 {
@@ -2246,12 +2372,12 @@ func (m *ProofOfReplicateChallenge) MarshalToSizedBuffer(dAtA []byte) (int, erro
 		i--
 		dAtA[i] = 0x3a
 	}
-	n12, err12 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.HostSignTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.HostSignTime):])
-	if err12 != nil {
-		return 0, err12
+	n14, err14 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.HostSignTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.HostSignTime):])
+	if err14 != nil {
+		return 0, err14
 	}
-	i -= n12
-	i = encodeVarintGuard(dAtA, i, uint64(n12))
+	i -= n14
+	i = encodeVarintGuard(dAtA, i, uint64(n14))
 	i--
 	dAtA[i] = 0x32
 	if len(m.HostAnswer) > 0 {
@@ -2275,12 +2401,12 @@ func (m *ProofOfReplicateChallenge) MarshalToSizedBuffer(dAtA []byte) (int, erro
 		i--
 		dAtA[i] = 0x1a
 	}
-	n13, err13 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ChallengeTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ChallengeTime):])
-	if err13 != nil {
-		return 0, err13
+	n15, err15 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ChallengeTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ChallengeTime):])
+	if err15 != nil {
+		return 0, err15
 	}
-	i -= n13
-	i = encodeVarintGuard(dAtA, i, uint64(n13))
+	i -= n15
+	i = encodeVarintGuard(dAtA, i, uint64(n15))
 	i--
 	dAtA[i] = 0x12
 	{
@@ -2375,12 +2501,12 @@ func (m *ShardChallengeQuestions) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i--
 		dAtA[i] = 0x3a
 	}
-	n15, err15 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.PrepareTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.PrepareTime):])
-	if err15 != nil {
-		return 0, err15
+	n17, err17 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.PrepareTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.PrepareTime):])
+	if err17 != nil {
+		return 0, err17
 	}
-	i -= n15
-	i = encodeVarintGuard(dAtA, i, uint64(n15))
+	i -= n17
+	i = encodeVarintGuard(dAtA, i, uint64(n17))
 	i--
 	dAtA[i] = 0x32
 	if len(m.Questions) > 0 {
@@ -2457,12 +2583,12 @@ func (m *CheckFileStoreMetaRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 		i--
 		dAtA[i] = 0x2a
 	}
-	n16, err16 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RequestTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RequestTime):])
-	if err16 != nil {
-		return 0, err16
+	n18, err18 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.RequestTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.RequestTime):])
+	if err18 != nil {
+		return 0, err18
 	}
-	i -= n16
-	i = encodeVarintGuard(dAtA, i, uint64(n16))
+	i -= n18
+	i = encodeVarintGuard(dAtA, i, uint64(n18))
 	i--
 	dAtA[i] = 0x22
 	if len(m.RequesterPid) > 0 {
@@ -2513,12 +2639,12 @@ func (m *Result) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	n17, err17 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
-	if err17 != nil {
-		return 0, err17
+	n19, err19 := github_com_tron_us_protobuf_types.StdTimeMarshalTo(m.ResponseTime, dAtA[i-github_com_tron_us_protobuf_types.SizeOfStdTime(m.ResponseTime):])
+	if err19 != nil {
+		return 0, err19
 	}
-	i -= n17
-	i = encodeVarintGuard(dAtA, i, uint64(n17))
+	i -= n19
+	i = encodeVarintGuard(dAtA, i, uint64(n19))
 	i--
 	dAtA[i] = 0x1a
 	if len(m.Message) > 0 {
@@ -2679,6 +2805,19 @@ func (m *Contract) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovGuard(uint64(l))
 	}
+	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastSuccessChallengeTime)
+	n += 1 + l + sovGuard(uint64(l))
+	l = github_com_tron_us_protobuf_types.SizeOfStdTime(m.LastChallengeTime)
+	n += 1 + l + sovGuard(uint64(l))
+	if m.ChallengeTimes != 0 {
+		n += 1 + sovGuard(uint64(m.ChallengeTimes))
+	}
+	if m.ChallengeWarnTimes != 0 {
+		n += 1 + sovGuard(uint64(m.ChallengeWarnTimes))
+	}
+	if m.ChallengeSuccessTimes != 0 {
+		n += 2 + sovGuard(uint64(m.ChallengeSuccessTimes))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -2732,6 +2871,15 @@ func (m *FileStoreMeta) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovGuard(uint64(l))
 	}
+	if m.WarnChallengeTimesLimit != 0 {
+		n += 1 + sovGuard(uint64(m.WarnChallengeTimesLimit))
+	}
+	if m.SuccessChallengeTimesLimit != 0 {
+		n += 1 + sovGuard(uint64(m.SuccessChallengeTimesLimit))
+	}
+	if m.CheckFrequencyWarn != 0 {
+		n += 2 + sovGuard(uint64(m.CheckFrequencyWarn))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -3984,6 +4132,129 @@ func (m *Contract) Unmarshal(dAtA []byte) error {
 				m.PreparerSignature = []byte{}
 			}
 			iNdEx = postIndex
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastSuccessChallengeTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGuard
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGuard
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastSuccessChallengeTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastChallengeTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGuard
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGuard
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_tron_us_protobuf_types.StdTimeUnmarshal(&m.LastChallengeTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 14:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChallengeTimes", wireType)
+			}
+			m.ChallengeTimes = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ChallengeTimes |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChallengeWarnTimes", wireType)
+			}
+			m.ChallengeWarnTimes = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ChallengeWarnTimes |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChallengeSuccessTimes", wireType)
+			}
+			m.ChallengeSuccessTimes = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ChallengeSuccessTimes |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGuard(dAtA[iNdEx:])
@@ -4365,6 +4636,63 @@ func (m *FileStoreMeta) Unmarshal(dAtA []byte) error {
 			}
 			m.GuardPid = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 14:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WarnChallengeTimesLimit", wireType)
+			}
+			m.WarnChallengeTimesLimit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WarnChallengeTimesLimit |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SuccessChallengeTimesLimit", wireType)
+			}
+			m.SuccessChallengeTimesLimit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SuccessChallengeTimesLimit |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CheckFrequencyWarn", wireType)
+			}
+			m.CheckFrequencyWarn = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGuard
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CheckFrequencyWarn |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGuard(dAtA[iNdEx:])
diff --git a/protos/guard/guard.proto b/protos/guard/guard.proto
index 8f61a8b..3570ab9 100644
--- a/protos/guard/guard.proto
+++ b/protos/guard/guard.proto
@@ -86,6 +86,7 @@ message Contract {
     CLOSED = 5; // the all work in such contract was done
     RENEWED = 6; // the contract got renewed
     OBSOLETE = 7; //the contract was replaced with some other contract after it was canceled or renewed
+    WARN = 8; //the shard is in warn status
   }
   ContractState state = 2;
   bytes renter_signature = 3; //renter’s signature for the sub contract
@@ -103,6 +104,17 @@ message Contract {
   bytes guard_signature = 9;
   string preparer_pid = 10; //while the contract got renewed, some stakeholder take renter's place to prepare such contract
   bytes preparer_signature = 11;
+  google.protobuf.Timestamp last_success_challenge_time = 12 [
+    (gogoproto.nullable) = false,
+    (gogoproto.stdtime) = true
+  ];
+  google.protobuf.Timestamp last_challenge_time = 13 [
+    (gogoproto.nullable) = false,
+    (gogoproto.stdtime) = true
+  ];
+  int32 challenge_times = 14; //total challenge times till now
+  int32 challenge_warn_times = 15; //record times of timeout response after last success challenge time
+  int32 challenge_success_times = 16; //record times of success after the contract was put into the warn status
 }
 
 message FileStoreMeta {
@@ -118,7 +130,7 @@ message FileStoreMeta {
     (gogoproto.nullable) = false,
     (gogoproto.stdtime) = true
   ]; //rent end time
-  int32 check_frequency = 6; // shard check frequency in a year,  1 means check once per year, 0 means check 12 per year(1 per month)
+  int32 check_frequency = 6; //reserve: shard check frequency in days, 1 means check once per day
   int64 guard_fee = 7; // reserve: the fee which guard will charge for supporting
   int64 escrow_fee = 8; //reserve: the fee which escrow will charge for supporting
   int32 shard_count = 9; //shard's count, by default is 30
@@ -126,6 +138,9 @@ message FileStoreMeta {
   int32 recover_threshold = 11; //reserved field, indicate the threshold for starting to recover
   string escrow_pid = 12;
   string guard_pid = 13;
+  int32 warn_challenge_times_limit = 14; //reserve: indicate how many times warn challenge will take the contract to cancel status, renter cannot set it now, use 7 as default
+  int32 success_challenge_times_limit = 15; //reserve: indicate how many times success will take the contract from warn status back to right, renter cannot set it now, use 1 as default
+  int32 check_frequency_warn = 16; //reserve: check frequency in days while in warn status, renter cannot set it now, use 1 as default
 }
 
 message FileStoreStatus {