Browse Source

test: protobuf vectors for reactors (#5221)

## Description

Add test vectors for all reactors

- [x] state-sync
- [x] privval
- [x] mempool
- [x] p2p
- [x] evidence
- [ ] light?

this PR is primarily oriented at testvectors for things going over the wire. should we expand the testvectors into types as well?

Closes: #XXX
pull/5231/head
Marko 4 years ago
committed by GitHub
parent
commit
40bd416d59
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 403 additions and 138 deletions
  1. +12
    -25
      blockchain/msgs_test.go
  2. +15
    -45
      consensus/msgs_test.go
  3. +90
    -0
      evidence/reactor_test.go
  4. +30
    -0
      mempool/reactor_test.go
  5. +26
    -0
      p2p/conn/connection_test.go
  6. +4
    -2
      p2p/pex/pex_reactor.go
  7. +28
    -0
      p2p/pex/pex_reactor_test.go
  8. +0
    -0
      privval/msgs.go
  9. +103
    -0
      privval/msgs_test.go
  10. +1
    -1
      privval/signer_client.go
  11. +2
    -2
      privval/signer_requestHandler.go
  12. +66
    -60
      proto/tendermint/privval/types.pb.go
  13. +1
    -2
      proto/tendermint/privval/types.proto
  14. +1
    -1
      statesync/messages.go
  15. +24
    -0
      statesync/messages_test.go

+ 12
- 25
blockchain/msgs_test.go View File

@ -1,6 +1,7 @@
package blockchain package blockchain
import ( import (
"encoding/hex"
"math" "math"
"testing" "testing"
@ -77,8 +78,8 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
} }
} }
// nolint:lll // ignore line length in tests
func TestBlockchainMessageVectors(t *testing.T) { func TestBlockchainMessageVectors(t *testing.T) {
block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil) block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil)
bpb, err := block.ToProto() bpb, err := block.ToProto()
@ -87,43 +88,29 @@ func TestBlockchainMessageVectors(t *testing.T) {
testCases := []struct { testCases := []struct {
testName string testName string
bmsg proto.Message bmsg proto.Message
expBytes []byte
expBytes string
}{ }{
{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{ {"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
BlockRequest: &bcproto.BlockRequest{Height: 1}}}, []byte{0xa, 0x2, 0x8, 0x1}},
BlockRequest: &bcproto.BlockRequest{Height: 1}}}, "0a020801"},
{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{ {"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
BlockRequest: &bcproto.BlockRequest{Height: math.MaxInt64}}}, BlockRequest: &bcproto.BlockRequest{Height: math.MaxInt64}}},
[]byte{0xa, 0xa, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
"0a0a08ffffffffffffffff7f"},
{"BlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_BlockResponse{ {"BlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_BlockResponse{
BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, []byte{0x1a, 0xb3, 0x1, 0xa,
0xb0, 0x1, 0xa, 0x59, 0xa, 0x0, 0x18, 0x3, 0x22, 0xb, 0x8, 0x80, 0x92, 0xb8, 0xc3,
0x98, 0xfe, 0xff, 0xff, 0xff, 0x1, 0x2a, 0x2, 0x12, 0x0, 0x3a, 0x20, 0xc4, 0xda,
0x88, 0xe8, 0x76, 0x6, 0x2a, 0xa1, 0x54, 0x34, 0x0, 0xd5, 0xd, 0xe, 0xaa, 0xd, 0xac,
0x88, 0x9, 0x60, 0x57, 0x94, 0x9c, 0xfb, 0x7b, 0xca, 0x7f, 0x3a, 0x48, 0xc0, 0x4b,
0xf9, 0x6a, 0x20, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4,
0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0x12, 0x2f, 0xa, 0xb, 0x48, 0x65, 0x6c,
0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x12, 0x20, 0xc4, 0xda, 0x88, 0xe8,
0x76, 0x6, 0x2a, 0xa1, 0x54, 0x34, 0x0, 0xd5, 0xd, 0xe, 0xaa, 0xd, 0xac, 0x88, 0x9,
0x60, 0x57, 0x94, 0x9c, 0xfb, 0x7b, 0xca, 0x7f, 0x3a, 0x48, 0xc0, 0x4b, 0xf9, 0x1a,
0x22, 0x12, 0x20, 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4,
0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55}},
BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, "1ab3010ab0010a590a001803220b088092b8c398feffffff012a0212003a20c4da88e876062aa1543400d50d0eaa0dac88096057949cfb7bca7f3a48c04bf96a20e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855122f0a0b48656c6c6f20576f726c641220c4da88e876062aa1543400d50d0eaa0dac88096057949cfb7bca7f3a48c04bf91a221220e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{ {"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, []byte{0x12, 0x2, 0x8, 0x1}},
NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, "12020801"},
{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{ {"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
NoBlockResponse: &bcproto.NoBlockResponse{Height: math.MaxInt64}}}, NoBlockResponse: &bcproto.NoBlockResponse{Height: math.MaxInt64}}},
[]byte{0x12, 0xa, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
"120a08ffffffffffffffff7f"},
{"StatusRequestMessage", &bcproto.Message{Sum: &bcproto.Message_StatusRequest{ {"StatusRequestMessage", &bcproto.Message{Sum: &bcproto.Message_StatusRequest{
StatusRequest: &bcproto.StatusRequest{}}}, StatusRequest: &bcproto.StatusRequest{}}},
[]byte{0x22, 0x0}},
"2200"},
{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{ {"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
StatusResponse: &bcproto.StatusResponse{Height: 1, Base: 2}}}, StatusResponse: &bcproto.StatusResponse{Height: 1, Base: 2}}},
[]byte{0x2a, 0x4, 0x8, 0x1, 0x10, 0x2}},
"2a0408011002"},
{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{ {"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
StatusResponse: &bcproto.StatusResponse{Height: math.MaxInt64, Base: math.MaxInt64}}}, StatusResponse: &bcproto.StatusResponse{Height: math.MaxInt64, Base: math.MaxInt64}}},
[]byte{0x2a, 0x14, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x10,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
"2a1408ffffffffffffffff7f10ffffffffffffffff7f"},
} }
for _, tc := range testCases { for _, tc := range testCases {
@ -131,7 +118,7 @@ func TestBlockchainMessageVectors(t *testing.T) {
t.Run(tc.testName, func(t *testing.T) { t.Run(tc.testName, func(t *testing.T) {
bz, _ := proto.Marshal(tc.bmsg) bz, _ := proto.Marshal(tc.bmsg)
require.Equal(t, tc.expBytes, bz)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz))
}) })
} }
} }

+ 15
- 45
consensus/msgs_test.go View File

@ -1,6 +1,7 @@
package consensus package consensus
import ( import (
"encoding/hex"
"math" "math"
"testing" "testing"
"time" "time"
@ -313,6 +314,7 @@ func TestWALMsgProto(t *testing.T) {
} }
} }
// nolint:lll //ignore line length for tests
func TestConsMsgsVectors(t *testing.T) { func TestConsMsgsVectors(t *testing.T) {
date := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC) date := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC)
psh := types.PartSetHeader{ psh := types.PartSetHeader{
@ -367,7 +369,7 @@ func TestConsMsgsVectors(t *testing.T) {
testCases := []struct { testCases := []struct {
testName string testName string
cMsg proto.Message cMsg proto.Message
expBytes []byte
expBytes string
}{ }{
{"NewRoundStep", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{ {"NewRoundStep", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{
Height: 1, Height: 1,
@ -375,74 +377,42 @@ func TestConsMsgsVectors(t *testing.T) {
Step: 1, Step: 1,
SecondsSinceStartTime: 1, SecondsSinceStartTime: 1,
LastCommitRound: 1, LastCommitRound: 1,
}}}, []byte{0xa, 0xa, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1, 0x28, 0x1}},
}}}, "0a0a08011001180120012801"},
{"NewRoundStep Max", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{ {"NewRoundStep Max", &tmcons.Message{Sum: &tmcons.Message_NewRoundStep{NewRoundStep: &tmcons.NewRoundStep{
Height: math.MaxInt64, Height: math.MaxInt64,
Round: math.MaxInt32, Round: math.MaxInt32,
Step: math.MaxUint32, Step: math.MaxUint32,
SecondsSinceStartTime: math.MaxInt64, SecondsSinceStartTime: math.MaxInt64,
LastCommitRound: math.MaxInt32, LastCommitRound: math.MaxInt32,
}}}, []byte{0xa, 0x26, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x10, 0xff,
0xff, 0xff, 0xff, 0x7, 0x18, 0xff, 0xff, 0xff, 0xff, 0xf, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x7f, 0x28, 0xff, 0xff, 0xff, 0xff, 0x7}},
}}}, "0a2608ffffffffffffffff7f10ffffffff0718ffffffff0f20ffffffffffffffff7f28ffffffff07"},
{"NewValidBlock", &tmcons.Message{Sum: &tmcons.Message_NewValidBlock{ {"NewValidBlock", &tmcons.Message{Sum: &tmcons.Message_NewValidBlock{
NewValidBlock: &tmcons.NewValidBlock{ NewValidBlock: &tmcons.NewValidBlock{
Height: 1, Round: 1, BlockPartSetHeader: pbPsh, BlockParts: pbBits, IsCommit: false}}}, Height: 1, Round: 1, BlockPartSetHeader: pbPsh, BlockParts: pbBits, IsCommit: false}}},
[]byte{0x12, 0x31, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d,
0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d,
0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x22, 0x5, 0x8, 0x1, 0x12, 0x1, 0x0}},
"1231080110011a24080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d22050801120100"},
{"Proposal", &tmcons.Message{Sum: &tmcons.Message_Proposal{Proposal: &tmcons.Proposal{Proposal: *pbProposal}}}, {"Proposal", &tmcons.Message{Sum: &tmcons.Message_Proposal{Proposal: &tmcons.Proposal{Proposal: *pbProposal}}},
[]byte{0x1a, 0x72, 0xa, 0x70, 0x8, 0x20, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1, 0x2a, 0x48, 0xa, 0x20, 0x61,
0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8,
0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65,
0x2d, 0x32, 0x6, 0x8, 0xc0, 0xb8, 0x9f, 0xdc, 0x5, 0x3a, 0x14, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e}},
"1a720a7008201001180120012a480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d320608c0b89fdc053a146164645f6d6f72655f6578636c616d6174696f6e"},
{"ProposalPol", &tmcons.Message{Sum: &tmcons.Message_ProposalPol{ {"ProposalPol", &tmcons.Message{Sum: &tmcons.Message_ProposalPol{
ProposalPol: &tmcons.ProposalPOL{Height: 1, ProposalPolRound: 1}}}, ProposalPol: &tmcons.ProposalPOL{Height: 1, ProposalPolRound: 1}}},
[]byte{0x22, 0x6, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x0}},
"2206080110011a00"},
{"BlockPart", &tmcons.Message{Sum: &tmcons.Message_BlockPart{ {"BlockPart", &tmcons.Message{Sum: &tmcons.Message_BlockPart{
BlockPart: &tmcons.BlockPart{Height: 1, Round: 1, Part: *pbParts}}}, BlockPart: &tmcons.BlockPart{Height: 1, Round: 1, Part: *pbParts}}},
[]byte{0x2a, 0x36, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x30, 0x8, 0x1, 0x12, 0x4,
0x74, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x8, 0x1, 0x10, 0x1, 0x1a, 0x20, 0x61,
0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63,
0x6f, 0x64, 0x65, 0x2d}},
"2a36080110011a3008011204746573741a26080110011a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d"},
{"Vote", &tmcons.Message{Sum: &tmcons.Message_Vote{ {"Vote", &tmcons.Message{Sum: &tmcons.Message_Vote{
Vote: &tmcons.Vote{Vote: vpb}}}, Vote: &tmcons.Vote{Vote: vpb}}},
[]byte{0x32, 0x70, 0xa, 0x6e, 0x8, 0x2, 0x10, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64,
0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12,
0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78,
0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f,
0x63, 0x6f, 0x64, 0x65, 0x2d, 0x2a, 0x6, 0x8, 0xc0, 0xb8, 0x9f, 0xdc, 0x5, 0x32, 0x14, 0x61, 0x64,
0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x38, 0x1}},
"32700a6e0802100122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d2a0608c0b89fdc0532146164645f6d6f72655f6578636c616d6174696f6e3801"},
{"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{ {"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{
HasVote: &tmcons.HasVote{Height: 1, Round: 1, Type: tmproto.PrevoteType, Index: 1}}}, HasVote: &tmcons.HasVote{Height: 1, Round: 1, Type: tmproto.PrevoteType, Index: 1}}},
[]byte{0x3a, 0x8, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x20, 0x1}},
"3a080801100118012001"},
{"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{ {"HasVote", &tmcons.Message{Sum: &tmcons.Message_HasVote{
HasVote: &tmcons.HasVote{Height: math.MaxInt64, Round: math.MaxInt32, HasVote: &tmcons.HasVote{Height: math.MaxInt64, Round: math.MaxInt32,
Type: tmproto.PrevoteType, Index: math.MaxInt32}}}, Type: tmproto.PrevoteType, Index: math.MaxInt32}}},
[]byte{0x3a, 0x18, 0x8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x7f, 0x10, 0xff, 0xff, 0xff, 0xff, 0x7, 0x18, 0x1, 0x20, 0xff, 0xff, 0xff, 0xff, 0x7}},
"3a1808ffffffffffffffff7f10ffffffff07180120ffffffff07"},
{"VoteSetMaj23", &tmcons.Message{Sum: &tmcons.Message_VoteSetMaj23{ {"VoteSetMaj23", &tmcons.Message{Sum: &tmcons.Message_VoteSetMaj23{
VoteSetMaj23: &tmcons.VoteSetMaj23{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi}}}, VoteSetMaj23: &tmcons.VoteSetMaj23{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi}}},
[]byte{0x42, 0x50, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64, 0x5f,
0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8, 0x1,
0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61,
0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x5f, 0x63, 0x6f, 0x64,
0x65, 0x2d}},
"425008011001180122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d"},
{"VoteSetBits", &tmcons.Message{Sum: &tmcons.Message_VoteSetBits{ {"VoteSetBits", &tmcons.Message{Sum: &tmcons.Message_VoteSetBits{
VoteSetBits: &tmcons.VoteSetBits{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi, Votes: *pbBits}}}, VoteSetBits: &tmcons.VoteSetBits{Height: 1, Round: 1, Type: tmproto.PrevoteType, BlockID: pbBi, Votes: *pbBits}}},
[]byte{0x4a, 0x57, 0x8, 0x1, 0x10, 0x1, 0x18, 0x1, 0x22, 0x48, 0xa, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73,
0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x12, 0x24, 0x8, 0x1, 0x12, 0x20, 0x61, 0x64, 0x64, 0x5f, 0x6d, 0x6f, 0x72,
0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x73,
0x5f, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x2a, 0x5, 0x8, 0x1, 0x12, 0x1, 0x0}},
"4a5708011001180122480a206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d1224080112206164645f6d6f72655f6578636c616d6174696f6e5f6d61726b735f636f64652d2a050801120100"},
} }
for _, tc := range testCases { for _, tc := range testCases {
@ -451,7 +421,7 @@ func TestConsMsgsVectors(t *testing.T) {
bz, err := proto.Marshal(tc.cMsg) bz, err := proto.Marshal(tc.cMsg)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, tc.expBytes, bz)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz))
}) })
} }
} }

+ 90
- 0
evidence/reactor_test.go View File

@ -1,6 +1,7 @@
package evidence package evidence
import ( import (
"encoding/hex"
"fmt" "fmt"
"sync" "sync"
"testing" "testing"
@ -14,9 +15,14 @@ import (
dbm "github.com/tendermint/tm-db" dbm "github.com/tendermint/tm-db"
cfg "github.com/tendermint/tendermint/config" cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/tmhash"
"github.com/tendermint/tendermint/evidence/mocks" "github.com/tendermint/tendermint/evidence/mocks"
"github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/log"
"github.com/tendermint/tendermint/p2p" "github.com/tendermint/tendermint/p2p"
ep "github.com/tendermint/tendermint/proto/tendermint/evidence"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/tendermint/tendermint/proto/tendermint/version"
"github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/types"
) )
@ -208,3 +214,87 @@ func TestReactorSelectiveBroadcast(t *testing.T) {
peers := reactors[1].Switch.Peers().List() peers := reactors[1].Switch.Peers().List()
assert.Equal(t, 1, len(peers)) assert.Equal(t, 1, len(peers))
} }
func exampleVote(t byte) *types.Vote {
var stamp, err = time.Parse(types.TimeFormat, "2017-12-25T03:00:01.234Z")
if err != nil {
panic(err)
}
return &types.Vote{
Type: tmproto.SignedMsgType(t),
Height: 3,
Round: 2,
Timestamp: stamp,
BlockID: types.BlockID{
Hash: tmhash.Sum([]byte("blockID_hash")),
PartSetHeader: types.PartSetHeader{
Total: 1000000,
Hash: tmhash.Sum([]byte("blockID_part_set_header_hash")),
},
},
ValidatorAddress: crypto.AddressHash([]byte("validator_address")),
ValidatorIndex: 56789,
}
}
func exampleHeader() *types.Header {
blockID := types.BlockID{Hash: []byte{0}, PartSetHeader: types.PartSetHeader{Total: 123, Hash: []byte{0}}}
h := &types.Header{
Version: version.Consensus{Block: 1, App: 2},
ChainID: "chainId",
Height: 3,
Time: time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC),
LastBlockID: blockID,
LastCommitHash: tmhash.Sum([]byte("last_commit_hash")),
DataHash: tmhash.Sum([]byte("data_hash")),
ValidatorsHash: tmhash.Sum([]byte("validators_hash")),
NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
ConsensusHash: tmhash.Sum([]byte("consensus_hash")),
AppHash: tmhash.Sum([]byte("app_hash")),
LastResultsHash: tmhash.Sum([]byte("last_results_hash")),
EvidenceHash: tmhash.Sum([]byte("evidence_hash")),
ProposerAddress: crypto.AddressHash([]byte("proposer_address")),
}
return h
}
// nolint:lll //ignore line length for tests
func TestEvidenceVectors(t *testing.T) {
dupl := types.NewDuplicateVoteEvidence(exampleVote(1), exampleVote(2), time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC))
lve := types.NewLunaticValidatorEvidence(exampleHeader(), exampleVote(1), "Datahash", time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC))
testCases := []struct {
testName string
evidenceList []types.Evidence
expBytes string
}{
{"DuplicateVoteEvidence", []types.Evidence{dupl}, "0a81020afe010a79080210031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031279080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031a0608f49a8ded05"},
{"LunaticValidatorEvidence", []types.Evidence{lve}, "0ade031adb030acb020a04080110021207636861696e49641803220608f49a8ded052a0a0a01001205087b1201003220e7aad01a1af897b05bcf78c7563b5d1adc2939d543dac949a5c8712156d19bf83a206d6e28b8b98b5327042ea50a57dd46e6cc851c72e528bdeaa6efdeeefe66a0b84220db5d0767f57d844ba68132eaf74f6b8b83df6c03810a6a4378c2a6b2caf93e8d4a201eef9748a3c48ff996033757d73200886e7b2b4e9d9df07b19a34a44bae3e2c85220e5e566c41ed57e3ff8cc10f184178788b8faa602b07cf1f425217bd8179f1f245a2041cafae31cc70f5801fa1016a2dd54a9bcb8201b5b389919fe9976762532c5166220092e058630247ed6009863a12eee117d26cd9d08b5adcaab37f2ab35db475a376a2073865db08f49d58428905d389ab4ca4b96e45a3206c7a69d43a5dc7372e60714721427834082c131975497cdebfbdce6c8e5196a13541279080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0b08b1d381d20510809dca6f32146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb031a084461746168617368220608f49a8ded05"},
}
for _, tc := range testCases {
tc := tc
evi := make([]*tmproto.Evidence, len(tc.evidenceList))
for i := 0; i < len(tc.evidenceList); i++ {
ev, err := types.EvidenceToProto(tc.evidenceList[i])
require.NoError(t, err, tc.testName)
evi[i] = ev
}
epl := ep.List{
Evidence: evi,
}
bz, err := epl.Marshal()
require.NoError(t, err, tc.testName)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

+ 30
- 0
mempool/reactor_test.go View File

@ -1,6 +1,7 @@
package mempool package mempool
import ( import (
"encoding/hex"
"errors" "errors"
"net" "net"
"sync" "sync"
@ -10,12 +11,14 @@ import (
"github.com/fortytw2/leaktest" "github.com/fortytw2/leaktest"
"github.com/go-kit/kit/log/term" "github.com/go-kit/kit/log/term"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/abci/example/kvstore" "github.com/tendermint/tendermint/abci/example/kvstore"
cfg "github.com/tendermint/tendermint/config" cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/log"
"github.com/tendermint/tendermint/p2p" "github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/p2p/mock" "github.com/tendermint/tendermint/p2p/mock"
memproto "github.com/tendermint/tendermint/proto/tendermint/mempool"
"github.com/tendermint/tendermint/proxy" "github.com/tendermint/tendermint/proxy"
"github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/types"
) )
@ -246,3 +249,30 @@ func ensureNoTxs(t *testing.T, reactor *Reactor, timeout time.Duration) {
time.Sleep(timeout) // wait for the txs in all mempools time.Sleep(timeout) // wait for the txs in all mempools
assert.Zero(t, reactor.mempool.Size()) assert.Zero(t, reactor.mempool.Size())
} }
func TestMempoolVectors(t *testing.T) {
testCases := []struct {
testName string
tx []byte
expBytes string
}{
{"tx 1", []byte{123}, "0a030a017b"},
{"tx 2", []byte("proto encoding in mempool"), "0a1b0a1970726f746f20656e636f64696e6720696e206d656d706f6f6c"},
}
for _, tc := range testCases {
tc := tc
msg := memproto.Message{
Sum: &memproto.Message_Tx{
Tx: &memproto.Tx{Tx: tc.tx},
},
}
bz, err := msg.Marshal()
require.NoError(t, err, tc.testName)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

+ 26
- 0
p2p/conn/connection_test.go View File

@ -1,11 +1,13 @@
package conn package conn
import ( import (
"encoding/hex"
"net" "net"
"testing" "testing"
"time" "time"
"github.com/fortytw2/leaktest" "github.com/fortytw2/leaktest"
"github.com/gogo/protobuf/proto"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
@ -561,3 +563,27 @@ func TestMConnectionTrySend(t *testing.T) {
assert.False(t, mconn.TrySend(0x01, msg)) assert.False(t, mconn.TrySend(0x01, msg))
assert.Equal(t, "TrySend", <-resultCh) assert.Equal(t, "TrySend", <-resultCh)
} }
// nolint:lll //ignore line length for tests
func TestConnVectors(t *testing.T) {
testCases := []struct {
testName string
msg proto.Message
expBytes string
}{
{"PacketPing", &tmp2p.PacketPing{}, "0a00"},
{"PacketPong", &tmp2p.PacketPong{}, "1200"},
{"PacketMsg", &tmp2p.PacketMsg{ChannelID: 1, EOF: false, Data: []byte("data transmitted over the wire")}, "1a2208011a1e64617461207472616e736d6974746564206f766572207468652077697265"},
}
for _, tc := range testCases {
tc := tc
pm := mustWrapPacket(tc.msg)
bz, err := pm.Marshal()
require.NoError(t, err, tc.testName)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

+ 4
- 2
p2p/pex/pex_reactor.go View File

@ -779,7 +779,7 @@ func mustEncode(pb proto.Message) []byte {
panic(fmt.Sprintf("Unknown message type %T", pb)) panic(fmt.Sprintf("Unknown message type %T", pb))
} }
bz, err := proto.Marshal(&msg)
bz, err := msg.Marshal()
if err != nil { if err != nil {
panic(fmt.Errorf("unable to marshal %T: %w", pb, err)) panic(fmt.Errorf("unable to marshal %T: %w", pb, err))
} }
@ -788,10 +788,12 @@ func mustEncode(pb proto.Message) []byte {
func decodeMsg(bz []byte) (proto.Message, error) { func decodeMsg(bz []byte) (proto.Message, error) {
pb := &tmp2p.Message{} pb := &tmp2p.Message{}
err := proto.Unmarshal(bz, pb)
err := pb.Unmarshal(bz)
if err != nil { if err != nil {
return nil, err return nil, err
} }
switch msg := pb.Sum.(type) { switch msg := pb.Sum.(type) {
case *tmp2p.Message_PexRequest: case *tmp2p.Message_PexRequest:
return msg.PexRequest, nil return msg.PexRequest, nil


+ 28
- 0
p2p/pex/pex_reactor_test.go View File

@ -1,6 +1,7 @@
package pex package pex
import ( import (
"encoding/hex"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"os" "os"
@ -8,6 +9,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/gogo/protobuf/proto"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
@ -673,3 +675,29 @@ func createSwitchAndAddReactors(reactors ...p2p.Reactor) *p2p.Switch {
} }
return sw return sw
} }
func TestPexVectors(t *testing.T) {
addr := tmp2p.NetAddress{
ID: "1",
IP: "127.0.0.1",
Port: 9090,
}
testCases := []struct {
testName string
msg proto.Message
expBytes string
}{
{"PexRequest", &tmp2p.PexRequest{}, "0a00"},
{"PexAddrs", &tmp2p.PexAddrs{Addrs: []tmp2p.NetAddress{addr}}, "12130a110a013112093132372e302e302e31188247"},
}
for _, tc := range testCases {
tc := tc
bz := mustEncode(tc.msg)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

privval/messages.go → privval/msgs.go View File


+ 103
- 0
privval/msgs_test.go View File

@ -0,0 +1,103 @@
package privval
import (
"encoding/hex"
"testing"
"time"
"github.com/gogo/protobuf/proto"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/crypto/tmhash"
privproto "github.com/tendermint/tendermint/proto/tendermint/privval"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"github.com/tendermint/tendermint/types"
)
var stamp = time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC)
func exampleVote() *types.Vote {
return &types.Vote{
Type: tmproto.SignedMsgType(1),
Height: 3,
Round: 2,
Timestamp: stamp,
BlockID: types.BlockID{
Hash: tmhash.Sum([]byte("blockID_hash")),
PartSetHeader: types.PartSetHeader{
Total: 1000000,
Hash: tmhash.Sum([]byte("blockID_part_set_header_hash")),
},
},
ValidatorAddress: crypto.AddressHash([]byte("validator_address")),
ValidatorIndex: 56789,
}
}
func exampleProposal() *types.Proposal {
return &types.Proposal{
Type: tmproto.SignedMsgType(1),
Height: 3,
Round: 2,
Timestamp: stamp,
POLRound: 2,
Signature: []byte("it's a signature"),
BlockID: types.BlockID{
Hash: tmhash.Sum([]byte("blockID_hash")),
PartSetHeader: types.PartSetHeader{
Total: 1000000,
Hash: tmhash.Sum([]byte("blockID_part_set_header_hash")),
},
},
}
}
// nolint:lll // ignore line length for tests
func TestPrivvalVectors(t *testing.T) {
pk := ed25519.GenPrivKeyFromSecret([]byte("it's a secret")).PubKey()
ppk, err := cryptoenc.PubKeyToProto(pk)
require.NoError(t, err)
// Generate a simple vote
vote := exampleVote()
votepb := vote.ToProto()
// Generate a simple proposal
proposal := exampleProposal()
proposalpb := proposal.ToProto()
// Create a Reuseable remote error
remoteError := &privproto.RemoteSignerError{Code: 1, Description: "it's a error"}
testCases := []struct {
testName string
msg proto.Message
expBytes string
}{
{"ping request", &privproto.PingRequest{}, ""},
{"ping response", &privproto.PingResponse{}, ""},
{"pubKey request", &privproto.PubKeyRequest{}, "0a00"},
{"pubKey response", &privproto.PubKeyResponse{PubKey: &ppk, Error: nil}, "12240a220a20556a436f1218d30942efe798420f51dc9b6a311b929c578257457d05c5fcf230"},
{"pubKey response with error", &privproto.PubKeyResponse{PubKey: nil, Error: remoteError}, "121212100801120c697427732061206572726f72"},
{"Vote Request", &privproto.SignVoteRequest{Vote: votepb}, "1a760a74080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0608f49a8ded0532146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb03"},
{"Vote Response", &privproto.SignedVoteResponse{Vote: votepb, Error: nil}, "22760a74080110031802224a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a2a0608f49a8ded0532146af1f4111082efb388211bc72c55bcd61e9ac3d538d5bb03"},
{"Vote Response with error", &privproto.SignedVoteResponse{Vote: nil, Error: remoteError}, "221212100801120c697427732061206572726f72"},
{"Proposal Request", &privproto.SignProposalRequest{Proposal: proposalpb}, "2a700a6e08011003180220022a4a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a320608f49a8ded053a10697427732061207369676e6174757265"},
{"Proposal Response", &privproto.SignedProposalResponse{Proposal: proposalpb, Error: nil}, "32700a6e08011003180220022a4a0a208b01023386c371778ecb6368573e539afc3cc860ec3a2f614e54fe5652f4fc80122608c0843d122072db3d959635dff1bb567bedaa70573392c5159666a3f8caf11e413aac52207a320608f49a8ded053a10697427732061207369676e6174757265"},
{"Proposal Response with error", &privproto.SignedProposalResponse{Proposal: nil, Error: remoteError}, "321212100801120c697427732061206572726f72"},
}
for _, tc := range testCases {
tc := tc
pm := mustWrapMsg(tc.msg)
bz, err := pm.Marshal()
require.NoError(t, err, tc.testName)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

+ 1
- 1
privval/signer_client.go View File

@ -111,7 +111,7 @@ func (sc *SignerClient) SignVote(chainID string, vote *tmproto.Vote) error {
// SignProposal requests a remote signer to sign a proposal // SignProposal requests a remote signer to sign a proposal
func (sc *SignerClient) SignProposal(chainID string, proposal *tmproto.Proposal) error { func (sc *SignerClient) SignProposal(chainID string, proposal *tmproto.Proposal) error {
response, err := sc.endpoint.SendRequest(mustWrapMsg(&privvalproto.SignProposalRequest{Proposal: *proposal}))
response, err := sc.endpoint.SendRequest(mustWrapMsg(&privvalproto.SignProposalRequest{Proposal: proposal}))
if err != nil { if err != nil {
return err return err
} }


+ 2
- 2
privval/signer_requestHandler.go View File

@ -49,12 +49,12 @@ func DefaultValidationRequestHandler(
case *privvalproto.Message_SignProposalRequest: case *privvalproto.Message_SignProposalRequest:
proposal := r.SignProposalRequest.Proposal proposal := r.SignProposalRequest.Proposal
err = privVal.SignProposal(chainID, &proposal)
err = privVal.SignProposal(chainID, proposal)
if err != nil { if err != nil {
res = mustWrapMsg(&privvalproto.SignedProposalResponse{ res = mustWrapMsg(&privvalproto.SignedProposalResponse{
Proposal: nil, Error: &privvalproto.RemoteSignerError{Code: 0, Description: err.Error()}}) Proposal: nil, Error: &privvalproto.RemoteSignerError{Code: 0, Description: err.Error()}})
} else { } else {
res = mustWrapMsg(&privvalproto.SignedProposalResponse{Proposal: &proposal, Error: nil})
res = mustWrapMsg(&privvalproto.SignedProposalResponse{Proposal: proposal, Error: nil})
} }
case *privvalproto.Message_PingRequest: case *privvalproto.Message_PingRequest:
err, res = nil, mustWrapMsg(&privvalproto.PingResponse{}) err, res = nil, mustWrapMsg(&privvalproto.PingResponse{})


+ 66
- 60
proto/tendermint/privval/types.pb.go View File

@ -304,7 +304,7 @@ func (m *SignedVoteResponse) GetError() *RemoteSignerError {
// SignProposalRequest is a request to sign a proposal // SignProposalRequest is a request to sign a proposal
type SignProposalRequest struct { type SignProposalRequest struct {
Proposal types.Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal"`
Proposal *types.Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
} }
func (m *SignProposalRequest) Reset() { *m = SignProposalRequest{} } func (m *SignProposalRequest) Reset() { *m = SignProposalRequest{} }
@ -340,11 +340,11 @@ func (m *SignProposalRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_SignProposalRequest proto.InternalMessageInfo var xxx_messageInfo_SignProposalRequest proto.InternalMessageInfo
func (m *SignProposalRequest) GetProposal() types.Proposal {
func (m *SignProposalRequest) GetProposal() *types.Proposal {
if m != nil { if m != nil {
return m.Proposal return m.Proposal
} }
return types.Proposal{}
return nil
} }
// SignedProposalResponse is response containing a signed proposal or an error // SignedProposalResponse is response containing a signed proposal or an error
@ -654,53 +654,52 @@ func init() {
func init() { proto.RegisterFile("tendermint/privval/types.proto", fileDescriptor_cb4e437a5328cf9c) } func init() { proto.RegisterFile("tendermint/privval/types.proto", fileDescriptor_cb4e437a5328cf9c) }
var fileDescriptor_cb4e437a5328cf9c = []byte{ var fileDescriptor_cb4e437a5328cf9c = []byte{
// 721 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x4e, 0xdb, 0x4a,
0x14, 0xc6, 0x6d, 0x48, 0x02, 0xf7, 0x84, 0xfc, 0x61, 0xe0, 0x72, 0x73, 0x23, 0xae, 0xc9, 0x75,
0xd5, 0x16, 0xb1, 0x48, 0x24, 0xaa, 0x56, 0xaa, 0xda, 0x2e, 0x0a, 0x58, 0x4d, 0x84, 0x70, 0xd2,
0x49, 0x28, 0x15, 0x52, 0x15, 0x91, 0x64, 0xea, 0x5a, 0x10, 0xcf, 0xd4, 0xe3, 0x20, 0x65, 0xd1,
0x5d, 0xb7, 0x95, 0xfa, 0x18, 0x5d, 0xf7, 0x29, 0x58, 0xb2, 0xec, 0xaa, 0xaa, 0xe0, 0x45, 0x2a,
0x8f, 0x27, 0xb6, 0xc9, 0x9f, 0x4a, 0x88, 0x9d, 0xe7, 0x7c, 0x33, 0xbf, 0xf3, 0x1d, 0xcf, 0x27,
0x0d, 0x68, 0x1e, 0x71, 0x7a, 0xc4, 0xed, 0xdb, 0x8e, 0x57, 0x61, 0xae, 0x7d, 0x7e, 0x7e, 0x72,
0x56, 0xf1, 0x86, 0x8c, 0xf0, 0x32, 0x73, 0xa9, 0x47, 0x11, 0x8a, 0xf4, 0xb2, 0xd4, 0x8b, 0xab,
0x16, 0xb5, 0xa8, 0x90, 0x2b, 0xfe, 0x57, 0xb0, 0xb3, 0xb8, 0x1e, 0x23, 0x75, 0xdd, 0x21, 0xf3,
0x68, 0xe5, 0x94, 0x0c, 0xf9, 0x14, 0x55, 0xf0, 0xe3, 0x5d, 0xf4, 0x1a, 0x2c, 0x63, 0xd2, 0xa7,
0x1e, 0x69, 0xda, 0x96, 0x43, 0x5c, 0xc3, 0x75, 0xa9, 0x8b, 0x10, 0x24, 0xba, 0xb4, 0x47, 0x0a,
0x6a, 0x49, 0xdd, 0x4c, 0x62, 0xf1, 0x8d, 0x4a, 0x90, 0xee, 0x11, 0xde, 0x75, 0x6d, 0xe6, 0xd9,
0xd4, 0x29, 0xcc, 0x95, 0xd4, 0xcd, 0xbf, 0x70, 0xbc, 0xa4, 0xe7, 0x20, 0xd3, 0x18, 0x74, 0xf6,
0xc9, 0x10, 0x93, 0x8f, 0x03, 0xc2, 0x3d, 0xfd, 0xb3, 0x0a, 0xd9, 0x51, 0x85, 0x33, 0xea, 0x70,
0x82, 0x1e, 0xc3, 0x02, 0x1b, 0x74, 0xda, 0xa7, 0x64, 0x28, 0xe0, 0xe9, 0xed, 0xf5, 0x72, 0x6c,
0xcc, 0xc0, 0x7c, 0xb9, 0x31, 0xe8, 0x9c, 0xd9, 0x5d, 0xff, 0x58, 0x8a, 0x89, 0xe3, 0xe8, 0x19,
0x24, 0x89, 0xef, 0x4c, 0xb4, 0x4d, 0x6f, 0xdf, 0x2f, 0x4f, 0xfe, 0x9b, 0xf2, 0xc4, 0x18, 0x38,
0x38, 0xa3, 0xbf, 0x80, 0x9c, 0x5f, 0x7d, 0x43, 0x3d, 0x22, 0x9d, 0xa1, 0x2d, 0x48, 0x9c, 0x53,
0x8f, 0x48, 0x0f, 0x6b, 0x71, 0x5c, 0xf0, 0x73, 0xc4, 0x66, 0xb1, 0x47, 0xff, 0x04, 0x48, 0x40,
0x7b, 0x01, 0x40, 0x0e, 0x72, 0x0b, 0xc2, 0xdd, 0xdc, 0x37, 0x61, 0xc5, 0xaf, 0x36, 0x5c, 0xca,
0x28, 0x3f, 0x39, 0x1b, 0x4d, 0xf0, 0x1c, 0x16, 0x99, 0x2c, 0x49, 0x0f, 0xc5, 0x49, 0x0f, 0xa3,
0x43, 0x3b, 0x89, 0x8b, 0x9f, 0x1b, 0x0a, 0x0e, 0x4f, 0xe8, 0x5f, 0x54, 0x58, 0x0b, 0x86, 0x8a,
0xb8, 0x72, 0xb0, 0x27, 0xb7, 0x01, 0x47, 0xc8, 0xbb, 0x0d, 0x99, 0x81, 0x74, 0xc3, 0x76, 0xac,
0x51, 0x70, 0xb2, 0xb0, 0x14, 0x2c, 0x03, 0x4f, 0xfa, 0xf7, 0x24, 0x2c, 0x1c, 0x10, 0xce, 0x4f,
0x2c, 0x82, 0xf6, 0x21, 0x27, 0x13, 0xd4, 0x76, 0x83, 0xed, 0xd2, 0xe6, 0xff, 0xd3, 0x3a, 0xde,
0x08, 0x64, 0x55, 0xc1, 0x19, 0x16, 0x2f, 0x20, 0x13, 0xf2, 0x11, 0x2c, 0x68, 0x26, 0xfd, 0xeb,
0x7f, 0xa2, 0x05, 0x3b, 0xab, 0x0a, 0xce, 0xb2, 0x9b, 0xf1, 0x7e, 0x0d, 0xcb, 0xdc, 0xb6, 0x9c,
0xb6, 0x7f, 0xed, 0xa1, 0xbd, 0x79, 0x01, 0xbc, 0x37, 0x0d, 0x38, 0x96, 0xcb, 0xaa, 0x82, 0x73,
0x7c, 0x2c, 0xaa, 0xc7, 0xb0, 0xca, 0xc5, 0x4d, 0x8d, 0xa0, 0xd2, 0x66, 0x42, 0x50, 0x1f, 0xcc,
0xa2, 0xde, 0x8c, 0x6b, 0x55, 0xc1, 0x88, 0x4f, 0x86, 0xf8, 0x1d, 0xfc, 0x2d, 0xec, 0x8e, 0x2e,
0x31, 0xb4, 0x9c, 0x14, 0xf0, 0x87, 0xb3, 0xe0, 0x63, 0x61, 0xac, 0x2a, 0x78, 0x85, 0x4f, 0xc9,
0xe8, 0x7b, 0x28, 0x48, 0xeb, 0xb1, 0x06, 0xd2, 0x7e, 0x4a, 0x74, 0xd8, 0x9a, 0x6d, 0x7f, 0x3c,
0x98, 0x55, 0x05, 0xaf, 0xf1, 0xe9, 0x91, 0xdd, 0x83, 0x25, 0x66, 0x3b, 0x56, 0xe8, 0x7e, 0x41,
0xb0, 0x37, 0xa6, 0xde, 0x60, 0x94, 0xb2, 0xaa, 0x82, 0xd3, 0x2c, 0x5a, 0xa2, 0x57, 0x90, 0x91,
0x14, 0x69, 0x71, 0x51, 0x60, 0x4a, 0xb3, 0x31, 0xa1, 0xb1, 0x25, 0x16, 0x5b, 0xef, 0x24, 0x61,
0x9e, 0x0f, 0xfa, 0x5b, 0xdf, 0x54, 0x48, 0x89, 0x90, 0x73, 0x84, 0x20, 0x6b, 0x60, 0x5c, 0xc7,
0xcd, 0xf6, 0xa1, 0xb9, 0x6f, 0xd6, 0x8f, 0xcc, 0xbc, 0x82, 0x34, 0x28, 0x86, 0x35, 0xe3, 0x6d,
0xc3, 0xd8, 0x6d, 0x19, 0x7b, 0x6d, 0x6c, 0x34, 0x1b, 0x75, 0xb3, 0x69, 0xe4, 0x55, 0x54, 0x80,
0x55, 0xa9, 0x9b, 0xf5, 0xf6, 0x6e, 0xdd, 0x34, 0x8d, 0xdd, 0x56, 0xad, 0x6e, 0xe6, 0xe7, 0xd0,
0x7f, 0xf0, 0xaf, 0x54, 0xa2, 0x72, 0xbb, 0x55, 0x3b, 0x30, 0xea, 0x87, 0xad, 0xfc, 0x3c, 0xfa,
0x07, 0x56, 0xa4, 0x8c, 0x8d, 0x97, 0x7b, 0xa1, 0x90, 0x88, 0x11, 0x8f, 0x70, 0xad, 0x65, 0x84,
0x4a, 0x72, 0xa7, 0x79, 0x71, 0xa5, 0xa9, 0x97, 0x57, 0x9a, 0xfa, 0xeb, 0x4a, 0x53, 0xbf, 0x5e,
0x6b, 0xca, 0xe5, 0xb5, 0xa6, 0xfc, 0xb8, 0xd6, 0x94, 0xe3, 0xa7, 0x96, 0xed, 0x7d, 0x18, 0x74,
0xca, 0x5d, 0xda, 0xaf, 0xc4, 0xdf, 0x91, 0xf8, 0xd3, 0xe5, 0xbf, 0x46, 0x93, 0x6f, 0x59, 0x27,
0x25, 0x94, 0x47, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x98, 0xd1, 0x49, 0xc8, 0xe8, 0x06, 0x00,
0x00,
// 711 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x6e, 0xd3, 0x4a,
0x14, 0xc6, 0xed, 0x36, 0x49, 0x7b, 0x4f, 0x9a, 0x3f, 0x9d, 0xf6, 0xf6, 0xe6, 0x46, 0xbd, 0xbe,
0xc1, 0x08, 0xa8, 0xba, 0x48, 0xa4, 0x22, 0x90, 0x10, 0x62, 0x41, 0x5b, 0x8b, 0x44, 0x55, 0xed,
0x30, 0x49, 0x29, 0xaa, 0x84, 0xac, 0x26, 0x19, 0x8c, 0xd5, 0xc6, 0x33, 0x78, 0x9c, 0x4a, 0x59,
0xb0, 0x63, 0x8b, 0xc4, 0x63, 0xb0, 0xe6, 0x29, 0x58, 0x76, 0xc9, 0x12, 0xb5, 0x2f, 0x82, 0x3c,
0x9e, 0x38, 0x6e, 0xfe, 0x20, 0x41, 0x77, 0x9e, 0xf3, 0xcd, 0xfc, 0xce, 0x77, 0x3c, 0x9f, 0x34,
0xa0, 0x05, 0xc4, 0xeb, 0x11, 0xbf, 0xef, 0x7a, 0x41, 0x8d, 0xf9, 0xee, 0xc5, 0xc5, 0xe9, 0x79,
0x2d, 0x18, 0x32, 0xc2, 0xab, 0xcc, 0xa7, 0x01, 0x45, 0x68, 0xac, 0x57, 0xa5, 0x5e, 0x5e, 0x77,
0xa8, 0x43, 0x85, 0x5c, 0x0b, 0xbf, 0xa2, 0x9d, 0xe5, 0xcd, 0x04, 0xa9, 0xeb, 0x0f, 0x59, 0x40,
0x6b, 0x67, 0x64, 0xc8, 0x67, 0xa8, 0x82, 0x9f, 0xec, 0xa2, 0x37, 0x60, 0x15, 0x93, 0x3e, 0x0d,
0x48, 0xcb, 0x75, 0x3c, 0xe2, 0x1b, 0xbe, 0x4f, 0x7d, 0x84, 0x20, 0xd5, 0xa5, 0x3d, 0x52, 0x52,
0x2b, 0xea, 0x56, 0x1a, 0x8b, 0x6f, 0x54, 0x81, 0x6c, 0x8f, 0xf0, 0xae, 0xef, 0xb2, 0xc0, 0xa5,
0x5e, 0x69, 0xa1, 0xa2, 0x6e, 0xfd, 0x85, 0x93, 0x25, 0xbd, 0x00, 0xb9, 0xe6, 0xa0, 0x73, 0x40,
0x86, 0x98, 0xbc, 0x1f, 0x10, 0x1e, 0xe8, 0x1f, 0x55, 0xc8, 0x8f, 0x2a, 0x9c, 0x51, 0x8f, 0x13,
0xf4, 0x08, 0x96, 0xd8, 0xa0, 0x63, 0x9f, 0x91, 0xa1, 0x80, 0x67, 0x77, 0x36, 0xab, 0x89, 0x31,
0x23, 0xf3, 0xd5, 0xe6, 0xa0, 0x73, 0xee, 0x76, 0xc3, 0x63, 0x19, 0x26, 0x8e, 0xa3, 0xa7, 0x90,
0x26, 0xa1, 0x33, 0xd1, 0x36, 0xbb, 0x73, 0xaf, 0x3a, 0xfd, 0x6f, 0xaa, 0x53, 0x63, 0xe0, 0xe8,
0x8c, 0xfe, 0x0c, 0x0a, 0x61, 0xf5, 0x15, 0x0d, 0x88, 0x74, 0x86, 0xb6, 0x21, 0x75, 0x41, 0x03,
0x22, 0x3d, 0x6c, 0x24, 0x71, 0xd1, 0xcf, 0x11, 0x9b, 0xc5, 0x1e, 0xfd, 0x03, 0x20, 0x01, 0xed,
0x45, 0x00, 0x39, 0xc8, 0x6f, 0x10, 0x6e, 0xe7, 0xfe, 0x10, 0xd6, 0xc2, 0x6a, 0xd3, 0xa7, 0x8c,
0xf2, 0xd3, 0xf3, 0xd1, 0x04, 0x8f, 0x61, 0x99, 0xc9, 0x92, 0xf4, 0x50, 0x9e, 0xf6, 0x10, 0x1f,
0x8a, 0xf7, 0xea, 0x9f, 0x54, 0xd8, 0x88, 0xc6, 0x19, 0x13, 0xe5, 0x48, 0x7f, 0x88, 0xbc, 0xdd,
0x78, 0x39, 0xc8, 0x36, 0x5d, 0xcf, 0x19, 0x45, 0x26, 0x0f, 0x2b, 0xd1, 0x32, 0xf2, 0xa4, 0x7f,
0x4d, 0xc3, 0xd2, 0x21, 0xe1, 0xfc, 0xd4, 0x21, 0xe8, 0x00, 0x0a, 0x32, 0x3b, 0xb6, 0x1f, 0x6d,
0x97, 0x36, 0xef, 0xcc, 0xea, 0x78, 0x23, 0x8a, 0x75, 0x05, 0xe7, 0x58, 0xb2, 0x80, 0x4c, 0x28,
0x8e, 0x61, 0x51, 0x33, 0xe9, 0x5f, 0xff, 0x15, 0x2d, 0xda, 0x59, 0x57, 0x70, 0x9e, 0xdd, 0x0c,
0xf6, 0x4b, 0x58, 0xe5, 0xae, 0xe3, 0xd9, 0xe1, 0x85, 0xc7, 0xf6, 0x16, 0x05, 0xf0, 0xee, 0x2c,
0xe0, 0x44, 0x22, 0xeb, 0x0a, 0x2e, 0xf0, 0x89, 0x90, 0x9e, 0xc0, 0x3a, 0x17, 0x37, 0x35, 0x82,
0x4a, 0x9b, 0x29, 0x41, 0xbd, 0x3f, 0x8f, 0x7a, 0x33, 0xa8, 0x75, 0x05, 0x23, 0x3e, 0x1d, 0xdf,
0x37, 0xf0, 0xb7, 0xb0, 0x3b, 0xba, 0xc4, 0xd8, 0x72, 0x5a, 0xc0, 0x1f, 0xcc, 0x83, 0x4f, 0xc4,
0xb0, 0xae, 0xe0, 0x35, 0x3e, 0x23, 0x9d, 0x6f, 0xa1, 0x24, 0xad, 0x27, 0x1a, 0x48, 0xfb, 0x19,
0xd1, 0x61, 0x7b, 0xbe, 0xfd, 0xc9, 0x60, 0xd6, 0x15, 0xbc, 0xc1, 0x67, 0x47, 0x76, 0x1f, 0x56,
0x98, 0xeb, 0x39, 0xb1, 0xfb, 0x25, 0xc1, 0xfe, 0x7f, 0xe6, 0x0d, 0x8e, 0x53, 0x56, 0x57, 0x70,
0x96, 0x8d, 0x97, 0xe8, 0x05, 0xe4, 0x24, 0x45, 0x5a, 0x5c, 0x16, 0x98, 0xca, 0x7c, 0x4c, 0x6c,
0x6c, 0x85, 0x25, 0xd6, 0xbb, 0x69, 0x58, 0xe4, 0x83, 0xfe, 0xf6, 0x17, 0x15, 0x32, 0x22, 0xe4,
0x1c, 0x21, 0xc8, 0x1b, 0x18, 0x5b, 0xb8, 0x65, 0x1f, 0x99, 0x07, 0xa6, 0x75, 0x6c, 0x16, 0x15,
0xa4, 0x41, 0x39, 0xae, 0x19, 0xaf, 0x9b, 0xc6, 0x5e, 0xdb, 0xd8, 0xb7, 0xb1, 0xd1, 0x6a, 0x5a,
0x66, 0xcb, 0x28, 0xaa, 0xa8, 0x04, 0xeb, 0x52, 0x37, 0x2d, 0x7b, 0xcf, 0x32, 0x4d, 0x63, 0xaf,
0xdd, 0xb0, 0xcc, 0xe2, 0x02, 0xfa, 0x0f, 0xfe, 0x95, 0xca, 0xb8, 0x6c, 0xb7, 0x1b, 0x87, 0x86,
0x75, 0xd4, 0x2e, 0x2e, 0xa2, 0x7f, 0x60, 0x4d, 0xca, 0xd8, 0x78, 0xbe, 0x1f, 0x0b, 0xa9, 0x04,
0xf1, 0x18, 0x37, 0xda, 0x46, 0xac, 0xa4, 0x77, 0x5b, 0xdf, 0xae, 0x34, 0xf5, 0xf2, 0x4a, 0x53,
0x7f, 0x5c, 0x69, 0xea, 0xe7, 0x6b, 0x4d, 0xb9, 0xbc, 0xd6, 0x94, 0xef, 0xd7, 0x9a, 0x72, 0xf2,
0xc4, 0x71, 0x83, 0x77, 0x83, 0x4e, 0xb5, 0x4b, 0xfb, 0xb5, 0xe4, 0x0b, 0x92, 0x7c, 0xb4, 0xc2,
0x77, 0x68, 0xfa, 0x15, 0xeb, 0x64, 0x84, 0xf2, 0xf0, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbe,
0xc8, 0xae, 0x83, 0xe2, 0x06, 0x00, 0x00,
} }
func (m *RemoteSignerError) Marshal() (dAtA []byte, err error) { func (m *RemoteSignerError) Marshal() (dAtA []byte, err error) {
@ -910,16 +909,18 @@ func (m *SignProposalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
{
size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
if m.Proposal != nil {
{
size, err := m.Proposal.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
} }
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
i--
dAtA[i] = 0xa
} }
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -1305,8 +1306,10 @@ func (m *SignProposalRequest) Size() (n int) {
} }
var l int var l int
_ = l _ = l
l = m.Proposal.Size()
n += 1 + l + sovTypes(uint64(l))
if m.Proposal != nil {
l = m.Proposal.Size()
n += 1 + l + sovTypes(uint64(l))
}
return n return n
} }
@ -2014,6 +2017,9 @@ func (m *SignProposalRequest) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if m.Proposal == nil {
m.Proposal = &types.Proposal{}
}
if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }


+ 1
- 2
proto/tendermint/privval/types.proto View File

@ -43,7 +43,7 @@ message SignedVoteResponse {
// SignProposalRequest is a request to sign a proposal // SignProposalRequest is a request to sign a proposal
message SignProposalRequest { message SignProposalRequest {
tendermint.types.Proposal proposal = 1 [(gogoproto.nullable) = false];
tendermint.types.Proposal proposal = 1;
} }
// SignedProposalResponse is response containing a signed proposal or an error // SignedProposalResponse is response containing a signed proposal or an error
@ -70,4 +70,3 @@ message Message {
PingResponse ping_response = 8; PingResponse ping_response = 8;
} }
} }

+ 1
- 1
statesync/messages.go View File

@ -31,7 +31,7 @@ func mustEncodeMsg(pb proto.Message) []byte {
default: default:
panic(fmt.Errorf("unknown message type %T", pb)) panic(fmt.Errorf("unknown message type %T", pb))
} }
bz, err := proto.Marshal(&msg)
bz, err := msg.Marshal()
if err != nil { if err != nil {
panic(fmt.Errorf("unable to marshal %T: %w", pb, err)) panic(fmt.Errorf("unable to marshal %T: %w", pb, err))
} }


+ 24
- 0
statesync/messages_test.go View File

@ -1,6 +1,7 @@
package statesync package statesync
import ( import (
"encoding/hex"
"testing" "testing"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
@ -81,3 +82,26 @@ func TestValidateMsg(t *testing.T) {
}) })
} }
} }
//nolint:lll // ignore line length
func TestStateSyncVectors(t *testing.T) {
testCases := []struct {
testName string
msg proto.Message
expBytes string
}{
{"SnapshotsRequest", &ssproto.SnapshotsRequest{}, "0a00"},
{"SnapshotsResponse", &ssproto.SnapshotsResponse{Height: 1, Format: 2, Chunks: 3, Hash: []byte("chuck hash"), Metadata: []byte("snapshot metadata")}, "1225080110021803220a636875636b20686173682a11736e617073686f74206d65746164617461"},
{"ChunkRequest", &ssproto.ChunkRequest{Height: 1, Format: 2, Index: 3}, "1a06080110021803"},
{"ChunkResponse", &ssproto.ChunkResponse{Height: 1, Format: 2, Index: 3, Chunk: []byte("it's a chunk")}, "2214080110021803220c697427732061206368756e6b"},
}
for _, tc := range testCases {
tc := tc
bz := mustEncodeMsg(tc.msg)
require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
}
}

Loading…
Cancel
Save