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

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

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

2
consensus/config.go
Unescape View File

@ -14,7 +14,7 @@ const (
bootstrapDuration time.Duration = 300 * time.Second
maxLogSize uint32 = 1000
// 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

4
consensus/consensus.go
Unescape View File

@ -19,6 +19,7 @@ import (
nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
"github.com/harmony-one/harmony/internal/ctxerror"
"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/p2p"
)
@ -103,6 +104,8 @@ type Consensus struct {
blockHash [32]byte
// Block to run consensus on
block []byte
// BlockHeader to run consensus on
blockHeader []byte
// Array of block hashes.
blockHashes [][32]byte
// 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()
memprofiling.GetMemProfiling().Add("consensus.pbftLog", consensus.pbftLog)
return &consensus, nil
}

5
consensus/consensus_leader_msg.go
Unescape View File

@ -21,8 +21,7 @@ func (consensus *Consensus) constructAnnounceMessage() []byte {
}
consensusMsg := message.GetConsensus()
consensus.populateMessageFields(consensusMsg)
// n byte of block header
consensusMsg.Payload = consensus.block // TODO: send only block header in the announce phase.
consensusMsg.Payload = consensus.blockHeader
marshaledMessage, err := consensus.signAndMarshalConsensusMessage(message)
if err != nil {
@ -43,6 +42,8 @@ func (consensus *Consensus) constructPreparedMessage() ([]byte, *bls.Sign) {
consensusMsg := message.GetConsensus()
consensus.populateMessageFields(consensusMsg)
// add block content in prepared message for slow validators to catchup
consensusMsg.Block = consensus.block
//// Payload
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.switchPhase(Announce, true)
consensus.blockHash = [32]byte{}
consensus.blockHeader = []byte{}
consensus.block = []byte{}
consensus.prepareSigs = map[string]*bls.Sign{}
consensus.commitSigs = map[string]*bls.Sign{}
prepareBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, consensus.LeaderPubKey)
commitBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, consensus.LeaderPubKey)
prepareBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, nil)
commitBitmap, _ := bls_cosi.NewMask(consensus.PublicKeys, nil)
consensus.prepareBitmap = prepareBitmap
consensus.commitBitmap = commitBitmap
consensus.aggregatedPrepareSig = nil

237
consensus/consensus_v2.go
Unescape View File

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

4
consensus/pbft_log.go
Unescape View File

@ -27,6 +27,7 @@ type PbftMessage struct {
ViewID uint32
BlockNum uint64
BlockHash common.Hash
Block []byte
SenderPubkey *bls.PublicKey
LeaderPubkey *bls.PublicKey
Payload []byte
@ -217,6 +218,9 @@ func ParsePbftMessage(msg *msg_pb.Message) (*PbftMessage, error) {
copy(pbftMsg.BlockHash[:], consensusMsg.BlockHash[:])
pbftMsg.Payload = make([]byte, len(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)
if err != nil {
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)
commitPayload := append(blockNumBytes, consensus.blockHash[:]...)
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)

Write Preview
Loading…
Cancel
Save