zolfa
/
tendermint
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 221 Wiki Activity
Browse Source

proto: move keys to oneof (#4983)

pull/4997/head
Marko 5 years ago
committed by GitHub
parent
18d333c392
commit
31a361d119
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 367 additions and 584 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -2
      abci/example/kvstore/kvstore_test.go
  2. +17
    -10
      abci/example/kvstore/persistent_kvstore.go
  3. +14
    -6
      abci/types/pubkey.go
  4. +177
    -401
      abci/types/types.pb.go
  5. +3
    -7
      abci/types/types.proto
  6. +1
    -2
      abci/types/util.go
  7. +13
    -6
      consensus/reactor_test.go
  8. +9
    -4
      consensus/replay_test.go
  9. +2
    -0
      crypto/crypto.go
  10. +10
    -0
      crypto/ed25519/ed25519.go
  11. +3
    -0
      crypto/encoding/amino/encode_test.go
  12. +12
    -1
      crypto/secp256k1/secp256k1.go
  13. +4
    -0
      crypto/sr25519/privkey.go
  14. +9
    -1
      crypto/sr25519/pubkey.go
  15. +1
    -0
      p2p/conn/secret_connection_test.go
  16. +6
    -13
      proto/crypto/keys/types.pb.go
  17. +0
    -5
      proto/crypto/keys/types.proto
  18. +1
    -1
      proto/crypto/merkle/types.pb.go
  19. +7
    -2
      rpc/client/evidence_test.go
  20. +1
    -0
      rpc/client/helpers.go
  21. +3
    -0
      rpc/client/http/http.go
  22. +0
    -1
      rpc/client/rpc_test.go
  23. +8
    -3
      state/execution.go
  24. +24
    -38
      state/execution_test.go
  25. +18
    -7
      state/state_test.go
  26. +11
    -58
      types/protobuf.go
  27. +12
    -16
      types/protobuf_test.go

+ 1
- 2
abci/example/kvstore/kvstore_test.go View File

@ -1,7 +1,6 @@
package kvstore
import (
"bytes"
"fmt"
"io/ioutil"
"sort"
@ -220,7 +219,7 @@ func valsEqual(t *testing.T, vals1, vals2 []types.ValidatorUpdate) {
sort.Sort(types.ValidatorUpdates(vals2))
for i, v1 := range vals1 {
v2 := vals2[i]
if !bytes.Equal(v1.PubKey.Data, v2.PubKey.Data) ||
if !v1.PubKey.Equal(v2.PubKey) ||
v1.Power != v2.Power {
t.Fatalf("vals dont match at index %d. got %X/%d , expected %X/%d", i, v2.PubKey, v2.Power, v1.PubKey, v1.Power)
}


+ 17
- 10
abci/example/kvstore/persistent_kvstore.go View File

@ -11,8 +11,9 @@ import (
"github.com/tendermint/tendermint/abci/example/code"
"github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/libs/log"
pc "github.com/tendermint/tendermint/proto/crypto/keys"
tmtypes "github.com/tendermint/tendermint/types"
)
@ -30,7 +31,7 @@ type PersistentKVStoreApplication struct {
// validator set
ValUpdates []types.ValidatorUpdate
valAddrToPubKeyMap map[string]types.PubKey
valAddrToPubKeyMap map[string]pc.PublicKey
logger log.Logger
}
@ -46,7 +47,7 @@ func NewPersistentKVStoreApplication(dbDir string) *PersistentKVStoreApplication
return &PersistentKVStoreApplication{
app: &Application{state: state},
valAddrToPubKeyMap: make(map[string]types.PubKey),
valAddrToPubKeyMap: make(map[string]pc.PublicKey),
logger: log.NewNopLogger(),
}
}
@ -136,6 +137,7 @@ func (app *PersistentKVStoreApplication) BeginBlock(req types.RequestBeginBlock)
})
}
}
return types.ResponseBeginBlock{}
}
@ -185,8 +187,12 @@ func (app *PersistentKVStoreApplication) Validators() (validators []types.Valida
return
}
func MakeValSetChangeTx(pubkey types.PubKey, power int64) []byte {
pubStr := base64.StdEncoding.EncodeToString(pubkey.Data)
func MakeValSetChangeTx(pubkey pc.PublicKey, power int64) []byte {
pk, err := cryptoenc.PubKeyFromProto(pubkey)
if err != nil {
panic(err)
}
pubStr := base64.StdEncoding.EncodeToString(pk.Bytes())
return []byte(fmt.Sprintf("val:%s!%d", pubStr, power))
}
@ -230,10 +236,11 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon
// add, update, or remove a validator
func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate) types.ResponseDeliverTx {
key := []byte("val:" + string(v.PubKey.Data))
pubkey := make(ed25519.PubKey, ed25519.PubKeySize)
copy(pubkey, v.PubKey.Data)
key := []byte("val:" + string(v.PubKey.GetEd25519()))
pubkey, err := cryptoenc.PubKeyFromProto(v.PubKey)
if err != nil {
panic(fmt.Errorf("can't decode public key: %w", err))
}
if v.Power == 0 {
// remove validator
@ -242,7 +249,7 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
panic(err)
}
if !hasKey {
pubStr := base64.StdEncoding.EncodeToString(v.PubKey.Data)
pubStr := base64.StdEncoding.EncodeToString(pubkey.Bytes())
return types.ResponseDeliverTx{
Code: code.CodeTypeUnauthorized,
Log: fmt.Sprintf("Cannot remove non-existent validator %s", pubStr)}


+ 14
- 6
abci/types/pubkey.go View File

@ -1,16 +1,24 @@
package types
import (
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
)
const (
PubKeyEd25519 = "ed25519"
)
func Ed25519ValidatorUpdate(pubkey []byte, power int64) ValidatorUpdate {
func Ed25519ValidatorUpdate(pk []byte, power int64) ValidatorUpdate {
pke := ed25519.PubKey(pk)
pkp, err := cryptoenc.PubKeyToProto(pke)
if err != nil {
panic(err)
}
return ValidatorUpdate{
// Address:
PubKey: PubKey{
Type: PubKeyEd25519,
Data: pubkey,
},
Power: power,
PubKey: pkp,
Power: power,
}
}

+ 177
- 401
abci/types/types.pb.go View File

@ -10,6 +10,7 @@ import (
proto "github.com/gogo/protobuf/proto"
github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
_ "github.com/golang/protobuf/ptypes/timestamp"
keys "github.com/tendermint/tendermint/proto/crypto/keys"
merkle "github.com/tendermint/tendermint/proto/crypto/merkle"
types "github.com/tendermint/tendermint/proto/types"
grpc "google.golang.org/grpc"
@ -2926,8 +2927,8 @@ func (m *Validator) GetPower() int64 {
// ValidatorUpdate
type ValidatorUpdate struct {
PubKey PubKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"`
Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
PubKey keys.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"`
Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
}
func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} }
@ -2963,11 +2964,11 @@ func (m *ValidatorUpdate) XXX_DiscardUnknown() {
var xxx_messageInfo_ValidatorUpdate proto.InternalMessageInfo
func (m *ValidatorUpdate) GetPubKey() PubKey {
func (m *ValidatorUpdate) GetPubKey() keys.PublicKey {
if m != nil {
return m.PubKey
}
return PubKey{}
return keys.PublicKey{}
}
func (m *ValidatorUpdate) GetPower() int64 {
@ -3030,58 +3031,6 @@ func (m *VoteInfo) GetSignedLastBlock() bool {
return false
}
type PubKey struct {
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *PubKey) Reset() { *m = PubKey{} }
func (m *PubKey) String() string { return proto.CompactTextString(m) }
func (*PubKey) ProtoMessage() {}
func (*PubKey) Descriptor() ([]byte, []int) {
return fileDescriptor_9f1eaa49c51fa1ac, []int{44}
}
func (m *PubKey) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *PubKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_PubKey.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *PubKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_PubKey.Merge(m, src)
}
func (m *PubKey) XXX_Size() int {
return m.Size()
}
func (m *PubKey) XXX_DiscardUnknown() {
xxx_messageInfo_PubKey.DiscardUnknown(m)
}
var xxx_messageInfo_PubKey proto.InternalMessageInfo
func (m *PubKey) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *PubKey) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type Evidence struct {
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Validator Validator `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator"`
@ -3094,7 +3043,7 @@ func (m *Evidence) Reset() { *m = Evidence{} }
func (m *Evidence) String() string { return proto.CompactTextString(m) }
func (*Evidence) ProtoMessage() {}
func (*Evidence) Descriptor() ([]byte, []int) {
return fileDescriptor_9f1eaa49c51fa1ac, []int{45}
return fileDescriptor_9f1eaa49c51fa1ac, []int{44}
}
func (m *Evidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -3170,7 +3119,7 @@ func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (*Snapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_9f1eaa49c51fa1ac, []int{46}
return fileDescriptor_9f1eaa49c51fa1ac, []int{45}
}
func (m *Snapshot) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -3282,7 +3231,6 @@ func init() {
proto.RegisterType((*Validator)(nil), "tendermint.abci.types.Validator")
proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.types.ValidatorUpdate")
proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.types.VoteInfo")
proto.RegisterType((*PubKey)(nil), "tendermint.abci.types.PubKey")
proto.RegisterType((*Evidence)(nil), "tendermint.abci.types.Evidence")
proto.RegisterType((*Snapshot)(nil), "tendermint.abci.types.Snapshot")
}
@ -3290,176 +3238,177 @@ func init() {
func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) }
var fileDescriptor_9f1eaa49c51fa1ac = []byte{
// 2699 bytes of a gzipped FileDescriptorProto
// 2706 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x6f, 0x1b, 0xc9,
0xf1, 0xe7, 0x90, 0x14, 0x1f, 0x45, 0x91, 0xa2, 0xda, 0x5e, 0x2f, 0x97, 0xff, 0x5d, 0xc9, 0x18,
0xaf, 0x1f, 0xfb, 0xf8, 0x4b, 0xbb, 0x5a, 0x20, 0xb0, 0x63, 0x27, 0x81, 0x28, 0xcb, 0xa1, 0xe2,
0x87, 0xe4, 0x91, 0xe4, 0x78, 0x13, 0x60, 0x27, 0xcd, 0x99, 0x16, 0x39, 0x6b, 0x72, 0x66, 0x76,
0xa6, 0x29, 0x8b, 0x41, 0x0e, 0x41, 0x10, 0x20, 0xc8, 0xcd, 0xb9, 0xe4, 0x96, 0xef, 0x90, 0x43,
0x80, 0xcd, 0x17, 0x08, 0xb0, 0xc7, 0x3d, 0x05, 0x39, 0x6d, 0x02, 0x3b, 0xa7, 0xe4, 0x4b, 0x04,
0xfd, 0x98, 0x17, 0xc5, 0xc7, 0x70, 0xe3, 0x5b, 0x2e, 0x44, 0x57, 0x4f, 0x55, 0x75, 0x77, 0x75,
0x77, 0xd5, 0xaf, 0xaa, 0x09, 0x97, 0x70, 0xc7, 0xb0, 0x36, 0xe9, 0xc8, 0x25, 0xbe, 0xf8, 0xdd,
0x70, 0x3d, 0x87, 0x3a, 0xe8, 0x0d, 0x4a, 0x6c, 0x93, 0x78, 0x03, 0xcb, 0xa6, 0x1b, 0x8c, 0x65,
0x83, 0x7f, 0x6c, 0xae, 0xf3, 0xaf, 0x9b, 0x86, 0x37, 0x72, 0xa9, 0xb3, 0x39, 0x20, 0xde, 0xb3,
0x3e, 0x89, 0xcb, 0x35, 0xdf, 0x14, 0x0c, 0xe7, 0x14, 0x36, 0x1b, 0xf1, 0x0f, 0x2e, 0xf6, 0xf0,
0x20, 0xf8, 0xb2, 0xde, 0x75, 0x9c, 0x6e, 0x9f, 0x6c, 0x72, 0xaa, 0x33, 0x3c, 0xd9, 0xa4, 0xd6,
0x80, 0xf8, 0x14, 0x0f, 0x5c, 0xc9, 0x70, 0x8d, 0xf6, 0x2c, 0xcf, 0xd4, 0x5d, 0xec, 0xd1, 0x91,
0xe0, 0xda, 0xec, 0x3a, 0x5d, 0x27, 0x6a, 0x09, 0x3e, 0xf5, 0xdf, 0x25, 0x28, 0x6a, 0xe4, 0x8b,
0x21, 0xf1, 0x29, 0xba, 0x09, 0x79, 0x62, 0xf4, 0x9c, 0x46, 0xf6, 0xb2, 0x72, 0xa3, 0xb2, 0xa5,
0x6e, 0x4c, 0x5c, 0xce, 0x86, 0xe4, 0xde, 0x35, 0x7a, 0x4e, 0x3b, 0xa3, 0x71, 0x09, 0x74, 0x1b,
0x96, 0x4e, 0xfa, 0x43, 0xbf, 0xd7, 0xc8, 0x71, 0xd1, 0x2b, 0xb3, 0x45, 0xef, 0x31, 0xd6, 0x76,
0x46, 0x13, 0x32, 0x6c, 0x58, 0xcb, 0x3e, 0x71, 0x1a, 0xf9, 0x34, 0xc3, 0xee, 0xd9, 0x27, 0x7c,
0x58, 0x26, 0x81, 0xda, 0x00, 0x3e, 0xa1, 0xba, 0xe3, 0x52, 0xcb, 0xb1, 0x1b, 0x4b, 0x5c, 0xfe,
0xfa, 0x6c, 0xf9, 0x43, 0x42, 0xf7, 0x39, 0x7b, 0x3b, 0xa3, 0x95, 0xfd, 0x80, 0x60, 0x9a, 0x2c,
0xdb, 0xa2, 0xba, 0xd1, 0xc3, 0x96, 0xdd, 0x28, 0xa4, 0xd1, 0xb4, 0x67, 0x5b, 0x74, 0x87, 0xb1,
0x33, 0x4d, 0x56, 0x40, 0x30, 0x53, 0x7c, 0x31, 0x24, 0xde, 0xa8, 0x51, 0x4c, 0x63, 0x8a, 0xc7,
0x8c, 0x95, 0x99, 0x82, 0xcb, 0xa0, 0xfb, 0x50, 0xe9, 0x90, 0xae, 0x65, 0xeb, 0x9d, 0xbe, 0x63,
0x3c, 0x6b, 0x94, 0xb8, 0x8a, 0x1b, 0xb3, 0x55, 0xb4, 0x98, 0x40, 0x8b, 0xf1, 0xb7, 0x33, 0x1a,
0x74, 0x42, 0x0a, 0xb5, 0xa0, 0x64, 0xf4, 0x88, 0xf1, 0x4c, 0xa7, 0x67, 0x8d, 0x32, 0xd7, 0x74,
0x75, 0xb6, 0xa6, 0x1d, 0xc6, 0x7d, 0x74, 0xd6, 0xce, 0x68, 0x45, 0x43, 0x34, 0x99, 0x5d, 0x4c,
0xd2, 0xb7, 0x4e, 0x89, 0xc7, 0xb4, 0x5c, 0x48, 0x63, 0x97, 0xbb, 0x82, 0x9f, 0xeb, 0x29, 0x9b,
0x01, 0x81, 0x76, 0xa1, 0x4c, 0x6c, 0x53, 0x2e, 0xac, 0xc2, 0x15, 0x5d, 0x9b, 0x73, 0xc2, 0x6c,
0x33, 0x58, 0x56, 0x89, 0xc8, 0x36, 0xfa, 0x3e, 0x14, 0x0c, 0x67, 0x30, 0xb0, 0x68, 0x63, 0x99,
0xeb, 0x78, 0x77, 0xce, 0x92, 0x38, 0x6f, 0x3b, 0xa3, 0x49, 0x29, 0x74, 0x04, 0xb5, 0xbe, 0xe5,
0x53, 0xdd, 0xb7, 0xb1, 0xeb, 0xf7, 0x1c, 0xea, 0x37, 0xaa, 0x5c, 0xcf, 0x07, 0xb3, 0xf5, 0x3c,
0xb0, 0x7c, 0x7a, 0x18, 0x88, 0xb4, 0x33, 0x5a, 0xb5, 0x1f, 0xef, 0x60, 0x5a, 0x9d, 0x93, 0x13,
0xe2, 0x85, 0x6a, 0x1b, 0xb5, 0x34, 0x5a, 0xf7, 0x99, 0x4c, 0xa0, 0x85, 0x69, 0x75, 0xe2, 0x1d,
0x08, 0xc3, 0x85, 0xbe, 0x83, 0xcd, 0x50, 0xa9, 0x6e, 0xf4, 0x86, 0xf6, 0xb3, 0xc6, 0x0a, 0x57,
0xbd, 0x39, 0x67, 0xc2, 0x0e, 0x36, 0x03, 0x45, 0x3b, 0x4c, 0xac, 0x9d, 0xd1, 0x56, 0xfb, 0xe3,
0x9d, 0xc8, 0x84, 0x8b, 0xd8, 0x75, 0xfb, 0xa3, 0xf1, 0x31, 0xea, 0x7c, 0x8c, 0x8f, 0x66, 0x8f,
0xb1, 0xcd, 0x24, 0xc7, 0x07, 0x41, 0xf8, 0x5c, 0x6f, 0xab, 0x08, 0x4b, 0xa7, 0xb8, 0x3f, 0x24,
0xea, 0x75, 0xa8, 0xc4, 0xdc, 0x07, 0x6a, 0x40, 0x71, 0x40, 0x7c, 0x1f, 0x77, 0x49, 0x43, 0xb9,
0xac, 0xdc, 0x28, 0x6b, 0x01, 0xa9, 0xd6, 0x60, 0x39, 0xee, 0x2c, 0xd4, 0x41, 0x28, 0xc8, 0x1c,
0x00, 0x13, 0x3c, 0x25, 0x9e, 0xcf, 0x6e, 0xbd, 0x14, 0x94, 0x24, 0xba, 0x02, 0x55, 0x7e, 0xc4,
0xf4, 0xe0, 0x3b, 0x73, 0x66, 0x79, 0x6d, 0x99, 0x77, 0x3e, 0x91, 0x4c, 0xeb, 0x50, 0x71, 0xb7,
0xdc, 0x90, 0x25, 0xc7, 0x59, 0xc0, 0xdd, 0x72, 0x25, 0x83, 0xfa, 0x5d, 0xa8, 0x8f, 0xfb, 0x0b,
0x54, 0x87, 0xdc, 0x33, 0x32, 0x92, 0xe3, 0xb1, 0x26, 0xba, 0x28, 0x97, 0xc5, 0xc7, 0x28, 0x6b,
0x72, 0x8d, 0x7f, 0xcc, 0x86, 0xc2, 0xa1, 0x8b, 0x60, 0x3e, 0x8e, 0x79, 0x68, 0x2e, 0x5d, 0xd9,
0x6a, 0x6e, 0x08, 0xf7, 0xbd, 0x11, 0xb8, 0xef, 0x8d, 0xa3, 0xc0, 0x7d, 0xb7, 0x4a, 0x5f, 0x7d,
0xb3, 0x9e, 0x79, 0xf1, 0xf7, 0x75, 0x45, 0xe3, 0x12, 0xe8, 0x2d, 0x76, 0x8b, 0xb1, 0x65, 0xeb,
0x96, 0x29, 0xc7, 0x29, 0x72, 0x7a, 0xcf, 0x44, 0x8f, 0xa1, 0x6e, 0x38, 0xb6, 0x4f, 0x6c, 0x7f,
0xe8, 0xeb, 0x22, 0x3c, 0x48, 0x07, 0x3c, 0xed, 0x66, 0xed, 0x04, 0xec, 0x07, 0x9c, 0x5b, 0x5b,
0x31, 0x92, 0x1d, 0xe8, 0x01, 0xc0, 0x29, 0xee, 0x5b, 0x26, 0xa6, 0x8e, 0xe7, 0x37, 0xf2, 0x97,
0x73, 0x33, 0x94, 0x3d, 0x09, 0x18, 0x8f, 0x5d, 0x13, 0x53, 0xd2, 0xca, 0xb3, 0x99, 0x6b, 0x31,
0x79, 0x74, 0x0d, 0x56, 0xb0, 0xeb, 0xea, 0x3e, 0xc5, 0x94, 0xe8, 0x9d, 0x11, 0x25, 0x3e, 0x77,
0xd2, 0xcb, 0x5a, 0x15, 0xbb, 0xee, 0x21, 0xeb, 0x6d, 0xb1, 0x4e, 0xd5, 0x0c, 0x77, 0x9b, 0xfb,
0x43, 0x84, 0x20, 0x6f, 0x62, 0x8a, 0xb9, 0xb5, 0x96, 0x35, 0xde, 0x66, 0x7d, 0x2e, 0xa6, 0x3d,
0x69, 0x03, 0xde, 0x46, 0x97, 0xa0, 0xd0, 0x23, 0x56, 0xb7, 0x47, 0xf9, 0xb2, 0x73, 0x9a, 0xa4,
0xd8, 0xc6, 0xb8, 0x9e, 0x73, 0x4a, 0x78, 0x48, 0x29, 0x69, 0x82, 0x50, 0x7f, 0x9f, 0x85, 0xd5,
0x73, 0x3e, 0x93, 0xe9, 0xed, 0x61, 0xbf, 0x17, 0x8c, 0xc5, 0xda, 0xe8, 0x0e, 0xd3, 0x8b, 0x4d,
0xe2, 0xc9, 0x50, 0xb8, 0x16, 0xb7, 0x00, 0xdf, 0x33, 0x69, 0x82, 0x36, 0xe7, 0x92, 0x2b, 0x97,
0x32, 0xe8, 0x18, 0xea, 0x7d, 0xec, 0x53, 0x5d, 0x78, 0x1c, 0x9d, 0xc7, 0xb6, 0xdc, 0x4c, 0xff,
0xfb, 0x00, 0x07, 0x9e, 0x8a, 0x9d, 0x6e, 0xa9, 0xae, 0xd6, 0x4f, 0xf4, 0xa2, 0xa7, 0x70, 0xb1,
0x33, 0xfa, 0x39, 0xb6, 0xa9, 0x65, 0x13, 0xfd, 0xdc, 0x26, 0xad, 0x4f, 0x51, 0xbd, 0x7b, 0x6a,
0x99, 0xc4, 0x36, 0x82, 0xdd, 0xb9, 0x10, 0xaa, 0x08, 0x77, 0xcf, 0x57, 0x9f, 0x42, 0x2d, 0x19,
0x01, 0x50, 0x0d, 0xb2, 0xf4, 0x4c, 0x9a, 0x24, 0x4b, 0xcf, 0xd0, 0x77, 0x20, 0xcf, 0xd4, 0x71,
0x73, 0xd4, 0xa6, 0x86, 0x68, 0x29, 0x7d, 0x34, 0x72, 0x89, 0xc6, 0xf9, 0x55, 0x35, 0xbc, 0x0a,
0x61, 0x54, 0x18, 0xd7, 0xad, 0xbe, 0x07, 0x2b, 0x63, 0x0e, 0x3f, 0xb6, 0xaf, 0x4a, 0x7c, 0x5f,
0xd5, 0x15, 0xa8, 0x26, 0xfc, 0xba, 0x7a, 0x09, 0x2e, 0x4e, 0x72, 0xd0, 0xaa, 0x1d, 0xf6, 0x27,
0x5c, 0x2c, 0xba, 0x0d, 0xa5, 0xd0, 0x43, 0x8b, 0xab, 0x38, 0xcd, 0x6e, 0x81, 0x88, 0x16, 0x0a,
0xb0, 0x9b, 0xc8, 0x4e, 0x33, 0x3f, 0x2d, 0x59, 0x3e, 0xfd, 0x22, 0x76, 0xdd, 0x36, 0xf6, 0x7b,
0xea, 0xcf, 0xa0, 0x31, 0xcd, 0xef, 0x8e, 0x2d, 0x26, 0x1f, 0x1e, 0xd2, 0x4b, 0x50, 0x38, 0x71,
0xbc, 0x01, 0xa6, 0x5c, 0x59, 0x55, 0x93, 0x14, 0x3b, 0xbc, 0xc2, 0x07, 0xe7, 0x78, 0xb7, 0x20,
0x54, 0x1d, 0xde, 0x9a, 0xea, 0x75, 0x99, 0x88, 0x65, 0x9b, 0x44, 0x58, 0xb5, 0xaa, 0x09, 0x22,
0x52, 0x24, 0x26, 0x2b, 0x08, 0x36, 0xac, 0xcf, 0x57, 0xcc, 0xf5, 0x97, 0x35, 0x49, 0xa9, 0x7f,
0x29, 0x43, 0x49, 0x23, 0xbe, 0xcb, 0x1c, 0x02, 0x6a, 0x43, 0x99, 0x9c, 0x19, 0x44, 0xe0, 0x2a,
0x65, 0x0e, 0x0a, 0x11, 0x32, 0xbb, 0x01, 0x3f, 0x0b, 0xfb, 0xa1, 0x30, 0xba, 0x95, 0xc0, 0x94,
0x57, 0xe6, 0x29, 0x89, 0x83, 0xca, 0x3b, 0x49, 0x50, 0xf9, 0xee, 0x1c, 0xd9, 0x31, 0x54, 0x79,
0x2b, 0x81, 0x2a, 0xe7, 0x0d, 0x9c, 0x80, 0x95, 0x7b, 0x13, 0x60, 0xe5, 0xbc, 0xe5, 0x4f, 0xc1,
0x95, 0x7b, 0x13, 0x70, 0xe5, 0x8d, 0xb9, 0x73, 0x99, 0x08, 0x2c, 0xef, 0x24, 0x81, 0xe5, 0x3c,
0x73, 0x8c, 0x21, 0xcb, 0x07, 0x93, 0x90, 0xe5, 0x7b, 0x73, 0x74, 0x4c, 0x85, 0x96, 0x3b, 0xe7,
0xa0, 0xe5, 0xb5, 0x39, 0xaa, 0x26, 0x60, 0xcb, 0xbd, 0x04, 0xb6, 0x84, 0x54, 0xb6, 0x99, 0x02,
0x2e, 0xef, 0x9d, 0x07, 0x97, 0xd7, 0xe7, 0x1d, 0xb5, 0x49, 0xe8, 0xf2, 0x07, 0x63, 0xe8, 0xf2,
0xea, 0xbc, 0x55, 0x8d, 0xc3, 0xcb, 0xe3, 0x29, 0xf0, 0xf2, 0xc3, 0x39, 0x8a, 0xe6, 0xe0, 0xcb,
0xe3, 0x29, 0xf8, 0x72, 0x9e, 0xda, 0x39, 0x00, 0xb3, 0x33, 0x0b, 0x60, 0x7e, 0x34, 0x6f, 0xca,
0xe9, 0x10, 0x26, 0x99, 0x89, 0x30, 0x3f, 0x9e, 0x33, 0xc8, 0xe2, 0x10, 0xf3, 0x3d, 0x16, 0xe4,
0xc7, 0x5c, 0x12, 0x73, 0x85, 0xc4, 0xf3, 0x1c, 0x4f, 0xa2, 0x37, 0x41, 0xa8, 0x37, 0x18, 0xec,
0x88, 0x1c, 0xcf, 0x0c, 0x38, 0xca, 0x03, 0x4f, 0xcc, 0xcd, 0xa8, 0x7f, 0x56, 0x22, 0x59, 0x1e,
0x9d, 0xe3, 0x90, 0xa5, 0x2c, 0x21, 0x4b, 0x0c, 0xa5, 0x66, 0x93, 0x28, 0x75, 0x1d, 0x2a, 0x2c,
0x94, 0x8c, 0x01, 0x50, 0xec, 0x06, 0x00, 0x14, 0xbd, 0x0f, 0xab, 0x1c, 0x43, 0x08, 0x2c, 0x2b,
0xe3, 0x47, 0x9e, 0x07, 0xc3, 0x15, 0xf6, 0x41, 0x1c, 0x5d, 0x11, 0x48, 0xfe, 0x1f, 0x2e, 0xc4,
0x78, 0xc3, 0x10, 0x25, 0x90, 0x56, 0x3d, 0xe4, 0xde, 0x96, 0xb1, 0xea, 0x61, 0x64, 0xa0, 0x08,
0xdc, 0x22, 0xc8, 0x1b, 0x8e, 0x49, 0x64, 0x00, 0xe1, 0x6d, 0x06, 0x78, 0xfb, 0x4e, 0x57, 0x86,
0x09, 0xd6, 0x64, 0x5c, 0xa1, 0x4f, 0x2d, 0x0b, 0x67, 0xa9, 0xfe, 0x49, 0x89, 0xf4, 0x45, 0x78,
0x77, 0x12, 0x34, 0x55, 0x5e, 0x27, 0x34, 0xcd, 0xfe, 0x77, 0xd0, 0x54, 0xfd, 0x75, 0x36, 0xda,
0xd2, 0x10, 0x74, 0x7e, 0x3b, 0x13, 0x44, 0xe1, 0x77, 0x89, 0x6f, 0x90, 0x0c, 0xbf, 0x32, 0x5f,
0x28, 0xf0, 0x6d, 0x48, 0xe6, 0x0b, 0x45, 0x11, 0x90, 0x39, 0xc1, 0x12, 0x63, 0xd7, 0x73, 0x9c,
0x13, 0xdd, 0x71, 0xfd, 0x49, 0x19, 0xbf, 0xc0, 0x9b, 0xa2, 0x7a, 0xb4, 0x21, 0xaa, 0x47, 0x1b,
0x07, 0x4c, 0x60, 0xdf, 0xf5, 0xb5, 0x92, 0x2b, 0x5b, 0x31, 0x98, 0x51, 0x4e, 0x60, 0xe1, 0xb7,
0xa1, 0xcc, 0x96, 0xe2, 0xbb, 0xd8, 0x20, 0xdc, 0xc9, 0x96, 0xb5, 0xa8, 0x43, 0x35, 0x01, 0x9d,
0x77, 0xf6, 0xe8, 0x11, 0x14, 0xc8, 0x29, 0xb1, 0x29, 0xdb, 0x33, 0x66, 0xe6, 0xb7, 0xa7, 0x82,
0x4b, 0x62, 0xd3, 0x56, 0x83, 0x19, 0xf7, 0x5f, 0xdf, 0xac, 0xd7, 0x85, 0xcc, 0x87, 0xce, 0xc0,
0xa2, 0x64, 0xe0, 0xd2, 0x91, 0x26, 0xb5, 0xa8, 0xbf, 0xc9, 0x32, 0x8c, 0x97, 0x08, 0x04, 0x13,
0xcd, 0x1d, 0x5c, 0xa2, 0x6c, 0x0c, 0xf7, 0xa7, 0xdb, 0x82, 0x77, 0x00, 0xba, 0xd8, 0xd7, 0x9f,
0x63, 0x9b, 0x12, 0x53, 0xee, 0x43, 0xb9, 0x8b, 0xfd, 0x1f, 0xf3, 0x0e, 0x06, 0xdd, 0xd8, 0xe7,
0xa1, 0x4f, 0x4c, 0xbe, 0x21, 0x39, 0xad, 0xd8, 0xc5, 0xfe, 0xb1, 0x4f, 0xcc, 0xd8, 0x5a, 0x8b,
0xaf, 0x63, 0xad, 0x49, 0x7b, 0x97, 0xc6, 0xed, 0xfd, 0xdb, 0x6c, 0x74, 0x5b, 0x22, 0x48, 0xfc,
0xbf, 0x69, 0x8b, 0x3f, 0xf0, 0x44, 0x39, 0x19, 0x8d, 0xd1, 0xa7, 0xb0, 0x1a, 0xde, 0x52, 0x7d,
0xc8, 0x6f, 0x6f, 0x70, 0x0a, 0x17, 0xbb, 0xec, 0xf5, 0xd3, 0x64, 0xb7, 0x8f, 0x3e, 0x83, 0x37,
0xc7, 0x7c, 0x52, 0x38, 0x40, 0x76, 0x21, 0xd7, 0xf4, 0x46, 0xd2, 0x35, 0x05, 0xfa, 0x23, 0xeb,
0xe5, 0x5e, 0xcb, 0xad, 0xd9, 0x63, 0x69, 0x59, 0x1c, 0x67, 0x4c, 0x3c, 0x13, 0x57, 0xa0, 0xea,
0x11, 0x8a, 0x2d, 0x5b, 0x4f, 0xa4, 0xc2, 0xcb, 0xa2, 0x53, 0x84, 0x08, 0xf5, 0x09, 0xbc, 0x31,
0x11, 0x69, 0xa0, 0xef, 0x41, 0x39, 0x82, 0x2a, 0xca, 0xcc, 0x4c, 0x32, 0xcc, 0x88, 0x22, 0x09,
0xf5, 0x4b, 0x25, 0x52, 0x9c, 0xcc, 0xb4, 0xee, 0x43, 0xc1, 0x23, 0xfe, 0xb0, 0x2f, 0xb2, 0x9e,
0xda, 0xd6, 0x27, 0x8b, 0x20, 0x15, 0xd6, 0x3b, 0xec, 0x53, 0x4d, 0xaa, 0x50, 0x1f, 0x43, 0x41,
0xf4, 0x20, 0x80, 0xc2, 0xf6, 0xce, 0xce, 0xee, 0xc1, 0x51, 0x3d, 0x83, 0xca, 0xb0, 0xb4, 0xdd,
0xda, 0xd7, 0x8e, 0xea, 0x0a, 0xeb, 0xd6, 0x76, 0x7f, 0xb4, 0xbb, 0x73, 0x54, 0xcf, 0xa2, 0x55,
0xa8, 0x8a, 0xb6, 0x7e, 0x6f, 0x5f, 0x7b, 0xb8, 0x7d, 0x54, 0xcf, 0xc5, 0xba, 0x0e, 0x77, 0x1f,
0xdd, 0xdd, 0xd5, 0xea, 0x79, 0xf5, 0x63, 0x96, 0x4f, 0x4d, 0x01, 0x32, 0x51, 0xe6, 0xa4, 0xc4,
0x32, 0x27, 0xf5, 0x77, 0x59, 0x68, 0x4e, 0xc7, 0x25, 0xe8, 0x60, 0x6c, 0xc5, 0x37, 0x17, 0x86,
0x36, 0x63, 0xcb, 0x46, 0x57, 0xa1, 0xe6, 0x91, 0x13, 0x42, 0x8d, 0x9e, 0xc0, 0x4c, 0x22, 0xea,
0x55, 0xb5, 0xaa, 0xec, 0xe5, 0x42, 0xbe, 0x60, 0xfb, 0x9c, 0x18, 0x54, 0x17, 0xa9, 0x9c, 0x38,
0x7f, 0x65, 0xc6, 0xc6, 0x7a, 0x0f, 0x45, 0xa7, 0x7a, 0x38, 0xcf, 0x88, 0x65, 0x58, 0xd2, 0x76,
0x8f, 0xb4, 0x4f, 0xeb, 0x59, 0x84, 0xa0, 0xc6, 0x9b, 0xfa, 0xe1, 0xa3, 0xed, 0x83, 0xc3, 0xf6,
0x3e, 0x33, 0xe2, 0x05, 0x58, 0x09, 0x8c, 0x18, 0x74, 0xe6, 0xd5, 0xbf, 0x2a, 0xb0, 0x32, 0x76,
0x3d, 0xd0, 0x4d, 0x58, 0x12, 0x40, 0x5c, 0x99, 0x59, 0xd0, 0xe7, 0xf7, 0x5d, 0xde, 0x28, 0x21,
0x80, 0x5a, 0x50, 0x22, 0xb2, 0x5e, 0x31, 0xe9, 0x4a, 0xc6, 0x2b, 0x2f, 0x41, 0x5d, 0x43, 0x2a,
0x08, 0xe5, 0x58, 0x38, 0x0d, 0x6f, 0xbe, 0xcc, 0x1c, 0xaf, 0x4f, 0x53, 0x12, 0x7a, 0x0e, 0xa9,
0x25, 0x92, 0x54, 0x77, 0xa0, 0x12, 0x9b, 0x20, 0xfa, 0x3f, 0x28, 0x0f, 0xf0, 0x99, 0xac, 0x61,
0x89, 0xa2, 0x44, 0x69, 0x80, 0xcf, 0x78, 0xf9, 0x0a, 0xbd, 0x09, 0x45, 0xf6, 0xb1, 0x8b, 0x85,
0x23, 0xc9, 0x69, 0x85, 0x01, 0x3e, 0xfb, 0x21, 0xf6, 0x55, 0x03, 0x6a, 0xc9, 0xd2, 0x0e, 0x3b,
0x59, 0x9e, 0x33, 0xb4, 0x4d, 0xae, 0x63, 0x49, 0x13, 0x04, 0xba, 0x0d, 0x4b, 0xa7, 0x8e, 0xf0,
0x43, 0xb3, 0x6e, 0xe0, 0x13, 0x87, 0x92, 0x58, 0x81, 0x48, 0xc8, 0xa8, 0x8f, 0xa0, 0xc6, 0x3d,
0xca, 0x36, 0xa5, 0x9e, 0xd5, 0x19, 0x52, 0x12, 0xaf, 0x54, 0x2e, 0x4f, 0xa8, 0x54, 0x86, 0xc8,
0x23, 0xc4, 0x2d, 0x39, 0x51, 0x26, 0xe3, 0x84, 0xfa, 0x4b, 0x05, 0x96, 0xb8, 0x42, 0xe6, 0x6e,
0x78, 0xd5, 0x47, 0x62, 0x5a, 0xd6, 0x46, 0x06, 0x00, 0x0e, 0x06, 0x0a, 0xe6, 0x7b, 0x75, 0x96,
0xa3, 0x0b, 0xa7, 0xd5, 0x7a, 0x5b, 0x7a, 0xbc, 0x8b, 0x91, 0x82, 0x98, 0xd7, 0x8b, 0xa9, 0x55,
0x5f, 0x28, 0x50, 0x3a, 0x3a, 0x93, 0xa7, 0x75, 0x4a, 0x31, 0x88, 0xcd, 0x7e, 0x8f, 0xcf, 0x5e,
0x94, 0x4f, 0x04, 0x21, 0xab, 0x4b, 0xb9, 0xb0, 0x72, 0x75, 0x2f, 0xbc, 0x95, 0xf9, 0xc5, 0x12,
0xcc, 0xa0, 0xa8, 0x27, 0x5d, 0x50, 0x1f, 0x8a, 0xfc, 0x3c, 0xec, 0xdd, 0x9d, 0x58, 0x31, 0x7c,
0x08, 0xcb, 0x2e, 0xf6, 0xa8, 0xaf, 0x27, 0xea, 0x86, 0xd3, 0x72, 0xf4, 0x03, 0xec, 0xd1, 0x43,
0x42, 0x13, 0xd5, 0xc3, 0x0a, 0x97, 0x17, 0x5d, 0xea, 0x2d, 0xa8, 0x26, 0x78, 0xd8, 0x62, 0xa9,
0x43, 0x71, 0x3f, 0x38, 0x37, 0x9c, 0x08, 0x67, 0x92, 0x8d, 0x66, 0xa2, 0xde, 0x86, 0x72, 0x78,
0xac, 0x59, 0x06, 0x82, 0x4d, 0xd3, 0x23, 0xbe, 0x2f, 0x67, 0x1b, 0x90, 0xbc, 0x44, 0xea, 0x3c,
0x97, 0x55, 0xa0, 0x9c, 0x26, 0x08, 0x95, 0xc0, 0xca, 0x58, 0x34, 0x45, 0x77, 0xa0, 0xe8, 0x0e,
0x3b, 0x7a, 0x70, 0xa0, 0x2a, 0x5b, 0xef, 0x4c, 0x5b, 0xd4, 0xb0, 0x73, 0x9f, 0x8c, 0x02, 0xb3,
0xb9, 0x9c, 0x8a, 0x86, 0xc9, 0xc6, 0x87, 0xf9, 0x05, 0x94, 0x82, 0xb3, 0x8c, 0xee, 0xc6, 0xef,
0xab, 0x18, 0xe1, 0xf2, 0xbc, 0x40, 0x2f, 0x07, 0x89, 0x04, 0x59, 0xbe, 0xe4, 0x5b, 0x5d, 0x9b,
0x98, 0x7a, 0x94, 0x0a, 0xf1, 0x31, 0x4b, 0xda, 0x8a, 0xf8, 0xf0, 0x20, 0xc8, 0x83, 0xd4, 0x8f,
0xa0, 0x20, 0xe6, 0x3a, 0xf1, 0x80, 0x4f, 0x88, 0xb1, 0xea, 0x3f, 0x15, 0x28, 0x05, 0x0e, 0x67,
0xa2, 0x50, 0x62, 0x11, 0xd9, 0x6f, 0xbb, 0x88, 0x69, 0xe5, 0xec, 0xe0, 0xf1, 0x20, 0xbf, 0xf0,
0xe3, 0xc1, 0x87, 0x80, 0xf8, 0x49, 0xd1, 0x4f, 0x1d, 0x6a, 0xd9, 0x5d, 0x5d, 0xec, 0x85, 0x80,
0x84, 0x75, 0xfe, 0xe5, 0x09, 0xff, 0x70, 0xc0, 0xb7, 0xe5, 0x57, 0x0a, 0x94, 0xc2, 0x00, 0xbe,
0x68, 0xd9, 0xf2, 0x12, 0x14, 0x64, 0x90, 0x12, 0x75, 0x4b, 0x49, 0x85, 0x67, 0x34, 0x1f, 0xbb,
0x2d, 0x4d, 0x28, 0x0d, 0x08, 0xc5, 0xdc, 0xce, 0x22, 0x4d, 0x0d, 0xe9, 0xf7, 0xaf, 0x40, 0x25,
0x56, 0x47, 0x46, 0x45, 0xc8, 0x3d, 0x22, 0xcf, 0xeb, 0x19, 0x54, 0x81, 0xa2, 0x46, 0x78, 0xe9,
0xa8, 0xae, 0x6c, 0x7d, 0x59, 0x81, 0x95, 0xed, 0xd6, 0xce, 0x1e, 0x8b, 0xa1, 0x96, 0x81, 0x79,
0x0a, 0xbb, 0x0f, 0x79, 0x9e, 0xc5, 0xa7, 0x78, 0xb7, 0x6e, 0xa6, 0xa9, 0x43, 0x22, 0x0d, 0x96,
0x78, 0xb2, 0x8f, 0xd2, 0x3c, 0x67, 0x37, 0x53, 0x95, 0x27, 0xd9, 0x24, 0xf9, 0xa9, 0x4f, 0xf1,
0xca, 0xdd, 0x4c, 0x53, 0xb3, 0x44, 0x9f, 0x41, 0x39, 0xca, 0xe2, 0xd3, 0xbe, 0x7d, 0x37, 0x53,
0x57, 0x33, 0x99, 0xfe, 0x28, 0x4f, 0x49, 0xfb, 0xf2, 0xdb, 0x4c, 0xed, 0x65, 0xd1, 0x53, 0x28,
0x06, 0x19, 0x61, 0xba, 0xd7, 0xe9, 0x66, 0xca, 0x4a, 0x23, 0xdb, 0x3e, 0x91, 0xd8, 0xa7, 0x79,
0x82, 0x6f, 0xa6, 0x2a, 0xa7, 0xa2, 0x63, 0x28, 0x48, 0x28, 0x9e, 0xea, 0xdd, 0xb9, 0x99, 0xae,
0x7e, 0xc8, 0x8c, 0x1c, 0x95, 0x4e, 0xd2, 0xfe, 0xed, 0xa0, 0x99, 0xba, 0x8e, 0x8c, 0x30, 0x40,
0x2c, 0xbb, 0x4f, 0xfd, 0x7f, 0x82, 0x66, 0xfa, 0xfa, 0x30, 0xfa, 0x29, 0x94, 0xc2, 0x1c, 0x2e,
0xe5, 0xbb, 0x7e, 0x33, 0x6d, 0x89, 0x16, 0x7d, 0x0e, 0xd5, 0x64, 0xda, 0xb2, 0xc8, 0x6b, 0x7d,
0x73, 0xa1, 0xda, 0x2b, 0x1b, 0x2b, 0x99, 0xc9, 0x2c, 0xf2, 0x86, 0xdf, 0x5c, 0xa8, 0x20, 0x8b,
0x4e, 0x61, 0xf5, 0x7c, 0xf2, 0xb1, 0xe8, 0xc3, 0x7e, 0x73, 0xe1, 0x42, 0x2d, 0x1a, 0x01, 0x9a,
0x90, 0xc0, 0x2c, 0xfc, 0xda, 0xdf, 0x5c, 0xbc, 0x7a, 0xdb, 0xda, 0xfd, 0xea, 0xe5, 0x9a, 0xf2,
0xf5, 0xcb, 0x35, 0xe5, 0x1f, 0x2f, 0xd7, 0x94, 0x17, 0xaf, 0xd6, 0x32, 0x5f, 0xbf, 0x5a, 0xcb,
0xfc, 0xed, 0xd5, 0x5a, 0xe6, 0x27, 0x1f, 0x74, 0x2d, 0xda, 0x1b, 0x76, 0x36, 0x0c, 0x67, 0xb0,
0x19, 0xa9, 0x8d, 0x37, 0xa3, 0xbf, 0x5d, 0x75, 0x0a, 0x3c, 0xf8, 0x7d, 0xf2, 0x9f, 0x00, 0x00,
0x00, 0xff, 0xff, 0x33, 0x72, 0x48, 0xac, 0x8b, 0x25, 0x00, 0x00,
0xf1, 0xe7, 0x4b, 0x7c, 0x14, 0x45, 0x8a, 0x6a, 0x7b, 0xbd, 0x5c, 0xfe, 0x77, 0x25, 0x63, 0xbc,
0x7e, 0xed, 0xfa, 0x4f, 0xed, 0x6a, 0x81, 0xc0, 0x8e, 0x9d, 0x04, 0xa2, 0x2c, 0x87, 0x8a, 0x1f,
0x92, 0x47, 0x92, 0xe3, 0x4d, 0x80, 0x9d, 0x34, 0x67, 0x5a, 0xe4, 0xac, 0xc8, 0x99, 0xd9, 0x99,
0xa6, 0x2c, 0x06, 0x39, 0x04, 0x41, 0x80, 0x20, 0x37, 0xe7, 0x92, 0x5b, 0xbe, 0x43, 0x0e, 0x01,
0x36, 0x5f, 0x20, 0xc0, 0x1e, 0xf7, 0x14, 0xe4, 0xb4, 0x09, 0xec, 0x9c, 0x92, 0x2f, 0x11, 0xf4,
0x63, 0x5e, 0x14, 0x1f, 0xc3, 0x8d, 0x6f, 0xb9, 0x10, 0xdd, 0x35, 0x55, 0xd5, 0xdd, 0xd5, 0xdd,
0x55, 0xbf, 0xaa, 0x26, 0x5c, 0xc2, 0x1d, 0xdd, 0xdc, 0xa0, 0x23, 0x87, 0x78, 0xe2, 0xb7, 0xe9,
0xb8, 0x36, 0xb5, 0xd1, 0x5b, 0x94, 0x58, 0x06, 0x71, 0x07, 0xa6, 0x45, 0x9b, 0x8c, 0xa5, 0xc9,
0x3f, 0x36, 0xd6, 0xf9, 0xd7, 0x0d, 0xdd, 0x1d, 0x39, 0xd4, 0xde, 0x18, 0x10, 0xf7, 0xa4, 0x4f,
0xa2, 0x72, 0x8d, 0xb7, 0x05, 0xc3, 0x39, 0x85, 0x8d, 0xf7, 0x62, 0x92, 0x27, 0x64, 0x14, 0xff,
0x5c, 0x8f, 0xca, 0x39, 0xd8, 0xc5, 0x03, 0xff, 0xcb, 0x7a, 0xd7, 0xb6, 0xbb, 0x7d, 0xb2, 0xc1,
0x7b, 0x9d, 0xe1, 0xf1, 0x06, 0x35, 0x07, 0xc4, 0xa3, 0x78, 0xe0, 0x48, 0x86, 0x6b, 0xb4, 0x67,
0xba, 0x86, 0xe6, 0x60, 0x97, 0x8e, 0x04, 0xd7, 0x46, 0xd7, 0xee, 0xda, 0x61, 0x4b, 0xf0, 0x29,
0xff, 0x2e, 0x42, 0x41, 0x25, 0x5f, 0x0c, 0x89, 0x47, 0xd1, 0x6d, 0xc8, 0x11, 0xbd, 0x67, 0xd7,
0x33, 0x97, 0xd3, 0x37, 0xca, 0x9b, 0x4a, 0x73, 0xe2, 0x6a, 0x9b, 0x92, 0x7b, 0x47, 0xef, 0xd9,
0xed, 0x94, 0xca, 0x25, 0xd0, 0x5d, 0x58, 0x3a, 0xee, 0x0f, 0xbd, 0x5e, 0x3d, 0xcb, 0x45, 0xaf,
0xcc, 0x16, 0x7d, 0xc0, 0x58, 0xdb, 0x29, 0x55, 0xc8, 0xb0, 0x61, 0x4d, 0xeb, 0xd8, 0xae, 0xe7,
0x92, 0x0c, 0xbb, 0x6b, 0x1d, 0xf3, 0x61, 0x99, 0x04, 0x6a, 0x03, 0x78, 0x84, 0x6a, 0xb6, 0x43,
0x4d, 0xdb, 0xaa, 0x2f, 0x71, 0xf9, 0xeb, 0xb3, 0xe5, 0x0f, 0x08, 0xdd, 0xe3, 0xec, 0xed, 0x94,
0x5a, 0xf2, 0xfc, 0x0e, 0xd3, 0x64, 0x5a, 0x26, 0xd5, 0xf4, 0x1e, 0x36, 0xad, 0x7a, 0x3e, 0x89,
0xa6, 0x5d, 0xcb, 0xa4, 0xdb, 0x8c, 0x9d, 0x69, 0x32, 0xfd, 0x0e, 0x33, 0xc5, 0x17, 0x43, 0xe2,
0x8e, 0xea, 0x85, 0x24, 0xa6, 0x78, 0xca, 0x58, 0x99, 0x29, 0xb8, 0x0c, 0x7a, 0x08, 0xe5, 0x0e,
0xe9, 0x9a, 0x96, 0xd6, 0xe9, 0xdb, 0xfa, 0x49, 0xbd, 0xc8, 0x55, 0xdc, 0x98, 0xad, 0xa2, 0xc5,
0x04, 0x5a, 0x8c, 0xbf, 0x9d, 0x52, 0xa1, 0x13, 0xf4, 0x50, 0x0b, 0x8a, 0x7a, 0x8f, 0xe8, 0x27,
0x1a, 0x3d, 0xab, 0x97, 0xb8, 0xa6, 0xab, 0xb3, 0x35, 0x6d, 0x33, 0xee, 0xc3, 0xb3, 0x76, 0x4a,
0x2d, 0xe8, 0xa2, 0xc9, 0xec, 0x62, 0x90, 0xbe, 0x79, 0x4a, 0x5c, 0xa6, 0xe5, 0x42, 0x12, 0xbb,
0xdc, 0x17, 0xfc, 0x5c, 0x4f, 0xc9, 0xf0, 0x3b, 0x68, 0x07, 0x4a, 0xc4, 0x32, 0xe4, 0xc2, 0xca,
0x5c, 0xd1, 0xb5, 0x39, 0x27, 0xcc, 0x32, 0xfc, 0x65, 0x15, 0x89, 0x6c, 0xa3, 0xef, 0x43, 0x5e,
0xb7, 0x07, 0x03, 0x93, 0xd6, 0x97, 0xb9, 0x8e, 0xf7, 0xe7, 0x2c, 0x89, 0xf3, 0xb6, 0x53, 0xaa,
0x94, 0x42, 0x87, 0x50, 0xed, 0x9b, 0x1e, 0xd5, 0x3c, 0x0b, 0x3b, 0x5e, 0xcf, 0xa6, 0x5e, 0xbd,
0xc2, 0xf5, 0x7c, 0x38, 0x5b, 0xcf, 0x23, 0xd3, 0xa3, 0x07, 0xbe, 0x48, 0x3b, 0xa5, 0x56, 0xfa,
0x51, 0x02, 0xd3, 0x6a, 0x1f, 0x1f, 0x13, 0x37, 0x50, 0x5b, 0xaf, 0x26, 0xd1, 0xba, 0xc7, 0x64,
0x7c, 0x2d, 0x4c, 0xab, 0x1d, 0x25, 0x20, 0x0c, 0x17, 0xfa, 0x36, 0x36, 0x02, 0xa5, 0x9a, 0xde,
0x1b, 0x5a, 0x27, 0xf5, 0x15, 0xae, 0x7a, 0x63, 0xce, 0x84, 0x6d, 0x6c, 0xf8, 0x8a, 0xb6, 0x99,
0x58, 0x3b, 0xa5, 0xae, 0xf6, 0xc7, 0x89, 0xc8, 0x80, 0x8b, 0xd8, 0x71, 0xfa, 0xa3, 0xf1, 0x31,
0x6a, 0x7c, 0x8c, 0x8f, 0x66, 0x8f, 0xb1, 0xc5, 0x24, 0xc7, 0x07, 0x41, 0xf8, 0x1c, 0xb5, 0x55,
0x80, 0xa5, 0x53, 0xdc, 0x1f, 0x12, 0xe5, 0x3a, 0x94, 0x23, 0xee, 0x03, 0xd5, 0xa1, 0x30, 0x20,
0x9e, 0x87, 0xbb, 0xa4, 0x9e, 0xbe, 0x9c, 0xbe, 0x51, 0x52, 0xfd, 0xae, 0x52, 0x85, 0xe5, 0xa8,
0xb3, 0x50, 0x06, 0x81, 0x20, 0x73, 0x00, 0x4c, 0xf0, 0x94, 0xb8, 0x1e, 0xbb, 0xf5, 0x52, 0x50,
0x76, 0xd1, 0x15, 0xa8, 0xf0, 0x23, 0xa6, 0xf9, 0xdf, 0x99, 0x33, 0xcb, 0xa9, 0xcb, 0x9c, 0xf8,
0x4c, 0x32, 0xad, 0x43, 0xd9, 0xd9, 0x74, 0x02, 0x96, 0x2c, 0x67, 0x01, 0x67, 0xd3, 0x91, 0x0c,
0xca, 0x77, 0xa1, 0x36, 0xee, 0x2f, 0x50, 0x0d, 0xb2, 0x27, 0x64, 0x24, 0xc7, 0x63, 0x4d, 0x74,
0x51, 0x2e, 0x8b, 0x8f, 0x51, 0x52, 0xe5, 0x1a, 0xff, 0x98, 0x09, 0x84, 0x03, 0x17, 0xc1, 0x7c,
0x1c, 0xf3, 0xd0, 0x5c, 0xba, 0xbc, 0xd9, 0x68, 0x0a, 0xf7, 0xdd, 0xf4, 0xdd, 0x77, 0xf3, 0xd0,
0x77, 0xdf, 0xad, 0xe2, 0x57, 0xdf, 0xac, 0xa7, 0x5e, 0xfe, 0x7d, 0x3d, 0xad, 0x72, 0x09, 0xf4,
0x0e, 0xbb, 0xc5, 0xd8, 0xb4, 0x34, 0xd3, 0x90, 0xe3, 0x14, 0x78, 0x7f, 0xd7, 0x40, 0x4f, 0xa1,
0xa6, 0xdb, 0x96, 0x47, 0x2c, 0x6f, 0xe8, 0x69, 0x22, 0x3c, 0x48, 0x07, 0x3c, 0xed, 0x66, 0x6d,
0xfb, 0xec, 0xfb, 0x9c, 0x5b, 0x5d, 0xd1, 0xe3, 0x04, 0xf4, 0x08, 0xe0, 0x14, 0xf7, 0x4d, 0x03,
0x53, 0xdb, 0xf5, 0xea, 0xb9, 0xcb, 0xd9, 0x19, 0xca, 0x9e, 0xf9, 0x8c, 0x47, 0x8e, 0x81, 0x29,
0x69, 0xe5, 0xd8, 0xcc, 0xd5, 0x88, 0x3c, 0xba, 0x06, 0x2b, 0xd8, 0x71, 0x34, 0x8f, 0x62, 0x4a,
0xb4, 0xce, 0x88, 0x12, 0x8f, 0x3b, 0xe9, 0x65, 0xb5, 0x82, 0x1d, 0xe7, 0x80, 0x51, 0x5b, 0x8c,
0xa8, 0x18, 0xc1, 0x6e, 0x73, 0x7f, 0x88, 0x10, 0xe4, 0x0c, 0x4c, 0x31, 0xb7, 0xd6, 0xb2, 0xca,
0xdb, 0x8c, 0xe6, 0x60, 0xda, 0x93, 0x36, 0xe0, 0x6d, 0x74, 0x09, 0xf2, 0x3d, 0x62, 0x76, 0x7b,
0x94, 0x2f, 0x3b, 0xab, 0xca, 0x1e, 0xdb, 0x18, 0xc7, 0xb5, 0x4f, 0x09, 0x0f, 0x29, 0x45, 0x55,
0x74, 0x94, 0xdf, 0x67, 0x60, 0xf5, 0x9c, 0xcf, 0x64, 0x7a, 0x7b, 0xd8, 0xeb, 0xf9, 0x63, 0xb1,
0x36, 0xba, 0xc7, 0xf4, 0x62, 0x83, 0xb8, 0x32, 0x14, 0xae, 0x45, 0x2d, 0xc0, 0xf7, 0x4c, 0x9a,
0xa0, 0xcd, 0xb9, 0xe4, 0xca, 0xa5, 0x0c, 0x3a, 0x82, 0x5a, 0x1f, 0x7b, 0x54, 0x13, 0x1e, 0x47,
0xe3, 0xb1, 0x2d, 0x3b, 0xd3, 0xff, 0x3e, 0xc2, 0xbe, 0xa7, 0x62, 0xa7, 0x5b, 0xaa, 0xab, 0xf6,
0x63, 0x54, 0xf4, 0x1c, 0x2e, 0x76, 0x46, 0x3f, 0xc7, 0x16, 0x35, 0x2d, 0xa2, 0x9d, 0xdb, 0xa4,
0xf5, 0x29, 0xaa, 0x77, 0x4e, 0x4d, 0x83, 0x58, 0xba, 0xbf, 0x3b, 0x17, 0x02, 0x15, 0xc1, 0xee,
0x79, 0xca, 0x73, 0xa8, 0xc6, 0x23, 0x00, 0xaa, 0x42, 0x86, 0x9e, 0x49, 0x93, 0x64, 0xe8, 0x19,
0xfa, 0x0e, 0xe4, 0x98, 0x3a, 0x6e, 0x8e, 0xea, 0xd4, 0x10, 0x2d, 0xa5, 0x0f, 0x47, 0x0e, 0x51,
0x39, 0xbf, 0xa2, 0x04, 0x57, 0x21, 0x88, 0x0a, 0xe3, 0xba, 0x95, 0x9b, 0xb0, 0x32, 0xe6, 0xf0,
0x23, 0xfb, 0x9a, 0x8e, 0xee, 0xab, 0xb2, 0x02, 0x95, 0x98, 0x5f, 0x57, 0x2e, 0xc1, 0xc5, 0x49,
0x0e, 0x5a, 0xb1, 0x02, 0x7a, 0xcc, 0xc5, 0xa2, 0xbb, 0x50, 0x0c, 0x3c, 0xb4, 0xb8, 0x8a, 0xd3,
0xec, 0xe6, 0x8b, 0xa8, 0x81, 0x00, 0xbb, 0x89, 0xec, 0x34, 0xf3, 0xd3, 0x92, 0xe1, 0xd3, 0x2f,
0x60, 0xc7, 0x69, 0x63, 0xaf, 0xa7, 0xfc, 0x0c, 0xea, 0xd3, 0xfc, 0xee, 0xd8, 0x62, 0x72, 0xc1,
0x21, 0xbd, 0x04, 0xf9, 0x63, 0xdb, 0x1d, 0x60, 0xca, 0x95, 0x55, 0x54, 0xd9, 0x63, 0x87, 0x57,
0xf8, 0xe0, 0x2c, 0x27, 0x8b, 0x8e, 0xa2, 0xc1, 0x3b, 0x53, 0xbd, 0x2e, 0x13, 0x31, 0x2d, 0x83,
0x08, 0xab, 0x56, 0x54, 0xd1, 0x09, 0x15, 0x89, 0xc9, 0x8a, 0x0e, 0x1b, 0xd6, 0xe3, 0x2b, 0xe6,
0xfa, 0x4b, 0xaa, 0xec, 0x29, 0x7f, 0x29, 0x41, 0x51, 0x25, 0x9e, 0xc3, 0x1c, 0x02, 0x6a, 0x43,
0x89, 0x9c, 0xe9, 0x44, 0xe0, 0xaa, 0xf4, 0x1c, 0x14, 0x22, 0x64, 0x76, 0x7c, 0x7e, 0x16, 0xf6,
0x03, 0x61, 0x74, 0x27, 0x86, 0x29, 0xaf, 0xcc, 0x53, 0x12, 0x05, 0x95, 0xf7, 0xe2, 0xa0, 0xf2,
0xfd, 0x39, 0xb2, 0x63, 0xa8, 0xf2, 0x4e, 0x0c, 0x55, 0xce, 0x1b, 0x38, 0x06, 0x2b, 0x77, 0x27,
0xc0, 0xca, 0x79, 0xcb, 0x9f, 0x82, 0x2b, 0x77, 0x27, 0xe0, 0xca, 0x1b, 0x73, 0xe7, 0x32, 0x11,
0x58, 0xde, 0x8b, 0x03, 0xcb, 0x79, 0xe6, 0x18, 0x43, 0x96, 0x8f, 0x26, 0x21, 0xcb, 0x9b, 0x73,
0x74, 0x4c, 0x85, 0x96, 0xdb, 0xe7, 0xa0, 0xe5, 0xb5, 0x39, 0xaa, 0x26, 0x60, 0xcb, 0xdd, 0x18,
0xb6, 0x84, 0x44, 0xb6, 0x99, 0x02, 0x2e, 0x1f, 0x9c, 0x07, 0x97, 0xd7, 0xe7, 0x1d, 0xb5, 0x49,
0xe8, 0xf2, 0x07, 0x63, 0xe8, 0xf2, 0xea, 0xbc, 0x55, 0x8d, 0xc3, 0xcb, 0xa3, 0x29, 0xf0, 0xf2,
0xd6, 0x1c, 0x45, 0x73, 0xf0, 0xe5, 0xd1, 0x14, 0x7c, 0x39, 0x4f, 0xed, 0x1c, 0x80, 0xd9, 0x99,
0x05, 0x30, 0x3f, 0x9a, 0x37, 0xe5, 0x64, 0x08, 0x93, 0xcc, 0x44, 0x98, 0x1f, 0xcf, 0x19, 0x64,
0x71, 0x88, 0x79, 0x93, 0x05, 0xf9, 0x31, 0x97, 0xc4, 0x5c, 0x21, 0x71, 0x5d, 0xdb, 0x95, 0xe8,
0x4d, 0x74, 0x94, 0x1b, 0x0c, 0x76, 0x84, 0x8e, 0x67, 0x06, 0x1c, 0xe5, 0x81, 0x27, 0xe2, 0x66,
0x94, 0x3f, 0xa7, 0x43, 0x59, 0x1e, 0x9d, 0xa3, 0x90, 0xa5, 0x24, 0x21, 0x4b, 0x04, 0xa5, 0x66,
0xe2, 0x28, 0x75, 0x1d, 0xca, 0x2c, 0x94, 0x8c, 0x01, 0x50, 0xec, 0xf8, 0x00, 0x14, 0x7d, 0x00,
0xab, 0x1c, 0x43, 0x08, 0x2c, 0x2b, 0xe3, 0x47, 0x8e, 0x07, 0xc3, 0x15, 0xf6, 0x41, 0x1c, 0x5d,
0x11, 0x48, 0xfe, 0x1f, 0x2e, 0x44, 0x78, 0x83, 0x10, 0x25, 0x90, 0x56, 0x2d, 0xe0, 0xde, 0x92,
0xb1, 0xea, 0x71, 0x68, 0xa0, 0x10, 0xdc, 0x22, 0xc8, 0xe9, 0xb6, 0x41, 0x64, 0x00, 0xe1, 0x6d,
0x06, 0x78, 0xfb, 0x76, 0x57, 0x86, 0x09, 0xd6, 0x64, 0x5c, 0x81, 0x4f, 0x2d, 0x09, 0x67, 0xa9,
0xfc, 0x29, 0x1d, 0xea, 0x0b, 0xf1, 0xee, 0x24, 0x68, 0x9a, 0x7e, 0x93, 0xd0, 0x34, 0xf3, 0xdf,
0x41, 0x53, 0xe5, 0xd7, 0x99, 0x70, 0x4b, 0x03, 0xd0, 0xf9, 0xed, 0x4c, 0x10, 0x86, 0xdf, 0x25,
0xbe, 0x41, 0x32, 0xfc, 0xca, 0x7c, 0x21, 0xcf, 0xb7, 0x21, 0x9e, 0x2f, 0x14, 0x44, 0x40, 0xe6,
0x1d, 0x96, 0x18, 0x3b, 0xae, 0x6d, 0x1f, 0x6b, 0xb6, 0xe3, 0x4d, 0xca, 0xf8, 0x05, 0xde, 0x14,
0x25, 0xa2, 0xa6, 0x28, 0x2e, 0x35, 0xf7, 0x99, 0xc0, 0x9e, 0xe3, 0xa9, 0x45, 0x47, 0xb6, 0x22,
0x30, 0xa3, 0x14, 0xc3, 0xc2, 0xef, 0x42, 0x89, 0x2d, 0xc5, 0x73, 0xb0, 0x4e, 0xb8, 0x93, 0x2d,
0xa9, 0x21, 0x41, 0x31, 0x00, 0x9d, 0x77, 0xf6, 0xe8, 0x09, 0xe4, 0xc9, 0x29, 0xb1, 0x28, 0xdb,
0x33, 0x66, 0xe6, 0x77, 0xa7, 0x82, 0x4b, 0x62, 0xd1, 0x56, 0x9d, 0x19, 0xf7, 0x5f, 0xdf, 0xac,
0xd7, 0x84, 0xcc, 0x2d, 0x7b, 0x60, 0x52, 0x32, 0x70, 0xe8, 0x48, 0x95, 0x5a, 0x94, 0xdf, 0x64,
0x18, 0xc6, 0x8b, 0x05, 0x82, 0x89, 0xe6, 0xf6, 0x2f, 0x51, 0x26, 0x82, 0xfb, 0x93, 0x6d, 0xc1,
0x7b, 0x00, 0x5d, 0xec, 0x69, 0x2f, 0xb0, 0x45, 0x89, 0x21, 0xf7, 0xa1, 0xd4, 0xc5, 0xde, 0x8f,
0x39, 0x81, 0x41, 0x37, 0xf6, 0x79, 0xe8, 0x11, 0x83, 0x6f, 0x48, 0x56, 0x2d, 0x74, 0xb1, 0x77,
0xe4, 0x11, 0x23, 0xb2, 0xd6, 0xc2, 0x9b, 0x58, 0x6b, 0xdc, 0xde, 0xc5, 0x71, 0x7b, 0xff, 0x36,
0x13, 0xde, 0x96, 0x10, 0x12, 0xff, 0x6f, 0xda, 0xe2, 0x0f, 0x3c, 0x51, 0x8e, 0x47, 0x63, 0xf4,
0x29, 0xac, 0x06, 0xb7, 0x54, 0x1b, 0xf2, 0xdb, 0xeb, 0x9f, 0xc2, 0xc5, 0x2e, 0x7b, 0xed, 0x34,
0x4e, 0xf6, 0xd0, 0x67, 0xf0, 0xf6, 0x98, 0x4f, 0x0a, 0x06, 0xc8, 0x2c, 0xe4, 0x9a, 0xde, 0x8a,
0xbb, 0x26, 0x5f, 0x7f, 0x68, 0xbd, 0xec, 0x1b, 0xb9, 0x35, 0xbb, 0x2c, 0x2d, 0x8b, 0xe2, 0x8c,
0x89, 0x67, 0xe2, 0x0a, 0x54, 0x5c, 0x42, 0xb1, 0x69, 0x69, 0xb1, 0x54, 0x78, 0x59, 0x10, 0x45,
0x88, 0x50, 0x9e, 0xc1, 0x5b, 0x13, 0x91, 0x06, 0xfa, 0x1e, 0x94, 0x42, 0xa8, 0x92, 0x9e, 0x99,
0x49, 0x06, 0x19, 0x51, 0x28, 0xa1, 0x7c, 0x99, 0x0e, 0x15, 0xc7, 0x33, 0xad, 0x87, 0x90, 0x77,
0x89, 0x37, 0xec, 0x8b, 0xac, 0xa7, 0xba, 0xf9, 0xc9, 0x22, 0x48, 0x85, 0x51, 0x87, 0x7d, 0xaa,
0x4a, 0x15, 0xca, 0x53, 0xc8, 0x0b, 0x0a, 0x02, 0xc8, 0x6f, 0x6d, 0x6f, 0xef, 0xec, 0x1f, 0xd6,
0x52, 0xa8, 0x04, 0x4b, 0x5b, 0xad, 0x3d, 0xf5, 0xb0, 0x96, 0x66, 0x64, 0x75, 0xe7, 0x47, 0x3b,
0xdb, 0x87, 0xb5, 0x0c, 0x5a, 0x85, 0x8a, 0x68, 0x6b, 0x0f, 0xf6, 0xd4, 0xc7, 0x5b, 0x87, 0xb5,
0x6c, 0x84, 0x74, 0xb0, 0xf3, 0xe4, 0xfe, 0x8e, 0x5a, 0xcb, 0x29, 0x1f, 0xb3, 0x7c, 0x6a, 0x0a,
0x90, 0x09, 0x33, 0xa7, 0x74, 0x24, 0x73, 0x52, 0x7e, 0x97, 0x81, 0xc6, 0x74, 0x5c, 0x82, 0xf6,
0xc7, 0x56, 0x7c, 0x7b, 0x61, 0x68, 0x33, 0xb6, 0x6c, 0x74, 0x15, 0xaa, 0x2e, 0x39, 0x26, 0x54,
0xef, 0x09, 0xcc, 0x24, 0xa2, 0x5e, 0x45, 0xad, 0x48, 0x2a, 0x17, 0xf2, 0x04, 0xdb, 0xe7, 0x44,
0xa7, 0x9a, 0x48, 0xe5, 0xc4, 0xf9, 0x2b, 0x31, 0x36, 0x46, 0x3d, 0x10, 0x44, 0xe5, 0x60, 0x9e,
0x11, 0x4b, 0xb0, 0xa4, 0xee, 0x1c, 0xaa, 0x9f, 0xd6, 0x32, 0x08, 0x41, 0x95, 0x37, 0xb5, 0x83,
0x27, 0x5b, 0xfb, 0x07, 0xed, 0x3d, 0x66, 0xc4, 0x0b, 0xb0, 0xe2, 0x1b, 0xd1, 0x27, 0xe6, 0x94,
0xbf, 0xa6, 0x61, 0x65, 0xec, 0x7a, 0xa0, 0xdb, 0xb0, 0x24, 0x80, 0x78, 0x7a, 0x66, 0x41, 0x9f,
0xdf, 0x77, 0x79, 0xa3, 0x84, 0x00, 0x6a, 0x41, 0x91, 0xc8, 0x7a, 0xc5, 0xa4, 0x2b, 0x19, 0xad,
0xbc, 0xf8, 0x75, 0x0d, 0xa9, 0x20, 0x90, 0x63, 0xe1, 0x34, 0xb8, 0xf9, 0x32, 0x73, 0xbc, 0x3e,
0x4d, 0x49, 0xe0, 0x39, 0xa4, 0x96, 0x50, 0x52, 0xd9, 0x86, 0x72, 0x64, 0x82, 0xe8, 0xff, 0xa0,
0x34, 0xc0, 0x67, 0xb2, 0x86, 0x25, 0x8a, 0x12, 0xc5, 0x01, 0x3e, 0xe3, 0xe5, 0x2b, 0xf4, 0x36,
0x14, 0xd8, 0xc7, 0x2e, 0x16, 0x8e, 0x24, 0xab, 0xe6, 0x07, 0xf8, 0xec, 0x87, 0xd8, 0x53, 0x74,
0xa8, 0xc6, 0x4b, 0x3b, 0xec, 0x64, 0xb9, 0xf6, 0xd0, 0x32, 0xb8, 0x8e, 0x25, 0x55, 0x74, 0xd0,
0x5d, 0x58, 0x3a, 0xb5, 0x85, 0x1f, 0x9a, 0x75, 0x03, 0x9f, 0xd9, 0x94, 0x44, 0x0a, 0x44, 0x42,
0x46, 0x79, 0x02, 0x55, 0xee, 0x51, 0xb6, 0x28, 0x75, 0xcd, 0xce, 0x90, 0x92, 0x68, 0xa5, 0x72,
0x79, 0x42, 0xa5, 0x32, 0x40, 0x1e, 0x01, 0x6e, 0xc9, 0x8a, 0x32, 0x19, 0xef, 0x28, 0xbf, 0x4c,
0xc3, 0x12, 0x57, 0xc8, 0xdc, 0x0d, 0xaf, 0xfa, 0x48, 0x4c, 0xcb, 0xda, 0x48, 0x07, 0xc0, 0xfe,
0x40, 0xfe, 0x7c, 0xaf, 0xce, 0x72, 0x74, 0xc1, 0xb4, 0x5a, 0xef, 0x4a, 0x8f, 0x77, 0x31, 0x54,
0x10, 0xf1, 0x7a, 0x11, 0xb5, 0xca, 0xcb, 0x34, 0x14, 0x0f, 0xcf, 0xe4, 0x69, 0x9d, 0x52, 0x0c,
0x62, 0xb3, 0xdf, 0xe5, 0xb3, 0x17, 0xe5, 0x13, 0xd1, 0x91, 0xd5, 0xa5, 0x6c, 0x50, 0xb9, 0x7a,
0x10, 0xdc, 0xca, 0xdc, 0x62, 0x09, 0xa6, 0x5f, 0xd4, 0x93, 0x2e, 0xa8, 0x0f, 0x05, 0x7e, 0x1e,
0x76, 0xef, 0x4f, 0xac, 0x18, 0x3e, 0x86, 0x65, 0x07, 0xbb, 0xd4, 0xd3, 0x62, 0x75, 0xc3, 0x69,
0x39, 0xfa, 0x3e, 0x76, 0xe9, 0x01, 0xa1, 0xb1, 0xea, 0x61, 0x99, 0xcb, 0x0b, 0x92, 0x72, 0x07,
0x2a, 0x31, 0x1e, 0xb6, 0x58, 0x6a, 0x53, 0xdc, 0xf7, 0xcf, 0x0d, 0xef, 0x04, 0x33, 0xc9, 0x84,
0x33, 0x51, 0xee, 0x42, 0x29, 0x38, 0xd6, 0x2c, 0x03, 0xc1, 0x86, 0xe1, 0x12, 0xcf, 0x93, 0xb3,
0xf5, 0xbb, 0xbc, 0x44, 0x6a, 0xbf, 0x90, 0x55, 0xa0, 0xac, 0x2a, 0x3a, 0x8a, 0x0d, 0x2b, 0x63,
0xd1, 0x14, 0x3d, 0x80, 0x82, 0x33, 0xec, 0x68, 0xfe, 0x81, 0x9a, 0x78, 0x9b, 0x24, 0x38, 0x3d,
0x21, 0x23, 0xaf, 0xb9, 0x3f, 0xec, 0xf4, 0x4d, 0xfd, 0x21, 0x19, 0xf9, 0x06, 0x74, 0x86, 0x9d,
0x87, 0xe2, 0x08, 0x8a, 0x01, 0x33, 0xd1, 0x01, 0x7f, 0x01, 0x45, 0xff, 0x54, 0xa3, 0xfb, 0xd1,
0x9b, 0x2b, 0xc6, 0xba, 0x3c, 0x2f, 0xe4, 0xcb, 0x41, 0x42, 0x41, 0x96, 0x39, 0x79, 0x66, 0xd7,
0x22, 0x86, 0x16, 0x26, 0x45, 0x7c, 0xcc, 0xa2, 0xba, 0x22, 0x3e, 0x3c, 0xf2, 0x33, 0x22, 0xe5,
0x9f, 0x69, 0x28, 0xfa, 0x8e, 0x64, 0xe2, 0x69, 0x8f, 0x4d, 0x29, 0xf3, 0x6d, 0xa7, 0x34, 0xad,
0x4c, 0xed, 0x3f, 0x0a, 0xe4, 0x16, 0x7e, 0x14, 0xb8, 0x05, 0x88, 0x9f, 0x00, 0xed, 0xd4, 0xa6,
0xa6, 0xd5, 0xd5, 0x84, 0x65, 0x05, 0xd4, 0xab, 0xf1, 0x2f, 0xcf, 0xf8, 0x87, 0x7d, 0x6e, 0xe4,
0x5f, 0xa5, 0xa1, 0x18, 0x04, 0xe6, 0x45, 0xcb, 0x91, 0x97, 0x20, 0x2f, 0x83, 0x8f, 0xa8, 0x47,
0xca, 0x5e, 0x70, 0xf6, 0x72, 0x91, 0x5b, 0xd0, 0x80, 0xe2, 0x80, 0x50, 0xcc, 0x31, 0x8a, 0x48,
0x3f, 0x83, 0xfe, 0x07, 0x57, 0xa0, 0x1c, 0xa9, 0x0f, 0xa3, 0x02, 0x64, 0x9f, 0x90, 0x17, 0xb5,
0x14, 0x2a, 0x43, 0x41, 0x25, 0xbc, 0x24, 0x54, 0x4b, 0x6f, 0x7e, 0x59, 0x86, 0x95, 0xad, 0xd6,
0xf6, 0x2e, 0x8b, 0x8d, 0xa6, 0x8e, 0x79, 0x6a, 0xba, 0x07, 0x39, 0x9e, 0x9d, 0x27, 0x78, 0x8f,
0x6e, 0x24, 0xa9, 0x2f, 0x22, 0x15, 0x96, 0x78, 0x12, 0x8f, 0x92, 0x3c, 0x53, 0x37, 0x12, 0x95,
0x1d, 0xd9, 0x24, 0xf9, 0x19, 0x4e, 0xf0, 0x7a, 0xdd, 0x48, 0x52, 0x8b, 0x44, 0x9f, 0x41, 0x29,
0xcc, 0xce, 0x93, 0xbe, 0x69, 0x37, 0x12, 0x57, 0x29, 0x99, 0xfe, 0x30, 0xff, 0x48, 0xfa, 0xa2,
0xdb, 0x48, 0xec, 0x3d, 0xd1, 0x73, 0x28, 0xf8, 0x99, 0x5e, 0xb2, 0x57, 0xe7, 0x46, 0xc2, 0x0a,
0x22, 0xdb, 0x3e, 0x91, 0xb0, 0x27, 0x79, 0x5a, 0x6f, 0x24, 0x2a, 0x93, 0xa2, 0x23, 0xc8, 0x4b,
0x88, 0x9d, 0xe8, 0x3d, 0xb9, 0x91, 0xac, 0x2e, 0xc8, 0x8c, 0x1c, 0x96, 0x44, 0x92, 0xfe, 0x9d,
0xa0, 0x91, 0xb8, 0x3e, 0x8c, 0x30, 0x40, 0x24, 0x6b, 0x4f, 0xfc, 0x3f, 0x81, 0x46, 0xf2, 0xba,
0x2f, 0xfa, 0x29, 0x14, 0x83, 0xdc, 0x2c, 0xe1, 0x7b, 0x7d, 0x23, 0x69, 0xe9, 0x15, 0x7d, 0x0e,
0x95, 0x78, 0x3a, 0xb2, 0xc8, 0x2b, 0x7c, 0x63, 0xa1, 0x9a, 0x2a, 0x1b, 0x2b, 0x9e, 0xa1, 0x2c,
0xf2, 0x36, 0xdf, 0x58, 0xa8, 0xd0, 0x8a, 0x4e, 0x61, 0xf5, 0x7c, 0x52, 0xb1, 0xe8, 0x83, 0x7d,
0x63, 0xe1, 0x02, 0x2c, 0x1a, 0x01, 0x9a, 0x90, 0x98, 0x2c, 0xfc, 0x8a, 0xdf, 0x58, 0xbc, 0x2a,
0xdb, 0xda, 0xf9, 0xea, 0xd5, 0x5a, 0xfa, 0xeb, 0x57, 0x6b, 0xe9, 0x7f, 0xbc, 0x5a, 0x4b, 0xbf,
0x7c, 0xbd, 0x96, 0xfa, 0xfa, 0xf5, 0x5a, 0xea, 0x6f, 0xaf, 0xd7, 0x52, 0x3f, 0xf9, 0xb0, 0x6b,
0xd2, 0xde, 0xb0, 0xd3, 0xd4, 0xed, 0xc1, 0x46, 0xa8, 0x36, 0xda, 0x0c, 0xff, 0x6d, 0xd5, 0xc9,
0xf3, 0xe0, 0xf7, 0xc9, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x75, 0x7a, 0xc6, 0x83, 0x82, 0x25,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -6569,43 +6518,6 @@ func (m *VoteInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *PubKey) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PubKey) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *PubKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Data) > 0 {
i -= len(m.Data)
copy(dAtA[i:], m.Data)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Data)))
i--
dAtA[i] = 0x12
}
if len(m.Type) > 0 {
i -= len(m.Type)
copy(dAtA[i:], m.Type)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Type)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Evidence) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -7903,23 +7815,6 @@ func (m *VoteInfo) Size() (n int) {
return n
}
func (m *PubKey) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Type)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = len(m.Data)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
return n
}
func (m *Evidence) Size() (n int) {
if m == nil {
return 0
@ -14477,125 +14372,6 @@ func (m *VoteInfo) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *PubKey) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PubKey: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PubKey: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Type = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
if m.Data == nil {
m.Data = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Evidence) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0


+ 3
- 7
abci/types/types.proto View File

@ -6,6 +6,7 @@ option go_package = "github.com/tendermint/tendermint/abci/types";
// https://github.com/gogo/protobuf/blob/master/extensions.md
import "proto/crypto/merkle/types.proto";
import "proto/types/types.proto";
import "proto/crypto/keys/types.proto";
import "proto/types/params.proto";
import "google/protobuf/timestamp.proto";
import "third_party/proto/gogoproto/gogo.proto";
@ -341,8 +342,8 @@ message Validator {
// ValidatorUpdate
message ValidatorUpdate {
PubKey pub_key = 1 [(gogoproto.nullable) = false];
int64 power = 2;
tendermint.proto.crypto.keys.PublicKey pub_key = 1 [(gogoproto.nullable) = false];
int64 power = 2;
}
// VoteInfo
@ -351,11 +352,6 @@ message VoteInfo {
bool signed_last_block = 2;
}
message PubKey {
string type = 1;
bytes data = 2;
}
message Evidence {
string type = 1;
Validator validator = 2 [(gogoproto.nullable) = false];


+ 1
- 2
abci/types/util.go View File

@ -1,7 +1,6 @@
package types
import (
"bytes"
"sort"
)
@ -24,7 +23,7 @@ func (v ValidatorUpdates) Len() int {
// XXX: doesn't distinguish same validator with different power
func (v ValidatorUpdates) Less(i, j int) bool {
return bytes.Compare(v[i].PubKey.Data, v[j].PubKey.Data) <= 0
return v[i].PubKey.Compare(v[j].PubKey) <= 0
}
func (v ValidatorUpdates) Swap(i, j int) {


+ 13
- 6
consensus/reactor_test.go View File

@ -21,6 +21,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cfg "github.com/tendermint/tendermint/config"
cstypes "github.com/tendermint/tendermint/consensus/types"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/crypto/tmhash"
"github.com/tendermint/tendermint/libs/bits"
"github.com/tendermint/tendermint/libs/bytes"
@ -361,7 +362,9 @@ func TestReactorVotingPowerChange(t *testing.T) {
val1PubKey, err := css[0].privValidator.GetPubKey()
require.NoError(t, err)
val1PubKeyABCI := types.TM2PB.PubKey(val1PubKey)
val1PubKeyABCI, err := cryptoenc.PubKeyToProto(val1PubKey)
require.NoError(t, err)
updateValidatorTx := kvstore.MakeValSetChangeTx(val1PubKeyABCI, 25)
previousTotalVotingPower := css[0].GetRoundState().LastValidators.TotalVotingPower()
@ -441,8 +444,9 @@ func TestReactorValidatorSetChanges(t *testing.T) {
logger.Info("---------------------------- Testing adding one validator")
newValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
valPubKey1ABCI := types.TM2PB.PubKey(newValidatorPubKey1)
assert.NoError(t, err)
valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1)
assert.NoError(t, err)
newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
// wait till everyone makes block 2
@ -470,7 +474,8 @@ func TestReactorValidatorSetChanges(t *testing.T) {
updateValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
updatePubKey1ABCI := types.TM2PB.PubKey(updateValidatorPubKey1)
updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1)
require.NoError(t, err)
updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
previousTotalVotingPower := css[nVals].GetRoundState().LastValidators.TotalVotingPower()
@ -491,12 +496,14 @@ func TestReactorValidatorSetChanges(t *testing.T) {
newValidatorPubKey2, err := css[nVals+1].privValidator.GetPubKey()
require.NoError(t, err)
newVal2ABCI := types.TM2PB.PubKey(newValidatorPubKey2)
newVal2ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey2)
require.NoError(t, err)
newValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, testMinPower)
newValidatorPubKey3, err := css[nVals+2].privValidator.GetPubKey()
require.NoError(t, err)
newVal3ABCI := types.TM2PB.PubKey(newValidatorPubKey3)
newVal3ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey3)
require.NoError(t, err)
newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, newValidatorTx2, newValidatorTx3)


+ 9
- 4
consensus/replay_test.go View File

@ -22,6 +22,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/libs/log"
tmrand "github.com/tendermint/tendermint/libs/rand"
mempl "github.com/tendermint/tendermint/mempool"
@ -351,7 +352,8 @@ func TestSimulateValidatorsChange(t *testing.T) {
incrementHeight(vss...)
newValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
valPubKey1ABCI := types.TM2PB.PubKey(newValidatorPubKey1)
valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1)
require.NoError(t, err)
newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx1, nil, mempl.TxInfo{})
assert.Nil(t, err)
@ -379,7 +381,8 @@ func TestSimulateValidatorsChange(t *testing.T) {
incrementHeight(vss...)
updateValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
updatePubKey1ABCI := types.TM2PB.PubKey(updateValidatorPubKey1)
updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1)
require.NoError(t, err)
updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
err = assertMempool(css[0].txNotifier).CheckTx(updateValidatorTx1, nil, mempl.TxInfo{})
assert.Nil(t, err)
@ -407,13 +410,15 @@ func TestSimulateValidatorsChange(t *testing.T) {
incrementHeight(vss...)
newValidatorPubKey2, err := css[nVals+1].privValidator.GetPubKey()
require.NoError(t, err)
newVal2ABCI := types.TM2PB.PubKey(newValidatorPubKey2)
newVal2ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey2)
require.NoError(t, err)
newValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, testMinPower)
err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx2, nil, mempl.TxInfo{})
assert.Nil(t, err)
newValidatorPubKey3, err := css[nVals+2].privValidator.GetPubKey()
require.NoError(t, err)
newVal3ABCI := types.TM2PB.PubKey(newValidatorPubKey3)
newVal3ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey3)
require.NoError(t, err)
newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx3, nil, mempl.TxInfo{})
assert.Nil(t, err)


+ 2
- 0
crypto/crypto.go View File

@ -24,6 +24,7 @@ type PubKey interface {
Bytes() []byte
VerifyBytes(msg []byte, sig []byte) bool
Equals(PubKey) bool
Type() string
}
type PrivKey interface {
@ -31,6 +32,7 @@ type PrivKey interface {
Sign(msg []byte) ([]byte, error)
PubKey() PubKey
Equals(PrivKey) bool
Type() string
}
type Symmetric interface {


+ 10
- 0
crypto/ed25519/ed25519.go View File

@ -30,6 +30,8 @@ const (
// SeedSize is the size, in bytes, of private key seeds. These are the
// private key representations used by RFC 8032.
SeedSize = 32
keyType = "ed25519"
)
func init() {
@ -90,6 +92,10 @@ func (privKey PrivKey) Equals(other crypto.PrivKey) bool {
return false
}
func (privKey PrivKey) Type() string {
return keyType
}
// GenPrivKey generates a new ed25519 private key.
// It uses OS randomness in conjunction with the current global random seed
// in tendermint/libs/common to generate the private key.
@ -151,6 +157,10 @@ func (pubKey PubKey) String() string {
return fmt.Sprintf("PubKeyEd25519{%X}", []byte(pubKey))
}
func (pubKey PubKey) Type() string {
return keyType
}
func (pubKey PubKey) Equals(other crypto.PubKey) bool {
if otherEd, ok := other.(PubKey); ok {
return bytes.Equal(pubKey[:], otherEd[:])


+ 3
- 0
crypto/encoding/amino/encode_test.go View File

@ -160,6 +160,7 @@ func (privkey testPriv) Bytes() []byte {
}
func (privkey testPriv) Sign(msg []byte) ([]byte, error) { return []byte{}, nil }
func (privkey testPriv) Equals(other crypto.PrivKey) bool { return true }
func (privkey testPriv) Type() string { return "testPriv" }
type testPub []byte
@ -169,6 +170,8 @@ func (key testPub) Bytes() []byte {
}
func (key testPub) VerifyBytes(msg []byte, sig []byte) bool { return true }
func (key testPub) Equals(other crypto.PubKey) bool { return true }
func (key testPub) String() string { return "" }
func (key testPub) Type() string { return "testPub" }
var (
privAminoName = "registerTest/Priv"


+ 12
- 1
crypto/secp256k1/secp256k1.go View File

@ -16,7 +16,10 @@ import (
var _ crypto.PrivKey = PrivKey{}
const PrivKeySize = 32
const (
PrivKeySize = 32
keyType = "secp256k1"
)
// PrivKey implements PrivKey.
type PrivKey []byte
@ -42,6 +45,10 @@ func (privKey PrivKey) Equals(other crypto.PrivKey) bool {
return false
}
func (privKey PrivKey) Type() string {
return keyType
}
// GenPrivKey generates a new ECDSA private key on curve secp256k1 private key.
// It uses OS randomness to generate the private key.
func GenPrivKey() PrivKey {
@ -140,6 +147,10 @@ func (pubKey PubKey) String() string {
return fmt.Sprintf("PubKeySecp256k1{%X}", []byte(pubKey))
}
func (pubKey PubKey) Type() string {
return keyType
}
func (pubKey PubKey) Equals(other crypto.PubKey) bool {
if otherSecp, ok := other.(PubKey); ok {
return bytes.Equal(pubKey[:], otherSecp[:])


+ 4
- 0
crypto/sr25519/privkey.go View File

@ -69,6 +69,10 @@ func (privKey PrivKey) Equals(other crypto.PrivKey) bool {
return false
}
func (privKey PrivKey) Type() string {
return keyType
}
// GenPrivKey generates a new sr25519 private key.
// It uses OS randomness in conjunction with the current global random seed
// in tendermint/libs/common to generate the private key.


+ 9
- 1
crypto/sr25519/pubkey.go View File

@ -13,7 +13,10 @@ import (
var _ crypto.PubKey = PubKey{}
// PubKeySize is the number of bytes in an Sr25519 public key.
const PubKeySize = 32
const (
PubKeySize = 32
keyType = "sr25519"
)
// PubKeySr25519 implements crypto.PubKey for the Sr25519 signature scheme.
type PubKey []byte
@ -67,3 +70,8 @@ func (pubKey PubKey) Equals(other crypto.PubKey) bool {
}
return false
}
func (pubKey PubKey) Type() string {
return keyType
}

+ 1
- 0
p2p/conn/secret_connection_test.go View File

@ -51,6 +51,7 @@ func (pk privKeyWithNilPubKey) Bytes() []byte { return pk.orig
func (pk privKeyWithNilPubKey) Sign(msg []byte) ([]byte, error) { return pk.orig.Sign(msg) }
func (pk privKeyWithNilPubKey) PubKey() crypto.PubKey { return nil }
func (pk privKeyWithNilPubKey) Equals(pk2 crypto.PrivKey) bool { return pk.orig.Equals(pk2) }
func (pk privKeyWithNilPubKey) Type() string { return "privKeyWithNilPubKey" }
func TestSecretConnectionHandshake(t *testing.T) {
fooSecConn, barSecConn := makeSecretConnPair(t)


+ 6
- 13
proto/crypto/keys/types.pb.go View File

@ -8,7 +8,6 @@ import (
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
golang_proto "github.com/golang/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
@ -16,7 +15,6 @@ import (
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
@ -177,18 +175,13 @@ func (*PrivateKey) XXX_OneofWrappers() []interface{} {
func init() {
proto.RegisterType((*PublicKey)(nil), "tendermint.proto.crypto.keys.PublicKey")
golang_proto.RegisterType((*PublicKey)(nil), "tendermint.proto.crypto.keys.PublicKey")
proto.RegisterType((*PrivateKey)(nil), "tendermint.proto.crypto.keys.PrivateKey")
golang_proto.RegisterType((*PrivateKey)(nil), "tendermint.proto.crypto.keys.PrivateKey")
}
func init() { proto.RegisterFile("proto/crypto/keys/types.proto", fileDescriptor_943d79b57ec0188f) }
func init() {
golang_proto.RegisterFile("proto/crypto/keys/types.proto", fileDescriptor_943d79b57ec0188f)
}
var fileDescriptor_943d79b57ec0188f = []byte{
// 220 bytes of a gzipped FileDescriptorProto
// 215 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2d, 0x28, 0xca, 0x2f,
0xc9, 0xd7, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0xcf, 0x4e, 0xad, 0x2c, 0xd6, 0x2f, 0xa9,
0x2c, 0x48, 0x2d, 0xd6, 0x03, 0x8b, 0x0b, 0xc9, 0x94, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66,
@ -198,11 +191,11 @@ var fileDescriptor_943d79b57ec0188f = []byte{
0x52, 0x5c, 0xec, 0xa9, 0x29, 0x46, 0xa6, 0xa6, 0x86, 0x96, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c,
0x1e, 0x0c, 0x41, 0x30, 0x01, 0x2b, 0x8e, 0x17, 0x0b, 0xe4, 0x19, 0x5f, 0x2c, 0x94, 0x67, 0x74,
0x62, 0xe5, 0x62, 0x2e, 0x2e, 0xcd, 0x55, 0xd2, 0xe7, 0xe2, 0x0a, 0x28, 0xca, 0x2c, 0x4b, 0x2c,
0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0x29, 0xe0, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc0, 0x63, 0x39, 0xc6, 0x0b, 0x8f, 0xe5,
0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce,
0xcf, 0xd5, 0x47, 0xf8, 0x0c, 0x99, 0x89, 0x11, 0x1c, 0x49, 0x6c, 0x60, 0x21, 0x63, 0x40, 0x00,
0x00, 0x00, 0xff, 0xff, 0xc1, 0xcf, 0x98, 0xcb, 0x2a, 0x01, 0x00, 0x00,
0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0xc9, 0xe7, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5,
0x18, 0xa2, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x11, 0xbe,
0x42, 0x66, 0x62, 0x04, 0x45, 0x12, 0x1b, 0x58, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x85,
0x0d, 0xee, 0x82, 0x26, 0x01, 0x00, 0x00,
}
func (this *PublicKey) Compare(that interface{}) int {


+ 0
- 5
proto/crypto/keys/types.proto View File

@ -5,11 +5,6 @@ option go_package = "github.com/tendermint/tendermint/proto/crypto/keys";
import "third_party/proto/gogoproto/gogo.proto";
option (gogoproto.marshaler_all) = true;
option (gogoproto.unmarshaler_all) = true;
option (gogoproto.sizer_all) = true;
option (gogoproto.goproto_registration) = true;
// PublicKey defines the keys available for use with Tendermint Validators
message PublicKey {
option (gogoproto.compare) = true;


+ 1
- 1
proto/crypto/merkle/types.pb.go View File

@ -154,7 +154,7 @@ func (m *ProofOp) GetData() []byte {
return nil
}
// Proof is Merkle proof defined by the list of ProofOps
// ProofOps is Merkle proof defined by the list of ProofOps
type ProofOps struct {
Ops []ProofOp `protobuf:"bytes,1,rep,name=ops,proto3" json:"ops"`
}


+ 7
- 2
rpc/client/evidence_test.go View File

@ -11,6 +11,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/crypto/tmhash"
"github.com/tendermint/tendermint/privval"
tmproto "github.com/tendermint/tendermint/proto/types"
@ -122,7 +123,8 @@ func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) {
status, err := c.Status()
require.NoError(t, err)
client.WaitForHeight(c, status.SyncInfo.LatestBlockHeight+2, nil)
err = client.WaitForHeight(c, status.SyncInfo.LatestBlockHeight+2, nil)
require.NoError(t, err)
ed25519pub := pv.Key.PubKey.(ed25519.PubKey)
rawpub := ed25519pub.Bytes()
@ -135,7 +137,10 @@ func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) {
err = abci.ReadMessage(bytes.NewReader(qres.Value), &v)
require.NoError(t, err, "Error reading query result, value %v", qres.Value)
require.EqualValues(t, rawpub, v.PubKey.Data, "Stored PubKey not equal with expected, value %v", string(qres.Value))
pk, err := cryptoenc.PubKeyFromProto(v.PubKey)
require.NoError(t, err)
require.EqualValues(t, rawpub, pk.Bytes(), "Stored PubKey not equal with expected, value %v", string(qres.Value))
require.Equal(t, int64(9), v.Power, "Stored Power not equal with expected, value %v", string(qres.Value))
for _, fake := range fakes {


+ 1
- 0
rpc/client/helpers.go View File

@ -48,6 +48,7 @@ func WaitForHeight(c StatusClient, h int64, waiter Waiter) error {
return err
}
}
return nil
}


+ 3
- 0
rpc/client/http/http.go View File

@ -207,6 +207,7 @@ func (c *baseRPCClient) Status() (*ctypes.ResultStatus, error) {
if err != nil {
return nil, err
}
return result, nil
}
@ -216,6 +217,7 @@ func (c *baseRPCClient) ABCIInfo() (*ctypes.ResultABCIInfo, error) {
if err != nil {
return nil, err
}
return result, nil
}
@ -234,6 +236,7 @@ func (c *baseRPCClient) ABCIQueryWithOptions(
if err != nil {
return nil, err
}
return result, nil
}


+ 0
- 1
rpc/client/rpc_test.go View File

@ -13,7 +13,6 @@ import (
"github.com/stretchr/testify/require"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/libs/log"
tmmath "github.com/tendermint/tendermint/libs/math"
mempl "github.com/tendermint/tendermint/mempool"


+ 8
- 3
state/execution.go View File

@ -8,6 +8,7 @@ import (
dbm "github.com/tendermint/tm-db"
abci "github.com/tendermint/tendermint/abci/types"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/libs/fail"
"github.com/tendermint/tendermint/libs/log"
mempl "github.com/tendermint/tendermint/mempool"
@ -380,10 +381,14 @@ func validateValidatorUpdates(abciUpdates []abci.ValidatorUpdate,
}
// Check if validator's pubkey matches an ABCI type in the consensus params
thisKeyType := valUpdate.PubKey.Type
if !types.IsValidPubkeyType(params, thisKeyType) {
pk, err := cryptoenc.PubKeyFromProto(valUpdate.PubKey)
if err != nil {
return err
}
if !types.IsValidPubkeyType(params, pk.Type()) {
return fmt.Errorf("validator %v is using pubkey %s, which is unsupported for consensus",
valUpdate, thisKeyType)
valUpdate, pk.Type())
}
}
return nil


+ 24
- 38
state/execution_test.go View File

@ -11,7 +11,7 @@ import (
"github.com/tendermint/tendermint/abci/example/kvstore"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/ed25519"
"github.com/tendermint/tendermint/crypto/secp256k1"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/libs/log"
"github.com/tendermint/tendermint/mempool/mock"
tmproto "github.com/tendermint/tendermint/proto/types"
@ -175,8 +175,10 @@ func TestBeginBlockByzantineValidators(t *testing.T) {
func TestValidateValidatorUpdates(t *testing.T) {
pubkey1 := ed25519.GenPrivKey().PubKey()
pubkey2 := ed25519.GenPrivKey().PubKey()
secpKey := secp256k1.GenPrivKey().PubKey()
pk1, err := cryptoenc.PubKeyToProto(pubkey1)
assert.NoError(t, err)
pk2, err := cryptoenc.PubKeyToProto(pubkey2)
assert.NoError(t, err)
defaultValidatorParams := tmproto.ValidatorParams{PubKeyTypes: []string{types.ABCIPubKeyTypeEd25519}}
@ -190,42 +192,26 @@ func TestValidateValidatorUpdates(t *testing.T) {
}{
{
"adding a validator is OK",
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: 20}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: 20}},
defaultValidatorParams,
false,
},
{
"updating a validator is OK",
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey1), Power: 20}},
[]abci.ValidatorUpdate{{PubKey: pk1, Power: 20}},
defaultValidatorParams,
false,
},
{
"removing a validator is OK",
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: 0}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: 0}},
defaultValidatorParams,
false,
},
{
"adding a validator with negative power results in error",
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: -100}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: -100}},
defaultValidatorParams,
true,
},
{
"adding a validator with pubkey thats not in validator params results in error",
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(secpKey), Power: -100}},
defaultValidatorParams,
true,
},
}
@ -249,6 +235,11 @@ func TestUpdateValidators(t *testing.T) {
pubkey2 := ed25519.GenPrivKey().PubKey()
val2 := types.NewValidator(pubkey2, 20)
pk, err := cryptoenc.PubKeyToProto(pubkey1)
require.NoError(t, err)
pk2, err := cryptoenc.PubKeyToProto(pubkey2)
require.NoError(t, err)
testCases := []struct {
name string
@ -260,37 +251,29 @@ func TestUpdateValidators(t *testing.T) {
}{
{
"adding a validator is OK",
types.NewValidatorSet([]*types.Validator{val1}),
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: 20}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: 20}},
types.NewValidatorSet([]*types.Validator{val1, val2}),
false,
},
{
"updating a validator is OK",
types.NewValidatorSet([]*types.Validator{val1}),
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey1), Power: 20}},
[]abci.ValidatorUpdate{{PubKey: pk, Power: 20}},
types.NewValidatorSet([]*types.Validator{types.NewValidator(pubkey1, 20)}),
false,
},
{
"removing a validator is OK",
types.NewValidatorSet([]*types.Validator{val1, val2}),
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: 0}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: 0}},
types.NewValidatorSet([]*types.Validator{val1}),
false,
},
{
"removing a non-existing validator results in error",
types.NewValidatorSet([]*types.Validator{val1}),
[]abci.ValidatorUpdate{{PubKey: types.TM2PB.PubKey(pubkey2), Power: 0}},
[]abci.ValidatorUpdate{{PubKey: pk2, Power: 0}},
types.NewValidatorSet([]*types.Validator{val1}),
true,
},
@ -355,13 +338,14 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
pubkey := ed25519.GenPrivKey().PubKey()
pk, err := cryptoenc.PubKeyToProto(pubkey)
require.NoError(t, err)
app.ValidatorUpdates = []abci.ValidatorUpdate{
{PubKey: types.TM2PB.PubKey(pubkey), Power: 10},
{PubKey: pk, Power: 10},
}
state, _, err = blockExec.ApplyBlock(state, blockID, block)
require.Nil(t, err)
// test new validator was added to NextValidators
if assert.Equal(t, state.Validators.Size()+1, state.NextValidators.Size()) {
idx, _ := state.NextValidators.GetByAddress(pubkey.Address())
@ -408,9 +392,11 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
block := makeBlock(state, 1)
blockID := types.BlockID{Hash: block.Hash(), PartsHeader: block.MakePartSet(testPartSize).Header()}
vp, err := cryptoenc.PubKeyToProto(state.Validators.Validators[0].PubKey)
require.NoError(t, err)
// Remove the only validator
app.ValidatorUpdates = []abci.ValidatorUpdate{
{PubKey: types.TM2PB.PubKey(state.Validators.Validators[0].PubKey), Power: 0},
{PubKey: vp, Power: 0},
}
assert.NotPanics(t, func() { state, _, err = blockExec.ApplyBlock(state, blockID, block) })


+ 18
- 7
state/state_test.go View File

@ -17,6 +17,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
tmrand "github.com/tendermint/tendermint/libs/rand"
tmstate "github.com/tendermint/tendermint/proto/state"
tmproto "github.com/tendermint/tendermint/proto/types"
@ -432,7 +433,10 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) {
// add a validator
val2PubKey := ed25519.GenPrivKey().PubKey()
val2VotingPower := int64(100)
updateAddVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(val2PubKey), Power: val2VotingPower}
fvp, err := cryptoenc.PubKeyToProto(val2PubKey)
require.NoError(t, err)
updateAddVal := abci.ValidatorUpdate{PubKey: fvp, Power: val2VotingPower}
validatorUpdates, err = types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{updateAddVal})
assert.NoError(t, err)
updatedState2, err := sm.UpdateState(updatedState, blockID, &block.Header, abciResponses, validatorUpdates)
@ -468,7 +472,7 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) {
// Updating a validator does not reset the ProposerPriority to zero:
// 1. Add - Val2 VotingPower change to 1 =>
updatedVotingPowVal2 := int64(1)
updateVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(val2PubKey), Power: updatedVotingPowVal2}
updateVal := abci.ValidatorUpdate{PubKey: fvp, Power: updatedVotingPowVal2}
validatorUpdates, err = types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{updateVal})
assert.NoError(t, err)
@ -546,7 +550,9 @@ func TestProposerPriorityProposerAlternates(t *testing.T) {
// add a validator with the same voting power as the first
val2PubKey := ed25519.GenPrivKey().PubKey()
updateAddVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(val2PubKey), Power: val1VotingPower}
fvp, err := cryptoenc.PubKeyToProto(val2PubKey)
require.NoError(t, err)
updateAddVal := abci.ValidatorUpdate{PubKey: fvp, Power: val1VotingPower}
validatorUpdates, err = types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{updateAddVal})
assert.NoError(t, err)
@ -727,7 +733,9 @@ func TestLargeGenesisValidator(t *testing.T) {
// see: https://github.com/tendermint/tendermint/issues/2960
firstAddedValPubKey := ed25519.GenPrivKey().PubKey()
firstAddedValVotingPower := int64(10)
firstAddedVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(firstAddedValPubKey), Power: firstAddedValVotingPower}
fvp, err := cryptoenc.PubKeyToProto(firstAddedValPubKey)
require.NoError(t, err)
firstAddedVal := abci.ValidatorUpdate{PubKey: fvp, Power: firstAddedValVotingPower}
validatorUpdates, err := types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{firstAddedVal})
assert.NoError(t, err)
abciResponses := &tmstate.ABCIResponses{
@ -770,8 +778,9 @@ func TestLargeGenesisValidator(t *testing.T) {
// add 10 validators with the same voting power as the one added directly after genesis:
for i := 0; i < 10; i++ {
addedPubKey := ed25519.GenPrivKey().PubKey()
addedVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(addedPubKey), Power: firstAddedValVotingPower}
ap, err := cryptoenc.PubKeyToProto(addedPubKey)
require.NoError(t, err)
addedVal := abci.ValidatorUpdate{PubKey: ap, Power: firstAddedValVotingPower}
validatorUpdates, err := types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{addedVal})
assert.NoError(t, err)
@ -786,7 +795,9 @@ func TestLargeGenesisValidator(t *testing.T) {
require.Equal(t, 10+2, len(state.NextValidators.Validators))
// remove genesis validator:
removeGenesisVal := abci.ValidatorUpdate{PubKey: types.TM2PB.PubKey(genesisPubKey), Power: 0}
gp, err := cryptoenc.PubKeyToProto(genesisPubKey)
require.NoError(t, err)
removeGenesisVal := abci.ValidatorUpdate{PubKey: gp, Power: 0}
abciResponses = &tmstate.ABCIResponses{
EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{removeGenesisVal}},
}


+ 11
- 58
types/protobuf.go View File

@ -8,6 +8,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/crypto/secp256k1"
"github.com/tendermint/tendermint/crypto/sr25519"
tmproto "github.com/tendermint/tendermint/proto/types"
@ -89,36 +90,16 @@ func (tm2pb) PartSetHeader(header PartSetHeader) abci.PartSetHeader {
// XXX: panics on unknown pubkey type
func (tm2pb) ValidatorUpdate(val *Validator) abci.ValidatorUpdate {
pk, err := cryptoenc.PubKeyToProto(val.PubKey)
if err != nil {
panic(err)
}
return abci.ValidatorUpdate{
PubKey: TM2PB.PubKey(val.PubKey),
PubKey: pk,
Power: val.VotingPower,
}
}
// XXX: panics on nil or unknown pubkey type
// TODO: add cases when new pubkey types are added to crypto
func (tm2pb) PubKey(pubKey crypto.PubKey) abci.PubKey {
switch pk := pubKey.(type) {
case ed25519.PubKey:
return abci.PubKey{
Type: ABCIPubKeyTypeEd25519,
Data: pk[:],
}
case sr25519.PubKey:
return abci.PubKey{
Type: ABCIPubKeyTypeSr25519,
Data: pk[:],
}
case secp256k1.PubKey:
return abci.PubKey{
Type: ABCIPubKeyTypeSecp256k1,
Data: pk[:],
}
default:
panic(fmt.Sprintf("unknown pubkey type: %v %v", pubKey, reflect.TypeOf(pubKey)))
}
}
// XXX: panics on nil or unknown pubkey type
func (tm2pb) ValidatorUpdates(vals *ValidatorSet) []abci.ValidatorUpdate {
validators := make([]abci.ValidatorUpdate, vals.Size())
@ -179,7 +160,10 @@ func (tm2pb) Evidence(ev Evidence, valSet *ValidatorSet, evTime time.Time) abci.
// XXX: panics on nil or unknown pubkey type
func (tm2pb) NewValidatorUpdate(pubkey crypto.PubKey, power int64) abci.ValidatorUpdate {
pubkeyABCI := TM2PB.PubKey(pubkey)
pubkeyABCI, err := cryptoenc.PubKeyToProto(pubkey)
if err != nil {
panic(err)
}
return abci.ValidatorUpdate{
PubKey: pubkeyABCI,
Power: power,
@ -194,41 +178,10 @@ var PB2TM = pb2tm{}
type pb2tm struct{}
func (pb2tm) PubKey(pubKey abci.PubKey) (crypto.PubKey, error) {
switch pubKey.Type {
case ABCIPubKeyTypeEd25519:
if len(pubKey.Data) != ed25519.PubKeySize {
return nil, fmt.Errorf("invalid size for PubKeyEd25519. Got %d, expected %d",
len(pubKey.Data), ed25519.PubKeySize)
}
var pk = make(ed25519.PubKey, ed25519.PubKeySize)
copy(pk, pubKey.Data)
return pk, nil
case ABCIPubKeyTypeSr25519:
if len(pubKey.Data) != sr25519.PubKeySize {
return nil, fmt.Errorf("invalid size for PubKeySr25519. Got %d, expected %d",
len(pubKey.Data), sr25519.PubKeySize)
}
var pk = make(sr25519.PubKey, sr25519.PubKeySize)
copy(pk, pubKey.Data)
return pk, nil
case ABCIPubKeyTypeSecp256k1:
if len(pubKey.Data) != secp256k1.PubKeySize {
return nil, fmt.Errorf("invalid size for PubKeySecp256k1. Got %d, expected %d",
len(pubKey.Data), secp256k1.PubKeySize)
}
var pk = make(secp256k1.PubKey, secp256k1.PubKeySize)
copy(pk, pubKey.Data)
return pk, nil
default:
return nil, fmt.Errorf("unknown pubkey type %v", pubKey.Type)
}
}
func (pb2tm) ValidatorUpdates(vals []abci.ValidatorUpdate) ([]*Validator, error) {
tmVals := make([]*Validator, len(vals))
for i, v := range vals {
pub, err := PB2TM.PubKey(v.PubKey)
pub, err := cryptoenc.PubKeyFromProto(v.PubKey)
if err != nil {
return nil, err
}


+ 12
- 16
types/protobuf_test.go View File

@ -13,22 +13,23 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
"github.com/tendermint/tendermint/crypto/secp256k1"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/proto/version"
)
func TestABCIPubKey(t *testing.T) {
pkEd := ed25519.GenPrivKey().PubKey()
pkSecp := secp256k1.GenPrivKey().PubKey()
testABCIPubKey(t, pkEd, ABCIPubKeyTypeEd25519)
testABCIPubKey(t, pkSecp, ABCIPubKeyTypeSecp256k1)
err := testABCIPubKey(t, pkEd, ABCIPubKeyTypeEd25519)
assert.NoError(t, err)
}
func testABCIPubKey(t *testing.T, pk crypto.PubKey, typeStr string) {
abciPubKey := TM2PB.PubKey(pk)
pk2, err := PB2TM.PubKey(abciPubKey)
assert.Nil(t, err)
assert.Equal(t, pk, pk2)
func testABCIPubKey(t *testing.T, pk crypto.PubKey, typeStr string) error {
abciPubKey, err := cryptoenc.PubKeyToProto(pk)
require.NoError(t, err)
pk2, err := cryptoenc.PubKeyFromProto(abciPubKey)
require.NoError(t, err)
require.Equal(t, pk, pk2)
return nil
}
func TestABCIValidators(t *testing.T) {
@ -54,13 +55,6 @@ func TestABCIValidators(t *testing.T) {
tmVals, err = PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{abciVal})
assert.Nil(t, err)
assert.Equal(t, tmValExpected, tmVals[0])
// val with incorrect pubkey data
abciVal = TM2PB.ValidatorUpdate(tmVal)
abciVal.PubKey.Data = []byte("incorrect!")
tmVals, err = PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{abciVal})
assert.NotNil(t, err)
assert.Nil(t, tmVals)
}
func TestABCIConsensusParams(t *testing.T) {
@ -154,6 +148,8 @@ func (pubKeyEddie) Address() Address { return []byte{} }
func (pubKeyEddie) Bytes() []byte { return []byte{} }
func (pubKeyEddie) VerifyBytes(msg []byte, sig []byte) bool { return false }
func (pubKeyEddie) Equals(crypto.PubKey) bool { return false }
func (pubKeyEddie) String() string { return "" }
func (pubKeyEddie) Type() string { return "pubKeyEddie" }
func TestABCIValidatorFromPubKeyAndPower(t *testing.T) {
pubkey := ed25519.GenPrivKey().PubKey()


Write Preview
Loading…
Cancel
Save