PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:harmony-one/harmony into rj_fork

Browse Source
pull/1096/head
Rongjian Lan 6 years ago
parent 379ab1efb3 174fe06605
commit dd67389671
9 changed files with 234 additions and 166 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 133
      api/proto/message/message.pb.go
  2. 5
      api/proto/message/message.proto
  3. 2
      consensus/config.go
  4. 4
      consensus/consensus.go
  5. 5
      consensus/consensus_leader_msg.go
  6. 6
      consensus/consensus_service.go
  7. 237
      consensus/consensus_v2.go
  8. 4
      consensus/pbft_log.go
  9. 4
      consensus/view_change.go

133
api/proto/message/message.pb.go
Unescape View File

@ -525,8 +525,9 @@ type ConsensusRequest struct {
BlockNum uint64 `protobuf:"varint,2,opt,name=block_num,json=blockNum,proto3" json:"block_num,omitempty"` BlockNum uint64 `protobuf:"varint,2,opt,name=block_num,json=blockNum,proto3" json:"block_num,omitempty"`
ShardId uint32 `protobuf:"varint,3,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"` ShardId uint32 `protobuf:"varint,3,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
BlockHash []byte `protobuf:"bytes,4,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` BlockHash []byte `protobuf:"bytes,4,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
SenderPubkey []byte `protobuf:"bytes,5,opt,name=sender_pubkey,json=senderPubkey,proto3" json:"sender_pubkey,omitempty"` Block []byte `protobuf:"bytes,5,opt,name=block,proto3" json:"block,omitempty"`
Payload []byte `protobuf:"bytes,6,opt,name=payload,proto3" json:"payload,omitempty"` SenderPubkey []byte `protobuf:"bytes,6,opt,name=sender_pubkey,json=senderPubkey,proto3" json:"sender_pubkey,omitempty"`
Payload []byte `protobuf:"bytes,7,opt,name=payload,proto3" json:"payload,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -585,6 +586,13 @@ func (m *ConsensusRequest) GetBlockHash() []byte {
return nil return nil
} }
func (m *ConsensusRequest) GetBlock() []byte {
if m != nil {
return m.Block
}
return nil
}
func (m *ConsensusRequest) GetSenderPubkey() []byte { func (m *ConsensusRequest) GetSenderPubkey() []byte {
if m != nil { if m != nil {
return m.SenderPubkey return m.SenderPubkey
@ -808,66 +816,67 @@ func init() {
func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) } func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) }
var fileDescriptor_33c57e4bae7b9afd = []byte{ var fileDescriptor_33c57e4bae7b9afd = []byte{
// 934 bytes of a gzipped FileDescriptorProto // 948 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x95, 0xdf, 0x6e, 0xe2, 0x46, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xdd, 0x6e, 0xe2, 0x46,
0x14, 0xc6, 0x31, 0x10, 0x0c, 0xc7, 0x86, 0xcc, 0x4e, 0xdb, 0x5d, 0x6f, 0xba, 0x55, 0x23, 0x56, 0x14, 0xc6, 0x40, 0x30, 0x1c, 0x1b, 0x32, 0x3b, 0xdd, 0xee, 0x7a, 0xd3, 0xad, 0x1a, 0xb1, 0xaa,
0x95, 0xa2, 0x95, 0x1a, 0xad, 0xe0, 0xa2, 0xaa, 0xd4, 0x1b, 0x02, 0xa3, 0xc4, 0x4a, 0x62, 0xe8, 0x14, 0xad, 0xd4, 0x68, 0x05, 0x17, 0x55, 0xa5, 0xde, 0x10, 0x18, 0x25, 0x56, 0x12, 0x43, 0x07,
0xe0, 0x6c, 0xd4, 0x2b, 0x6b, 0x82, 0x47, 0xc4, 0x0a, 0xd8, 0xd4, 0x63, 0xb2, 0xe2, 0x05, 0xda, 0x67, 0xa3, 0x5e, 0x59, 0x13, 0x3c, 0x22, 0x56, 0xc0, 0xa6, 0x1e, 0x93, 0x15, 0x2f, 0xd0, 0x3e,
0x87, 0xe9, 0x7d, 0xaf, 0xbb, 0x6f, 0x56, 0xcd, 0x8c, 0xc1, 0xfc, 0xd9, 0xaa, 0x37, 0x55, 0xef, 0x4c, 0xef, 0x7b, 0xdd, 0x3e, 0x45, 0x5f, 0xa7, 0x9a, 0x19, 0x83, 0xf9, 0xd9, 0xde, 0x55, 0xbd,
0x38, 0xdf, 0x39, 0xbf, 0x99, 0x73, 0x3e, 0xcf, 0x0c, 0xd0, 0x9c, 0x73, 0x21, 0xd8, 0x94, 0x9f, 0xe3, 0xfb, 0xce, 0xf9, 0xce, 0x9c, 0xf3, 0x79, 0xce, 0x08, 0x68, 0xce, 0xb9, 0x10, 0x6c, 0xca,
0x2f, 0xd2, 0x24, 0x4b, 0xb0, 0x99, 0x87, 0xed, 0x3f, 0x2b, 0x60, 0xde, 0xea, 0xdf, 0xf8, 0x07, 0xcf, 0x17, 0x69, 0x92, 0x25, 0xd8, 0xcc, 0x61, 0xfb, 0x8f, 0x0a, 0x98, 0xb7, 0xfa, 0x37, 0xfe,
0xb0, 0x05, 0x4f, 0x9f, 0xa3, 0x09, 0x0f, 0xb2, 0xd5, 0x82, 0x3b, 0xc6, 0xa9, 0x71, 0xd6, 0xea, 0x1e, 0x6c, 0xc1, 0xd3, 0xe7, 0x68, 0xc2, 0x83, 0x6c, 0xb5, 0xe0, 0x8e, 0x71, 0x6a, 0x9c, 0xb5,
0x7c, 0x79, 0xbe, 0x46, 0xc7, 0x3a, 0xe9, 0xaf, 0x16, 0x9c, 0x5a, 0xa2, 0x08, 0xf0, 0x19, 0x54, 0x3a, 0x2f, 0xcf, 0xd7, 0xd2, 0xb1, 0x0e, 0xfa, 0xab, 0x05, 0xa7, 0x96, 0x28, 0x00, 0x3e, 0x83,
0x15, 0x50, 0xde, 0x03, 0xf2, 0x85, 0x15, 0xa0, 0x2a, 0xf0, 0x1b, 0x68, 0x88, 0x68, 0x1a, 0xb3, 0xaa, 0x12, 0x94, 0xf7, 0x04, 0x79, 0x61, 0x25, 0x50, 0x19, 0xf8, 0x2d, 0x34, 0x44, 0x34, 0x8d,
0x6c, 0x99, 0x72, 0xa7, 0x72, 0x6a, 0x9c, 0xd9, 0xb4, 0x10, 0x70, 0x17, 0x4c, 0x91, 0xb1, 0xa7, 0x59, 0xb6, 0x4c, 0xb9, 0x53, 0x39, 0x35, 0xce, 0x6c, 0x5a, 0x10, 0xb8, 0x0b, 0xa6, 0xc8, 0xd8,
0x28, 0x9e, 0x3a, 0xd5, 0x53, 0xe3, 0xcc, 0xea, 0xbc, 0x2a, 0xf6, 0xd6, 0x3a, 0xe5, 0xbf, 0x2e, 0x53, 0x14, 0x4f, 0x9d, 0xea, 0xa9, 0x71, 0x66, 0x75, 0x5e, 0x17, 0x67, 0x6b, 0x9e, 0xf2, 0x5f,
0xb9, 0xc8, 0xae, 0x4a, 0x74, 0x5d, 0x89, 0x7f, 0x84, 0xc6, 0x24, 0x89, 0x05, 0x8f, 0xc5, 0x52, 0x96, 0x5c, 0x64, 0x57, 0x25, 0xba, 0xce, 0xc4, 0x3f, 0x40, 0x63, 0x92, 0xc4, 0x82, 0xc7, 0x62,
0x38, 0x47, 0x0a, 0x7b, 0xbd, 0xc1, 0xfa, 0xeb, 0x4c, 0x01, 0x16, 0xd5, 0xf8, 0x7b, 0x38, 0x0a, 0x29, 0x9c, 0x23, 0x25, 0x7b, 0xb3, 0x91, 0xf5, 0xd7, 0x91, 0x42, 0x58, 0x64, 0xe3, 0xef, 0xe0,
0x53, 0x16, 0x87, 0x4e, 0x4d, 0x61, 0x5f, 0x6d, 0xb0, 0x81, 0x54, 0x0b, 0x44, 0x57, 0xe1, 0x9f, 0x28, 0x4c, 0x59, 0x1c, 0x3a, 0x35, 0x25, 0xfb, 0x72, 0x23, 0x1b, 0x48, 0xb6, 0x90, 0xe8, 0x2c,
0x00, 0x9e, 0x23, 0xfe, 0x71, 0xf2, 0xc8, 0xe2, 0x29, 0x77, 0x4c, 0xc5, 0x9c, 0x6c, 0x98, 0x0f, 0xfc, 0x23, 0xc0, 0x73, 0xc4, 0x3f, 0x4d, 0x1e, 0x59, 0x3c, 0xe5, 0x8e, 0xa9, 0x34, 0x27, 0x1b,
0x11, 0xff, 0xd8, 0x57, 0xa9, 0x02, 0xdc, 0xaa, 0xc7, 0x17, 0x70, 0x3c, 0x4b, 0xb2, 0x8c, 0xa7, 0xcd, 0xc7, 0x88, 0x7f, 0xea, 0xab, 0x50, 0x21, 0xdc, 0xca, 0xc7, 0x17, 0x70, 0x3c, 0x4b, 0xb2,
0xab, 0x20, 0xd5, 0x05, 0x4e, 0x7d, 0x6f, 0xc8, 0x1b, 0x9d, 0x2f, 0xf8, 0xd6, 0x6c, 0x47, 0xb9, 0x8c, 0xa7, 0xab, 0x20, 0xd5, 0x09, 0x4e, 0x7d, 0x6f, 0xc8, 0x1b, 0x1d, 0x2f, 0xf4, 0xad, 0xd9,
0x68, 0x80, 0x99, 0xb3, 0xed, 0xbf, 0x0c, 0xa8, 0x53, 0x2e, 0x16, 0x72, 0x98, 0xff, 0xe3, 0xcb, 0x0e, 0x73, 0xd1, 0x00, 0x33, 0xd7, 0xb6, 0xff, 0x34, 0xa0, 0x4e, 0xb9, 0x58, 0xc8, 0x61, 0xfe,
0x11, 0x40, 0x45, 0xfb, 0x7a, 0x5b, 0xf5, 0x01, 0xad, 0x8e, 0x73, 0xd8, 0xbf, 0xce, 0x5f, 0x95, 0x8f, 0x2f, 0x47, 0x00, 0x15, 0xed, 0xeb, 0x63, 0xd5, 0x07, 0xb4, 0x3a, 0xce, 0x61, 0xff, 0x3a,
0xe8, 0xf1, 0x6c, 0x57, 0xba, 0x00, 0xa8, 0xaf, 0xf1, 0xf6, 0x25, 0x1c, 0xef, 0x11, 0xd8, 0x01, 0x7e, 0x55, 0xa2, 0xc7, 0xb3, 0x5d, 0xea, 0x02, 0xa0, 0xbe, 0x96, 0xb7, 0x2f, 0xe1, 0x78, 0x4f,
0x73, 0x31, 0x63, 0x2b, 0x9e, 0x0a, 0xa7, 0x7c, 0x5a, 0x39, 0x6b, 0xd0, 0x75, 0x88, 0x4f, 0xa0, 0x81, 0x1d, 0x30, 0x17, 0x33, 0xb6, 0xe2, 0xa9, 0x70, 0xca, 0xa7, 0x95, 0xb3, 0x06, 0x5d, 0x43,
0xfe, 0xc0, 0x66, 0x2c, 0x9e, 0x70, 0xe1, 0x54, 0x54, 0x6a, 0x13, 0xb7, 0xff, 0x30, 0xa0, 0xb5, 0x7c, 0x02, 0xf5, 0x07, 0x36, 0x63, 0xf1, 0x84, 0x0b, 0xa7, 0xa2, 0x42, 0x1b, 0xdc, 0xfe, 0xdd,
0xeb, 0x1d, 0x7e, 0x9f, 0x0f, 0xa6, 0x9d, 0x78, 0xf3, 0x0f, 0x16, 0x9f, 0x6f, 0x0d, 0xf8, 0x2d, 0x80, 0xd6, 0xae, 0x77, 0xf8, 0x43, 0x3e, 0x98, 0x76, 0xe2, 0xed, 0xbf, 0x58, 0x7c, 0xbe, 0x35,
0x58, 0x8b, 0x34, 0x7a, 0x66, 0x19, 0x0f, 0x9e, 0xf8, 0x4a, 0x39, 0xd2, 0xa0, 0x90, 0x4b, 0xd7, 0xe0, 0x37, 0x60, 0x2d, 0xd2, 0xe8, 0x99, 0x65, 0x3c, 0x78, 0xe2, 0x2b, 0xe5, 0x48, 0x83, 0x42,
0x7c, 0x85, 0x5f, 0x42, 0x8d, 0xcd, 0x93, 0x65, 0x9c, 0xa9, 0xb9, 0x2b, 0x34, 0x8f, 0xda, 0xe7, 0x4e, 0x5d, 0xf3, 0x15, 0x7e, 0x05, 0x35, 0x36, 0x4f, 0x96, 0x71, 0xa6, 0xe6, 0xae, 0xd0, 0x1c,
0x50, 0x55, 0x5e, 0x36, 0xe0, 0x88, 0x78, 0x3e, 0xa1, 0xa8, 0x84, 0x01, 0x6a, 0x94, 0x8c, 0xef, 0xb5, 0xcf, 0xa1, 0xaa, 0xbc, 0x6c, 0xc0, 0x11, 0xf1, 0x7c, 0x42, 0x51, 0x09, 0x03, 0xd4, 0x28,
0x6e, 0x7c, 0x64, 0xe0, 0x63, 0xb0, 0x46, 0x6e, 0xff, 0x3a, 0xb8, 0x77, 0x3d, 0x8f, 0x50, 0x54, 0x19, 0xdf, 0xdd, 0xf8, 0xc8, 0xc0, 0xc7, 0x60, 0x8d, 0xdc, 0xfe, 0x75, 0x70, 0xef, 0x7a, 0x1e,
0x6e, 0x5f, 0x43, 0x6b, 0xf7, 0x34, 0xe3, 0x53, 0xb0, 0xb2, 0x94, 0xc5, 0x82, 0x4d, 0xb2, 0x28, 0xa1, 0xa8, 0xdc, 0xbe, 0x86, 0xd6, 0xee, 0x6d, 0xc6, 0xa7, 0x60, 0x65, 0x29, 0x8b, 0x05, 0x9b,
0x89, 0x55, 0xcf, 0x36, 0xdd, 0x96, 0xf0, 0x2b, 0x30, 0xe3, 0x24, 0xe4, 0x41, 0x14, 0xe6, 0x8d, 0x64, 0x51, 0x12, 0xab, 0x9e, 0x6d, 0xba, 0x4d, 0xe1, 0xd7, 0x60, 0xc6, 0x49, 0xc8, 0x83, 0x28,
0xd5, 0x64, 0xe8, 0x86, 0xed, 0x4f, 0x06, 0xa0, 0xfd, 0x43, 0x2e, 0xab, 0xe5, 0xc1, 0x93, 0xd5, 0xcc, 0x1b, 0xab, 0x49, 0xe8, 0x86, 0xed, 0xbf, 0x0d, 0x40, 0xfb, 0x97, 0x5c, 0x66, 0xcb, 0x8b,
0x72, 0xad, 0x26, 0xad, 0xc9, 0xd0, 0x0d, 0xf1, 0xd7, 0xd0, 0x78, 0x98, 0x25, 0x93, 0xa7, 0x20, 0x27, 0xb3, 0x65, 0xad, 0x26, 0xad, 0x49, 0xe8, 0x86, 0xf8, 0x2b, 0x68, 0x3c, 0xcc, 0x92, 0xc9,
0x5e, 0xce, 0xd5, 0x42, 0x55, 0x5a, 0x57, 0x82, 0xb7, 0x9c, 0xe3, 0xd7, 0x50, 0x17, 0x8f, 0x2c, 0x53, 0x10, 0x2f, 0xe7, 0xaa, 0x50, 0x95, 0xd6, 0x15, 0xe1, 0x2d, 0xe7, 0xf8, 0x0d, 0xd4, 0xc5,
0x0d, 0x25, 0x56, 0x51, 0x98, 0xa9, 0x62, 0x37, 0xc4, 0xdf, 0x00, 0x68, 0xee, 0x91, 0x89, 0x47, 0x23, 0x4b, 0x43, 0x29, 0xab, 0x28, 0x99, 0xa9, 0xb0, 0x1b, 0xe2, 0xaf, 0x01, 0xb4, 0xee, 0x91,
0x75, 0x37, 0x6d, 0xaa, 0x57, 0xba, 0x62, 0xe2, 0x11, 0xbf, 0x85, 0xa6, 0xe0, 0x71, 0xc8, 0xd3, 0x89, 0x47, 0xb5, 0x9b, 0x36, 0xd5, 0x95, 0xae, 0x98, 0x78, 0xc4, 0x2f, 0xe1, 0x48, 0x01, 0xb5,
0x60, 0xb1, 0x7c, 0x90, 0xe6, 0x1d, 0xa9, 0x0a, 0x5b, 0x8b, 0x23, 0xa5, 0xa9, 0x4f, 0xcb, 0x56, 0x7e, 0x36, 0xd5, 0x00, 0xbf, 0x83, 0xa6, 0xe0, 0x71, 0xc8, 0xd3, 0x60, 0xb1, 0x7c, 0x90, 0x96,
0xb3, 0x84, 0xe9, 0xeb, 0x66, 0xd3, 0x75, 0xd8, 0xfe, 0xdd, 0x00, 0x7b, 0xfb, 0xc6, 0xed, 0x74, 0xd6, 0x54, 0xd4, 0xd6, 0xe4, 0x48, 0x71, 0xea, 0x83, 0xb3, 0xd5, 0x2c, 0x61, 0xa1, 0x5a, 0x28,
0x62, 0xec, 0x76, 0x72, 0xb0, 0x55, 0xf9, 0x33, 0x5b, 0xed, 0xb6, 0x5b, 0xd9, 0x6f, 0x77, 0xab, 0x9b, 0xae, 0x61, 0xfb, 0x37, 0x03, 0xec, 0xed, 0x3d, 0xdc, 0xe9, 0xcf, 0xd8, 0xed, 0xef, 0xe0,
0x93, 0xea, 0x6e, 0x27, 0xbf, 0x55, 0xe0, 0xc5, 0xc1, 0x3d, 0xfe, 0xef, 0xed, 0x3c, 0x18, 0xa2, 0xa8, 0xf2, 0x67, 0x8e, 0xda, 0x1d, 0xa2, 0xb2, 0x3f, 0xc4, 0x56, 0x27, 0xd5, 0xdd, 0x4e, 0x7e,
0xfa, 0x99, 0x21, 0xde, 0x42, 0x73, 0xc6, 0xd9, 0xa1, 0xa9, 0x5a, 0xfc, 0x37, 0x53, 0xf1, 0x77, 0xad, 0xc0, 0x8b, 0x83, 0xed, 0xfe, 0xef, 0x4d, 0x3e, 0x18, 0xa2, 0xfa, 0x99, 0x21, 0xde, 0x41,
0xd0, 0x2a, 0x1e, 0x9f, 0x40, 0x44, 0x53, 0xf5, 0x60, 0xd9, 0xb4, 0x59, 0xa8, 0xe3, 0x68, 0x2a, 0x73, 0xc6, 0xd9, 0x56, 0x92, 0xb6, 0xdc, 0xd6, 0xe4, 0xa1, 0xa9, 0xb5, 0x9d, 0x51, 0xf0, 0xb7,
0xad, 0x92, 0x42, 0x14, 0xaa, 0x92, 0xba, 0xb6, 0x4a, 0x2b, 0x79, 0x7a, 0xde, 0x09, 0xd8, 0x74, 0xd0, 0x2a, 0x9e, 0xa4, 0x40, 0x44, 0xd3, 0xdc, 0xf5, 0x66, 0xc1, 0x8e, 0xa3, 0xa9, 0xb4, 0x4a,
0x2a, 0xa2, 0xa9, 0x70, 0x1a, 0x3a, 0x3d, 0xef, 0xf4, 0xb4, 0x20, 0x0d, 0x98, 0x77, 0x82, 0x87, 0x12, 0x51, 0xa8, 0x52, 0xea, 0xda, 0x2a, 0xcd, 0xe4, 0xe1, 0x79, 0x27, 0x60, 0xd3, 0xa9, 0x88,
0x28, 0x9b, 0xb3, 0x85, 0x03, 0x2a, 0x5b, 0x9f, 0x77, 0x2e, 0x54, 0xac, 0xd8, 0xee, 0x86, 0xb5, 0xa6, 0xc2, 0x69, 0xe8, 0xf0, 0xbc, 0xd3, 0xd3, 0x84, 0x34, 0x60, 0xde, 0x09, 0x1e, 0xa2, 0x6c,
0x72, 0xb6, 0xbb, 0xcd, 0x76, 0xd7, 0xac, 0x9d, 0xb3, 0x5d, 0xcd, 0xbe, 0xbb, 0x02, 0x6b, 0xeb, 0xce, 0x16, 0x0e, 0xa8, 0x68, 0x7d, 0xde, 0xb9, 0x50, 0x58, 0x69, 0xbb, 0x1b, 0xad, 0x95, 0x6b,
0xcd, 0xc2, 0x4d, 0x68, 0xf4, 0x87, 0xde, 0x98, 0x78, 0xe3, 0xbb, 0x31, 0x2a, 0x61, 0x0b, 0xcc, 0xbb, 0xdb, 0xda, 0xee, 0x5a, 0x6b, 0xe7, 0xda, 0xae, 0xd6, 0xbe, 0xbf, 0x02, 0x6b, 0xeb, 0x25,
0xb1, 0xdf, 0xbb, 0x76, 0xbd, 0x4b, 0x64, 0xc8, 0x6b, 0x37, 0xa0, 0x3d, 0x6f, 0x80, 0xca, 0x18, 0xc3, 0x4d, 0x68, 0xf4, 0x87, 0xde, 0x98, 0x78, 0xe3, 0xbb, 0x31, 0x2a, 0x61, 0x0b, 0xcc, 0xb1,
0x43, 0xab, 0x7f, 0xe3, 0x12, 0xcf, 0x0f, 0xc6, 0x77, 0xa3, 0xd1, 0x90, 0xfa, 0xa8, 0xf2, 0xee, 0xdf, 0xbb, 0x76, 0xbd, 0x4b, 0x64, 0xc8, 0x65, 0x1c, 0xd0, 0x9e, 0x37, 0x40, 0x65, 0x8c, 0xa1,
0x93, 0x01, 0xd6, 0xd6, 0x6b, 0x86, 0x4f, 0xe0, 0xa5, 0x47, 0xee, 0xbd, 0xe1, 0x80, 0x04, 0x17, 0xd5, 0xbf, 0x71, 0x89, 0xe7, 0x07, 0xe3, 0xbb, 0xd1, 0x68, 0x48, 0x7d, 0x54, 0x79, 0xff, 0x97,
0xa4, 0xd7, 0x1f, 0x7a, 0xc1, 0x7a, 0xa9, 0x12, 0xb6, 0xa1, 0xde, 0xf3, 0xbc, 0xe1, 0x9d, 0xd7, 0x01, 0xd6, 0xd6, 0x1b, 0x87, 0x4f, 0xe0, 0x95, 0x47, 0xee, 0xbd, 0xe1, 0x80, 0x04, 0x17, 0xa4,
0x27, 0xc8, 0x90, 0xbb, 0x8c, 0x28, 0x19, 0xf5, 0x28, 0x41, 0x65, 0x99, 0xca, 0x83, 0x01, 0xaa, 0xd7, 0x1f, 0x7a, 0xc1, 0xba, 0x54, 0x09, 0xdb, 0x50, 0xef, 0x79, 0xde, 0xf0, 0xce, 0xeb, 0x13,
0xc8, 0xfb, 0xdd, 0x1f, 0xde, 0xde, 0xba, 0x3e, 0xaa, 0xea, 0xde, 0xe4, 0x6f, 0x9f, 0x0c, 0xd0, 0x64, 0xc8, 0x53, 0x46, 0x94, 0x8c, 0x7a, 0x94, 0xa0, 0xb2, 0x0c, 0xe5, 0x60, 0x80, 0x2a, 0x72,
0x11, 0x6e, 0x01, 0x7c, 0x70, 0xc9, 0x7d, 0xff, 0xaa, 0xe7, 0x5d, 0x12, 0x54, 0x93, 0xab, 0x78, 0xeb, 0xfb, 0xc3, 0xdb, 0x5b, 0xd7, 0x47, 0x55, 0xdd, 0x9b, 0xfc, 0xed, 0x93, 0x01, 0x3a, 0xc2,
0xe4, 0x5e, 0x4a, 0xc8, 0x94, 0x49, 0xd5, 0x6b, 0xe0, 0x7a, 0xae, 0x8f, 0x00, 0x23, 0xb0, 0x75, 0x2d, 0x80, 0x8f, 0x2e, 0xb9, 0xef, 0x5f, 0xf5, 0xbc, 0x4b, 0x82, 0x6a, 0xb2, 0x8a, 0x47, 0xee,
0x9c, 0xaf, 0x66, 0xe1, 0x2f, 0xe0, 0xf8, 0x66, 0xe8, 0xfb, 0x84, 0xfe, 0x12, 0x50, 0xf2, 0xf3, 0x25, 0x85, 0x4c, 0x19, 0x54, 0xbd, 0x06, 0xae, 0xe7, 0xfa, 0x08, 0x30, 0x02, 0x5b, 0xe3, 0xbc,
0x1d, 0x19, 0xfb, 0xc8, 0xee, 0xf4, 0xa0, 0xd9, 0x9f, 0x45, 0x3c, 0xce, 0x72, 0x4f, 0xf0, 0x7b, 0x9a, 0x85, 0xbf, 0x80, 0xe3, 0x9b, 0xa1, 0xef, 0x13, 0xfa, 0x73, 0x40, 0xc9, 0x4f, 0x77, 0x64,
0x30, 0x47, 0x69, 0x32, 0xe1, 0x42, 0x60, 0xb4, 0xff, 0x66, 0x9f, 0xbc, 0xd8, 0x28, 0xeb, 0x67, 0xec, 0x23, 0xbb, 0xd3, 0x83, 0x66, 0x7f, 0x16, 0xf1, 0x38, 0xcb, 0x3d, 0xc1, 0x1f, 0xc0, 0x1c,
0xb5, 0x5d, 0x7a, 0xa8, 0xa9, 0xff, 0xfd, 0xee, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x60, 0xa5, 0xc9, 0x84, 0x0b, 0x81, 0xd1, 0xfe, 0x4b, 0x7e, 0xf2, 0x62, 0xc3, 0xac, 0x1f, 0xdb, 0x76,
0x9a, 0xe1, 0x08, 0x08, 0x00, 0x00, 0xe9, 0xa1, 0xa6, 0xfe, 0x0d, 0x74, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x51, 0x67, 0xf4,
0x1e, 0x08, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

5
api/proto/message/message.proto
Unescape View File

@ -84,8 +84,9 @@ message ConsensusRequest {
uint64 block_num = 2; uint64 block_num = 2;
uint32 shard_id = 3; uint32 shard_id = 3;
bytes block_hash = 4; bytes block_hash = 4;
bytes sender_pubkey = 5; bytes block = 5;
bytes payload = 6; bytes sender_pubkey = 6;
bytes payload = 7;
} }
message DrandRequest { message DrandRequest {

2
consensus/config.go
Unescape View File

@ -14,7 +14,7 @@ const (
bootstrapDuration time.Duration = 300 * time.Second bootstrapDuration time.Duration = 300 * time.Second
maxLogSize uint32 = 1000 maxLogSize uint32 = 1000
// threshold between received consensus message blockNum and my blockNum // threshold between received consensus message blockNum and my blockNum
consensusBlockNumBuffer uint64 = 10 consensusBlockNumBuffer uint64 = 2
) )
// TimeoutType is the type of timeout in view change protocol // TimeoutType is the type of timeout in view change protocol

4
consensus/consensus.go
Unescape View File

@ -19,6 +19,7 @@ import (
nodeconfig "github.com/harmony-one/harmony/internal/configs/node" nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
"github.com/harmony-one/harmony/internal/ctxerror" "github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/genesis" "github.com/harmony-one/harmony/internal/genesis"
"github.com/harmony-one/harmony/internal/memprofiling"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
) )
@ -103,6 +104,8 @@ type Consensus struct {
blockHash [32]byte blockHash [32]byte
// Block to run consensus on // Block to run consensus on
block []byte block []byte
// BlockHeader to run consensus on
blockHeader []byte
// Array of block hashes. // Array of block hashes.
blockHashes [][32]byte blockHashes [][32]byte
// Shard Id which this node belongs to // Shard Id which this node belongs to
@ -275,6 +278,7 @@ func New(host p2p.Host, ShardID uint32, leader p2p.Peer, blsPriKey *bls.SecretKe
consensus.uniqueIDInstance = utils.GetUniqueValidatorIDInstance() consensus.uniqueIDInstance = utils.GetUniqueValidatorIDInstance()
memprofiling.GetMemProfiling().Add("consensus.pbftLog", consensus.pbftLog)
return &consensus, nil return &consensus, nil
} }

5
consensus/consensus_leader_msg.go
Unescape View File

@ -21,8 +21,7 @@ func (consensus *Consensus) constructAnnounceMessage() []byte {
} }
consensusMsg := message.GetConsensus() consensusMsg := message.GetConsensus()
consensus.populateMessageFields(consensusMsg) consensus.populateMessageFields(consensusMsg)
// n byte of block header consensusMsg.Payload = consensus.blockHeader
consensusMsg.Payload = consensus.block // TODO: send only block header in the announce phase.
marshaledMessage, err := consensus.signAndMarshalConsensusMessage(message) marshaledMessage, err := consensus.signAndMarshalConsensusMessage(message)
if err != nil { if err != nil {
@ -43,6 +42,8 @@ func (consensus *Consensus) constructPreparedMessage() ([]byte, *bls.Sign) {
consensusMsg := message.GetConsensus() consensusMsg := message.GetConsensus()
consensus.populateMessageFields(consensusMsg) consensus.populateMessageFields(consensusMsg)
// add block content in prepared message for slow validators to catchup
consensusMsg.Block = consensus.block
//// Payload //// Payload
buffer := bytes.NewBuffer([]byte{}) buffer := bytes.NewBuffer([]byte{})

6
consensus/consensus_service.go
Unescape View File

@ -331,11 +331,13 @@ func (consensus *Consensus) ResetState() {
consensus.getLogger().Debug("[ResetState] Resetting consensus state", "Phase", consensus.phase) consensus.getLogger().Debug("[ResetState] Resetting consensus state", "Phase", consensus.phase)
consensus.switchPhase(Announce, true) consensus.switchPhase(Announce, true)
consensus.blockHash = [32]byte{} consensus.blockHash = [32]byte{}
consensus.blockHeader = []byte{}
consensus.block = []byte{}
consensus.prepareSigs = map[string]*bls.Sign{} consensus.prepareSigs = map[string]*bls.Sign{}
consensus.commitSigs = map[string]*bls.Sign{} consensus.commitSigs = map[string]*bls.Sign{}
prepareBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, consensus.LeaderPubKey) prepareBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, nil)
commitBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, consensus.LeaderPubKey) commitBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, nil)
consensus.prepareBitmap = prepareBitmap consensus.prepareBitmap = prepareBitmap
consensus.commitBitmap = commitBitmap consensus.commitBitmap = commitBitmap
consensus.aggregatedPrepareSig = nil consensus.aggregatedPrepareSig = nil

237
consensus/consensus_v2.go
Unescape View File

@ -3,6 +3,7 @@ package consensus
import ( import (
"bytes" "bytes"
"encoding/binary" "encoding/binary"
"encoding/hex"
"time" "time"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
@ -14,7 +15,6 @@ import (
"github.com/harmony-one/harmony/api/service/explorer" "github.com/harmony-one/harmony/api/service/explorer"
"github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/core/types"
nodeconfig "github.com/harmony-one/harmony/internal/configs/node" nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
"github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/internal/utils" "github.com/harmony-one/harmony/internal/utils"
"github.com/harmony-one/harmony/p2p" "github.com/harmony-one/harmony/p2p"
"github.com/harmony-one/harmony/p2p/host" "github.com/harmony-one/harmony/p2p/host"
@ -82,10 +82,15 @@ func (consensus *Consensus) announce(block *types.Block) {
consensus.getLogger().Debug("[Announce] Failed encoding block") consensus.getLogger().Debug("[Announce] Failed encoding block")
return return
} }
encodedBlockHeader, err := rlp.EncodeToBytes(block.Header())
if err != nil {
consensus.getLogger().Debug("[Announce] Failed encoding block header")
return
}
consensus.block = encodedBlock consensus.block = encodedBlock
consensus.blockHeader = encodedBlockHeader
msgToSend := consensus.constructAnnounceMessage() msgToSend := consensus.constructAnnounceMessage()
consensus.getLogger().Debug("[Announce] Switching phase", "From", consensus.phase, "To", Prepare)
consensus.switchPhase(Prepare, true)
// save announce message to pbftLog // save announce message to pbftLog
msgPayload, _ := proto.GetConsensusMessagePayload(msgToSend) msgPayload, _ := proto.GetConsensusMessagePayload(msgToSend)
@ -102,6 +107,10 @@ func (consensus *Consensus) announce(block *types.Block) {
// Leader sign the block hash itself // Leader sign the block hash itself
consensus.prepareSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(consensus.blockHash[:]) consensus.prepareSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(consensus.blockHash[:])
if err := consensus.prepareBitmap.SetKey(consensus.PubKey, true); err != nil {
consensus.getLogger().Warn("[Announce] Leader prepareBitmap SetKey failed", "error", err)
return
}
// Construct broadcast p2p message // Construct broadcast p2p message
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil { if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil {
@ -109,6 +118,9 @@ func (consensus *Consensus) announce(block *types.Block) {
} else { } else {
consensus.getLogger().Debug("[Announce] Sent Announce Message!!", "BlockHash", block.Hash(), "BlockNum", block.NumberU64()) consensus.getLogger().Debug("[Announce] Sent Announce Message!!", "BlockHash", block.Hash(), "BlockNum", block.NumberU64())
} }
consensus.getLogger().Debug("[Announce] Switching phase", "From", consensus.phase, "To", Prepare)
consensus.switchPhase(Prepare, true)
} }
func (consensus *Consensus) onAnnounce(msg *msg_pb.Message) { func (consensus *Consensus) onAnnounce(msg *msg_pb.Message) {
@ -136,83 +148,71 @@ func (consensus *Consensus) onAnnounce(msg *msg_pb.Message) {
consensus.getLogger().Debug("[OnAnnounce] Unparseable leader message", "error", err, "MsgBlockNum", recvMsg.BlockNum) consensus.getLogger().Debug("[OnAnnounce] Unparseable leader message", "error", err, "MsgBlockNum", recvMsg.BlockNum)
return return
} }
block := recvMsg.Payload
// check block header is valid // verify validity of block header object
var blockObj types.Block blockHeader := recvMsg.Payload
err = rlp.DecodeBytes(block, &blockObj) var headerObj types.Header
err = rlp.DecodeBytes(blockHeader, &headerObj)
if err != nil { if err != nil {
consensus.getLogger().Warn("[OnAnnounce] Unparseable block header data", "error", err, "MsgBlockNum", recvMsg.BlockNum, "MsgPayloadBlockNum", blockObj.NumberU64()) consensus.getLogger().Warn("[OnAnnounce] Unparseable block header data", "error", err, "MsgBlockNum", recvMsg.BlockNum)
return return
} }
if blockObj.NumberU64() != recvMsg.BlockNum || recvMsg.BlockNum < consensus.blockNum { if recvMsg.BlockNum < consensus.blockNum || recvMsg.BlockNum != headerObj.Number.Uint64() {
consensus.getLogger().Warn("[OnAnnounce] BlockNum not match", "MsgBlockNum", recvMsg.BlockNum, "blockNum", blockObj.NumberU64()) consensus.getLogger().Debug("[OnAnnounce] BlockNum not match", "MsgBlockNum", recvMsg.BlockNum, "BlockNum", headerObj.Number)
return return
} }
if consensus.mode.Mode() == Normal { if consensus.mode.Mode() == Normal {
// skip verify header when node is in Syncing mode if err = consensus.VerifyHeader(consensus.ChainReader, &headerObj, false); err != nil {
if err := consensus.VerifyHeader(consensus.ChainReader, blockObj.Header(), false); err != nil { consensus.getLogger().Warn("[OnAnnounce] Block content is not verified successfully", "error", err, "inChain", consensus.ChainReader.CurrentHeader().Number, "MsgBlockNum", headerObj.Number)
consensus.getLogger().Warn("[OnAnnounce] Block content is not verified successfully", "error", err, "inChain", consensus.ChainReader.CurrentHeader().Number, "MsgBlockNum", blockObj.Header().Number)
return return
} }
} }
//blockObj.Logger(consensus.getLogger()).Debug("received announce", "viewID", recvMsg.ViewID, "msgBlockNum", recvMsg.BlockNum)
logMsgs := consensus.pbftLog.GetMessagesByTypeSeqView(msg_pb.MessageType_ANNOUNCE, recvMsg.BlockNum, recvMsg.ViewID) logMsgs := consensus.pbftLog.GetMessagesByTypeSeqView(msg_pb.MessageType_ANNOUNCE, recvMsg.BlockNum, recvMsg.ViewID)
if len(logMsgs) > 0 { if len(logMsgs) > 0 {
if logMsgs[0].BlockHash != blockObj.Header().Hash() { if logMsgs[0].BlockHash != recvMsg.BlockHash {
consensus.getLogger().Debug("[OnAnnounce] Leader is malicious", "leaderKey", consensus.LeaderPubKey.SerializeToHexStr()) consensus.getLogger().Debug("[OnAnnounce] Leader is malicious", "leaderKey", consensus.LeaderPubKey.SerializeToHexStr())
consensus.startViewChange(consensus.viewID + 1) consensus.startViewChange(consensus.viewID + 1)
} }
return return
} }
blockPayload := make([]byte, len(block))
copy(blockPayload[:], block[:]) consensus.getLogger().Debug("[OnAnnounce] Announce message Added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum)
consensus.block = blockPayload
consensus.blockHash = recvMsg.BlockHash
consensus.getLogger().Debug("[OnAnnounce] Announce Block Added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum)
consensus.pbftLog.AddMessage(recvMsg) consensus.pbftLog.AddMessage(recvMsg)
consensus.pbftLog.AddBlock(&blockObj)
consensus.mutex.Lock()
defer consensus.mutex.Unlock()
consensus.blockHash = recvMsg.BlockHash
// we have already added message and block, skip check viewID and send prepare message if is in ViewChanging mode // we have already added message and block, skip check viewID and send prepare message if is in ViewChanging mode
if consensus.mode.Mode() == ViewChanging { if consensus.mode.Mode() == ViewChanging {
consensus.getLogger().Debug("[OnAnnounce] Still in ViewChanging Mode, Exiting !!")
return return
} }
consensus.tryCatchup()
consensus.mutex.Lock()
defer consensus.mutex.Unlock()
if consensus.checkViewID(recvMsg) != nil { if consensus.checkViewID(recvMsg) != nil {
consensus.getLogger().Debug("[OnAnnounce] ViewID check failed", "MsgViewID", recvMsg.ViewID, "msgBlockNum", recvMsg.BlockNum) consensus.getLogger().Debug("[OnAnnounce] ViewID check failed", "MsgViewID", recvMsg.ViewID, "msgBlockNum", recvMsg.BlockNum)
return return
} }
consensus.prepare(&blockObj) consensus.prepare()
return return
} }
// tryPrepare will try to send prepare message // tryPrepare will try to send prepare message
func (consensus *Consensus) prepare(block *types.Block) { func (consensus *Consensus) prepare() {
// if consensus.blockNum != block.NumberU64() || !consensus.pbftLog.HasMatchingViewAnnounce(consensus.blockNum, consensus.viewID, hash) {
// consensus.getLogger().Debug("blockNum or announce message not match")
// return
// }
consensus.getLogger().Debug("[Announce] Switching Phase", "From", consensus.phase, "To", Prepare)
consensus.switchPhase(Prepare, true)
// Construct and send prepare message // Construct and send prepare message
msgToSend := consensus.constructPrepareMessage() msgToSend := consensus.constructPrepareMessage()
// TODO: this will not return immediatey, may block // TODO: this will not return immediatey, may block
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil { if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil {
consensus.getLogger().Warn("[OnAnnounce] Cannot send prepare message") consensus.getLogger().Warn("[OnAnnounce] Cannot send prepare message")
} else { } else {
consensus.getLogger().Info("[OnAnnounce] Sent Prepare Message!!", "BlockHash", block.Hash(), "BlockNum", block.NumberU64()) consensus.getLogger().Info("[OnAnnounce] Sent Prepare Message!!", "BlockHash", hex.EncodeToString(consensus.blockHash[:]))
} }
consensus.getLogger().Debug("[Announce] Switching Phase", "From", consensus.phase, "To", Prepare)
consensus.switchPhase(Prepare, true)
} }
// TODO: move to consensus_leader.go later // TODO: move to consensus_leader.go later
@ -284,7 +284,8 @@ func (consensus *Consensus) onPrepare(msg *msg_pb.Message) {
prepareSigs[validatorPubKey] = &sign prepareSigs[validatorPubKey] = &sign
// Set the bitmap indicating that this validator signed. // Set the bitmap indicating that this validator signed.
if err := prepareBitmap.SetKey(recvMsg.SenderPubkey, true); err != nil { if err := prepareBitmap.SetKey(recvMsg.SenderPubkey, true); err != nil {
ctxerror.Warn(consensus.getLogger(), err, "[OnPrepare] prepareBitmap.SetKey failed") consensus.getLogger().Warn("[OnPrepare] prepareBitmap.SetKey failed", "error", err)
return
} }
if len(prepareSigs) >= consensus.Quorum() { if len(prepareSigs) >= consensus.Quorum() {
@ -293,7 +294,7 @@ func (consensus *Consensus) onPrepare(msg *msg_pb.Message) {
msgToSend, aggSig := consensus.constructPreparedMessage() msgToSend, aggSig := consensus.constructPreparedMessage()
consensus.aggregatedPrepareSig = aggSig consensus.aggregatedPrepareSig = aggSig
// add prepared message to log //leader adds prepared message to log
msgPayload, _ := proto.GetConsensusMessagePayload(msgToSend) msgPayload, _ := proto.GetConsensusMessagePayload(msgToSend)
msg := &msg_pb.Message{} msg := &msg_pb.Message{}
_ = protobuf.Unmarshal(msgPayload, msg) _ = protobuf.Unmarshal(msgPayload, msg)
@ -304,14 +305,6 @@ func (consensus *Consensus) onPrepare(msg *msg_pb.Message) {
} }
consensus.pbftLog.AddMessage(pbftMsg) consensus.pbftLog.AddMessage(pbftMsg)
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil {
consensus.getLogger().Warn("[OnPrepare] Cannot send prepared message")
} else {
consensus.getLogger().Debug("[OnPrepare] Sent Prepared Message!!", "BlockHash", consensus.blockHash, "BlockNum", consensus.blockNum)
}
consensus.getLogger().Debug("[OnPrepare] Switching phase", "From", consensus.phase, "To", Commit)
consensus.switchPhase(Commit, true)
// Leader add commit phase signature // Leader add commit phase signature
blockNumHash := make([]byte, 8) blockNumHash := make([]byte, 8)
binary.LittleEndian.PutUint64(blockNumHash, consensus.blockNum) binary.LittleEndian.PutUint64(blockNumHash, consensus.blockNum)
@ -319,7 +312,16 @@ func (consensus *Consensus) onPrepare(msg *msg_pb.Message) {
consensus.commitSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(commitPayload) consensus.commitSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(commitPayload)
if err := consensus.commitBitmap.SetKey(consensus.PubKey, true); err != nil { if err := consensus.commitBitmap.SetKey(consensus.PubKey, true); err != nil {
consensus.getLogger().Debug("[OnPrepare] Leader commit bitmap set failed") consensus.getLogger().Debug("[OnPrepare] Leader commit bitmap set failed")
return
} }
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil {
consensus.getLogger().Warn("[OnPrepare] Cannot send prepared message")
} else {
consensus.getLogger().Debug("[OnPrepare] Sent Prepared Message!!", "BlockHash", consensus.blockHash, "BlockNum", consensus.blockNum)
}
consensus.getLogger().Debug("[OnPrepare] Switching phase", "From", consensus.phase, "To", Commit)
consensus.switchPhase(Commit, true)
} }
return return
} }
@ -357,22 +359,17 @@ func (consensus *Consensus) onPrepared(msg *msg_pb.Message) {
return return
} }
// check validity of prepared signature
blockHash := recvMsg.BlockHash blockHash := recvMsg.BlockHash
aggSig, mask, err := consensus.readSignatureBitmapPayload(recvMsg.Payload, 0) aggSig, mask, err := consensus.readSignatureBitmapPayload(recvMsg.Payload, 0)
if err != nil { if err != nil {
consensus.getLogger().Error("ReadSignatureBitmapPayload failed!!", "error", err) consensus.getLogger().Error("ReadSignatureBitmapPayload failed!!", "error", err)
return return
} }
consensus.mutex.Lock()
defer consensus.mutex.Unlock()
// check has 2f+1 signatures
if count := utils.CountOneBits(mask.Bitmap); count < consensus.Quorum() { if count := utils.CountOneBits(mask.Bitmap); count < consensus.Quorum() {
consensus.getLogger().Debug("Not enough signatures in the Prepared msg", "Need", consensus.Quorum(), "Got", count) consensus.getLogger().Debug("Not enough signatures in the Prepared msg", "Need", consensus.Quorum(), "Got", count)
return return
} }
if !aggSig.VerifyHash(mask.AggregatePublic, blockHash[:]) { if !aggSig.VerifyHash(mask.AggregatePublic, blockHash[:]) {
myBlockHash := common.Hash{} myBlockHash := common.Hash{}
myBlockHash.SetBytes(consensus.blockHash[:]) myBlockHash.SetBytes(consensus.blockHash[:])
@ -380,16 +377,49 @@ func (consensus *Consensus) onPrepared(msg *msg_pb.Message) {
return return
} }
consensus.getLogger().Debug("[OnPrepared] Prepared message added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum) // check validity of block
block := recvMsg.Block
var blockObj types.Block
err = rlp.DecodeBytes(block, &blockObj)
if err != nil {
consensus.getLogger().Warn("[OnPrepared] Unparseable block header data", "error", err, "MsgBlockNum", recvMsg.BlockNum)
return
}
if blockObj.NumberU64() != recvMsg.BlockNum || recvMsg.BlockNum < consensus.blockNum {
consensus.getLogger().Warn("[OnPrepared] BlockNum not match", "MsgBlockNum", recvMsg.BlockNum, "blockNum", blockObj.NumberU64())
return
}
if blockObj.Header().Hash() != recvMsg.BlockHash {
consensus.getLogger().Warn("[OnPrepared] BlockHash not match", "MsgBlockNum", recvMsg.BlockNum, "MsgBlockHash", recvMsg.BlockHash, "blockObjHash", blockObj.Header().Hash())
return
}
if consensus.mode.Mode() == Normal {
if err := consensus.VerifyHeader(consensus.ChainReader, blockObj.Header(), false); err != nil {
consensus.getLogger().Warn("[OnPrepared] Block header is not verified successfully", "error", err, "inChain", consensus.ChainReader.CurrentHeader().Number, "MsgBlockNum", blockObj.Header().Number)
return
}
if consensus.BlockVerifier == nil {
// do nothing
} else if err := consensus.BlockVerifier(&blockObj); err != nil {
consensus.getLogger().Info("[OnPrepared] Block verification faied")
return
}
}
consensus.pbftLog.AddBlock(&blockObj)
recvMsg.Block = []byte{} // save memory space
consensus.pbftLog.AddMessage(recvMsg) consensus.pbftLog.AddMessage(recvMsg)
consensus.getLogger().Debug("[OnPrepared] Prepared message and block added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum, "blockHash", recvMsg.BlockHash)
consensus.mutex.Lock()
defer consensus.mutex.Unlock()
consensus.tryCatchup()
if consensus.mode.Mode() == ViewChanging { if consensus.mode.Mode() == ViewChanging {
consensus.getLogger().Debug("[OnPrepared] Exiting after viewchange!!") consensus.getLogger().Debug("[OnPrepared] Still in ViewChanging mode, Exiting !!")
return return
} }
consensus.tryCatchup()
if consensus.checkViewID(recvMsg) != nil { if consensus.checkViewID(recvMsg) != nil {
consensus.getLogger().Debug("[OnPrepared] ViewID check failed", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum) consensus.getLogger().Debug("[OnPrepared] ViewID check failed", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum)
return return
@ -400,10 +430,16 @@ func (consensus *Consensus) onPrepared(msg *msg_pb.Message) {
return return
} }
// add block field
blockPayload := make([]byte, len(block))
copy(blockPayload[:], block[:])
consensus.block = blockPayload
// add preparedSig field
consensus.aggregatedPrepareSig = aggSig consensus.aggregatedPrepareSig = aggSig
consensus.prepareBitmap = mask consensus.prepareBitmap = mask
// Optimistically sign on the blockhash of prepare message // Optimistically add blockhash field of prepare message
emptyHash := [32]byte{} emptyHash := [32]byte{}
if bytes.Compare(consensus.blockHash[:], emptyHash[:]) == 0 { if bytes.Compare(consensus.blockHash[:], emptyHash[:]) == 0 {
copy(consensus.blockHash[:], blockHash[:]) copy(consensus.blockHash[:], blockHash[:])
@ -512,7 +548,8 @@ func (consensus *Consensus) onCommit(msg *msg_pb.Message) {
commitSigs[validatorPubKey] = &sign commitSigs[validatorPubKey] = &sign
// Set the bitmap indicating that this validator signed. // Set the bitmap indicating that this validator signed.
if err := commitBitmap.SetKey(recvMsg.SenderPubkey, true); err != nil { if err := commitBitmap.SetKey(recvMsg.SenderPubkey, true); err != nil {
ctxerror.Warn(consensus.getLogger(), err, "[OnCommit] commitBitmap.SetKey failed") consensus.getLogger().Warn("[OnCommit] commitBitmap.SetKey failed", "error", err)
return
} }
quorumIsMet := len(commitSigs) >= consensus.Quorum() quorumIsMet := len(commitSigs) >= consensus.Quorum()
@ -538,47 +575,49 @@ func (consensus *Consensus) onCommit(msg *msg_pb.Message) {
func (consensus *Consensus) finalizeCommits() { func (consensus *Consensus) finalizeCommits() {
consensus.getLogger().Info("[Finalizing] Finalizing Block", "NumCommits", len(consensus.commitSigs)) consensus.getLogger().Info("[Finalizing] Finalizing Block", "NumCommits", len(consensus.commitSigs))
// Construct and broadcast committed message beforeCatchupNum := consensus.blockNum
msgToSend, aggSig := consensus.constructCommittedMessage() beforeCatchupViewID := consensus.viewID
consensus.aggregatedCommitSig = aggSig
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil { // Construct committed message
ctxerror.Warn(consensus.getLogger(), err, "[Finalizing] Cannot send committed message") msgToSend, aggSig := consensus.constructCommittedMessage()
} else { consensus.aggregatedCommitSig = aggSig // this may not needed
consensus.getLogger().Debug("[Finalizing] Sent Committed Message", "BlockHash", consensus.blockHash, "BlockNum", consensus.blockNum)
}
consensus.getLogger().Debug("[Finalizing] Switching phase", "From", consensus.phase, "To", Announce) // leader adds committed message to log
consensus.switchPhase(Announce, true) msgPayload, _ := proto.GetConsensusMessagePayload(msgToSend)
var blockObj types.Block msg := &msg_pb.Message{}
err := rlp.DecodeBytes(consensus.block, &blockObj) _ = protobuf.Unmarshal(msgPayload, msg)
pbftMsg, err := ParsePbftMessage(msg)
if err != nil { if err != nil {
consensus.getLogger().Debug("[Finalizing] failed to construct the new block after consensus") consensus.getLogger().Warn("[FinalizeCommits] Unable to parse pbft message", "error", err)
return
} }
consensus.pbftLog.AddMessage(pbftMsg)
// Sign the block // find correct block content
blockObj.SetPrepareSig( block := consensus.pbftLog.GetBlockByHash(consensus.blockHash)
consensus.aggregatedPrepareSig.Serialize(), if block == nil {
consensus.prepareBitmap.Bitmap) consensus.getLogger().Warn("[FinalizeCommits] Cannot find block by hash", "blockHash", hex.EncodeToString(consensus.blockHash[:]))
blockObj.SetCommitSig( return
consensus.aggregatedCommitSig.Serialize(), }
consensus.commitBitmap.Bitmap) consensus.tryCatchup()
if consensus.blockNum-beforeCatchupNum != 1 {
select { consensus.getLogger().Warn("[FinalizeCommits] Leader cannot provide the correct block for committed message", "beforeCatchupBlockNum", beforeCatchupNum)
case consensus.VerifiedNewBlock <- &blockObj: return
default: }
consensus.getLogger().Info("[SYNC] Failed to send consensus verified block for state sync", "blockHash", blockObj.Hash()) // if leader success finalize the block, send committed message to validators
if err := consensus.host.SendMessageToGroups([]p2p.GroupID{p2p.NewGroupIDByShardID(p2p.ShardID(consensus.ShardID))}, host.ConstructP2pMessage(byte(17), msgToSend)); err != nil {
consensus.getLogger().Warn("[Finalizing] Cannot send committed message", "error", err)
} else {
consensus.getLogger().Debug("[Finalizing] Sent Committed Message", "BlockHash", consensus.blockHash, "BlockNum", consensus.blockNum)
} }
consensus.reportMetrics(blockObj) consensus.reportMetrics(*block)
// Dump new block into level db.
explorer.GetStorageInstance(consensus.leader.IP, consensus.leader.Port, true).Dump(&blockObj, consensus.viewID)
// Reset state to Finished, and clear other data. // Dump new block into level db
consensus.ResetState() // In current code, we add signatures in block in tryCatchup, the block dump to explorer does not contains signatures
consensus.viewID++ // but since explorer doesn't need signatures, it should be fine
consensus.blockNum++ // in future, we will move signatures to next block
explorer.GetStorageInstance(consensus.leader.IP, consensus.leader.Port, true).Dump(block, beforeCatchupViewID)
if consensus.consensusTimeout[timeoutBootstrap].IsActive() { if consensus.consensusTimeout[timeoutBootstrap].IsActive() {
consensus.consensusTimeout[timeoutBootstrap].Stop() consensus.consensusTimeout[timeoutBootstrap].Stop()
@ -588,8 +627,7 @@ func (consensus *Consensus) finalizeCommits() {
} }
consensus.consensusTimeout[timeoutConsensus].Start() consensus.consensusTimeout[timeoutConsensus].Start()
consensus.OnConsensusDone(&blockObj) consensus.getLogger().Info("HOORAY!!!!!!! CONSENSUS REACHED!!!!!!!", "BlockNum", beforeCatchupNum, "ViewId", beforeCatchupViewID, "BlockHash", block.Hash(), "index", consensus.getIndexOfPubKey(consensus.PubKey))
consensus.getLogger().Info("HOORAY!!!!!!! CONSENSUS REACHED!!!!!!!", "numOfSignatures", len(consensus.commitSigs), "BlockNum", consensus.blockNum-1, "ViewId", consensus.viewID-1, "BlockHash", blockObj.Hash())
// TODO: wait for validators receive committed message; remove this temporary delay // TODO: wait for validators receive committed message; remove this temporary delay
time.Sleep(time.Second) time.Sleep(time.Second)
@ -649,13 +687,14 @@ func (consensus *Consensus) onCommitted(msg *msg_pb.Message) {
return return
} }
consensus.pbftLog.AddMessage(recvMsg)
consensus.getLogger().Debug("[OnCommitted] Committed message added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum)
consensus.mutex.Lock() consensus.mutex.Lock()
defer consensus.mutex.Unlock() defer consensus.mutex.Unlock()
consensus.aggregatedCommitSig = aggSig consensus.aggregatedCommitSig = aggSig
consensus.commitBitmap = mask consensus.commitBitmap = mask
consensus.getLogger().Debug("[OnCommitted] Committed message added", "MsgViewID", recvMsg.ViewID, "MsgBlockNum", recvMsg.BlockNum)
consensus.pbftLog.AddMessage(recvMsg)
if recvMsg.BlockNum-consensus.blockNum > consensusBlockNumBuffer { if recvMsg.BlockNum-consensus.blockNum > consensusBlockNumBuffer {
consensus.getLogger().Debug("[OnCommitted] out of sync", "MsgBlockNum", recvMsg.BlockNum) consensus.getLogger().Debug("[OnCommitted] out of sync", "MsgBlockNum", recvMsg.BlockNum)
@ -678,6 +717,10 @@ func (consensus *Consensus) onCommitted(msg *msg_pb.Message) {
// } // }
consensus.tryCatchup() consensus.tryCatchup()
if consensus.mode.Mode() == ViewChanging {
consensus.getLogger().Debug("[OnCommitted] Still in ViewChanging mode, Exiting !!")
return
}
if consensus.consensusTimeout[timeoutBootstrap].IsActive() { if consensus.consensusTimeout[timeoutBootstrap].IsActive() {
consensus.consensusTimeout[timeoutBootstrap].Stop() consensus.consensusTimeout[timeoutBootstrap].Stop()

4
consensus/pbft_log.go
Unescape View File

@ -27,6 +27,7 @@ type PbftMessage struct {
ViewID uint32 ViewID uint32
BlockNum uint64 BlockNum uint64
BlockHash common.Hash BlockHash common.Hash
Block []byte
SenderPubkey *bls.PublicKey SenderPubkey *bls.PublicKey
LeaderPubkey *bls.PublicKey LeaderPubkey *bls.PublicKey
Payload []byte Payload []byte
@ -217,6 +218,9 @@ func ParsePbftMessage(msg *msg_pb.Message) (*PbftMessage, error) {
copy(pbftMsg.BlockHash[:], consensusMsg.BlockHash[:]) copy(pbftMsg.BlockHash[:], consensusMsg.BlockHash[:])
pbftMsg.Payload = make([]byte, len(consensusMsg.Payload)) pbftMsg.Payload = make([]byte, len(consensusMsg.Payload))
copy(pbftMsg.Payload[:], consensusMsg.Payload[:]) copy(pbftMsg.Payload[:], consensusMsg.Payload[:])
pbftMsg.Block = make([]byte, len(consensusMsg.Block))
copy(pbftMsg.Block[:], consensusMsg.Block[:])
pubKey, err := bls_cosi.BytesToBlsPublicKey(consensusMsg.SenderPubkey) pubKey, err := bls_cosi.BytesToBlsPublicKey(consensusMsg.SenderPubkey)
if err != nil { if err != nil {
return nil, err return nil, err

4
consensus/view_change.go
Unescape View File

@ -367,6 +367,10 @@ func (consensus *Consensus) onViewChange(msg *msg_pb.Message) {
binary.LittleEndian.PutUint64(blockNumBytes, consensus.blockNum) binary.LittleEndian.PutUint64(blockNumBytes, consensus.blockNum)
commitPayload := append(blockNumBytes, consensus.blockHash[:]...) commitPayload := append(blockNumBytes, consensus.blockHash[:]...)
consensus.commitSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(commitPayload) consensus.commitSigs[consensus.PubKey.SerializeToHexStr()] = consensus.priKey.SignHash(commitPayload)
if err = consensus.commitBitmap.SetKey(consensus.PubKey, true); err != nil {
consensus.getLogger().Debug("[OnViewChange] New Leader commit bitmap set failed")
return
}
} }
consensus.mode.SetViewID(recvMsg.ViewID) consensus.mode.SetViewID(recvMsg.ViewID)

Write Preview
Loading…
Cancel
Save