Browse Source
Sdk2 kvpair (#102)
* Canonical KVPair in common * Simplify common/Bytes to just hex encodepull/1842/head
Jae Kwon
7 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 254 additions and 90 deletions
Split View
Diff Options
-
+53 -0common/bytes.go
-
+68 -0common/bytes_test.go
-
+30 -0common/kvpair.go
-
+23 -25glide.lock
-
+0 -48merkle/kvpairs.go
-
+69 -9merkle/simple_map.go
-
+6 -6merkle/simple_map_test.go
-
+5 -2merkle/simple_tree.go
+ 53
- 0
common/bytes.go
View File
| @ -0,0 +1,53 @@ | |||
| package common | |||
| import ( | |||
| "encoding/hex" | |||
| "fmt" | |||
| "strings" | |||
| ) | |||
| // The main purpose of Bytes is to enable HEX-encoding for json/encoding. | |||
| type Bytes []byte | |||
| // Marshal needed for protobuf compatibility | |||
| func (b Bytes) Marshal() ([]byte, error) { | |||
| return b, nil | |||
| } | |||
| // Unmarshal needed for protobuf compatibility | |||
| func (b *Bytes) Unmarshal(data []byte) error { | |||
| *b = data | |||
| return nil | |||
| } | |||
| // This is the point of Bytes. | |||
| func (b Bytes) MarshalJSON() ([]byte, error) { | |||
| s := strings.ToUpper(hex.EncodeToString(b)) | |||
| jb := make([]byte, len(s)+2) | |||
| jb[0] = '"' | |||
| copy(jb[1:], []byte(s)) | |||
| jb[1] = '"' | |||
| return jb, nil | |||
| } | |||
| // This is the point of Bytes. | |||
| func (b *Bytes) UnmarshalJSON(data []byte) error { | |||
| if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { | |||
| return fmt.Errorf("Invalid hex string: %s", data) | |||
| } | |||
| bytes, err := hex.DecodeString(string(data[1 : len(data)-1])) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| *b = bytes | |||
| return nil | |||
| } | |||
| // Allow it to fulfill various interfaces in light-client, etc... | |||
| func (b Bytes) Bytes() []byte { | |||
| return b | |||
| } | |||
| func (b Bytes) String() string { | |||
| return strings.ToUpper(hex.EncodeToString(b)) | |||
| } | |||
+ 68
- 0
common/bytes_test.go
View File
| @ -0,0 +1,68 @@ | |||
| package common | |||
| import ( | |||
| "encoding/json" | |||
| "fmt" | |||
| "testing" | |||
| "github.com/stretchr/testify/assert" | |||
| ) | |||
| // This is a trivial test for protobuf compatibility. | |||
| func TestMarshal(t *testing.T) { | |||
| assert := assert.New(t) | |||
| b := []byte("hello world") | |||
| dataB := Bytes(b) | |||
| b2, err := dataB.Marshal() | |||
| assert.Nil(err) | |||
| assert.Equal(b, b2) | |||
| var dataB2 Bytes | |||
| err = (&dataB2).Unmarshal(b) | |||
| assert.Nil(err) | |||
| assert.Equal(dataB, dataB2) | |||
| } | |||
| // Test that the hex encoding works. | |||
| func TestJSONMarshal(t *testing.T) { | |||
| assert := assert.New(t) | |||
| type TestStruct struct { | |||
| B1 []byte | |||
| B2 Bytes | |||
| } | |||
| cases := []struct { | |||
| input []byte | |||
| expected string | |||
| }{ | |||
| {[]byte(``), `{"B1":"","B2":""}`}, | |||
| {[]byte(``), `{"B1":"","B2":""}`}, | |||
| {[]byte(``), `{"B1":"","B2":""}`}, | |||
| } | |||
| for i, tc := range cases { | |||
| t.Run(fmt.Sprintf("Case %d", i), func(t *testing.T) { | |||
| ts := TestStruct{B1: tc.input, B2: tc.input} | |||
| // Test that it marshals correctly to JSON. | |||
| jsonBytes, err := json.Marshal(ts) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Equal(string(jsonBytes), tc.expected) | |||
| // TODO do fuzz testing to ensure that unmarshal fails | |||
| // Test that unmarshaling works correctly. | |||
| ts2 := TestStruct{} | |||
| err = json.Unmarshal(jsonBytes, &ts2) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| assert.Equal(ts2.B1, tc.input) | |||
| assert.Equal(ts2.B2, Bytes(tc.input)) | |||
| }) | |||
| } | |||
| } | |||
+ 30
- 0
common/kvpair.go
View File
| @ -0,0 +1,30 @@ | |||
| package common | |||
| import ( | |||
| "bytes" | |||
| "sort" | |||
| ) | |||
| type KVPair struct { | |||
| Key Bytes | |||
| Value Bytes | |||
| } | |||
| type KVPairs []KVPair | |||
| // Sorting | |||
| func (kvs KVPairs) Len() int { return len(kvs) } | |||
| func (kvs KVPairs) Less(i, j int) bool { | |||
| switch bytes.Compare(kvs[i].Key, kvs[j].Key) { | |||
| case -1: | |||
| return true | |||
| case 0: | |||
| return bytes.Compare(kvs[i].Value, kvs[j].Value) < 0 | |||
| case 1: | |||
| return false | |||
| default: | |||
| panic("invalid comparison result") | |||
| } | |||
| } | |||
| func (kvs KVPairs) Swap(i, j int) { kvs[i], kvs[j] = kvs[j], kvs[i] } | |||
| func (kvs KVPairs) Sort() { sort.Sort(kvs) } | |||
+ 23
- 25
glide.lock
View File
+ 0
- 48
merkle/kvpairs.go
View File
| @ -1,48 +0,0 @@ | |||
| package merkle | |||
| import ( | |||
| "sort" | |||
| wire "github.com/tendermint/go-wire" | |||
| "golang.org/x/crypto/ripemd160" | |||
| ) | |||
| // NOTE: Behavior is undefined with dup keys. | |||
| type KVPair struct { | |||
| Key string | |||
| Value interface{} // Can be Hashable or not. | |||
| } | |||
| func (kv KVPair) Hash() []byte { | |||
| hasher, n, err := ripemd160.New(), new(int), new(error) | |||
| wire.WriteString(kv.Key, hasher, n, err) | |||
| if kvH, ok := kv.Value.(Hashable); ok { | |||
| wire.WriteByteSlice(kvH.Hash(), hasher, n, err) | |||
| } else { | |||
| wire.WriteBinary(kv.Value, hasher, n, err) | |||
| } | |||
| if *err != nil { | |||
| panic(*err) | |||
| } | |||
| return hasher.Sum(nil) | |||
| } | |||
| type KVPairs []KVPair | |||
| func (kvps KVPairs) Len() int { return len(kvps) } | |||
| func (kvps KVPairs) Less(i, j int) bool { return kvps[i].Key < kvps[j].Key } | |||
| func (kvps KVPairs) Swap(i, j int) { kvps[i], kvps[j] = kvps[j], kvps[i] } | |||
| func (kvps KVPairs) Sort() { sort.Sort(kvps) } | |||
| func MakeSortedKVPairs(m map[string]interface{}) []Hashable { | |||
| kvPairs := make([]KVPair, 0, len(m)) | |||
| for k, v := range m { | |||
| kvPairs = append(kvPairs, KVPair{k, v}) | |||
| } | |||
| KVPairs(kvPairs).Sort() | |||
| kvPairsH := make([]Hashable, 0, len(kvPairs)) | |||
| for _, kvp := range kvPairs { | |||
| kvPairsH = append(kvPairsH, kvp) | |||
| } | |||
| return kvPairsH | |||
| } | |||
+ 69
- 9
merkle/simple_map.go
View File
| @ -1,26 +1,86 @@ | |||
| package merkle | |||
| import ( | |||
| "github.com/tendermint/go-wire" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| "golang.org/x/crypto/ripemd160" | |||
| ) | |||
| type SimpleMap struct { | |||
| kvz KVPairs | |||
| kvs cmn.KVPairs | |||
| sorted bool | |||
| } | |||
| func NewSimpleMap() *SimpleMap { | |||
| return &SimpleMap{ | |||
| kvz: nil, | |||
| kvs: nil, | |||
| sorted: false, | |||
| } | |||
| } | |||
| func (sm *SimpleMap) Set(k string, o interface{}) { | |||
| sm.kvz = append(sm.kvz, KVPair{Key: k, Value: o}) | |||
| func (sm *SimpleMap) Set(key string, value interface{}) { | |||
| sm.sorted = false | |||
| // Is value Hashable? | |||
| var vBytes []byte | |||
| if hashable, ok := value.(Hashable); ok { | |||
| vBytes = hashable.Hash() | |||
| } else { | |||
| vBytes = wire.BinaryBytes(value) | |||
| } | |||
| sm.kvs = append(sm.kvs, cmn.KVPair{ | |||
| Key: []byte(key), | |||
| Value: vBytes, | |||
| }) | |||
| } | |||
| // Merkle root hash of items sorted by key. | |||
| // NOTE: Behavior is undefined when key is duplicate. | |||
| func (sm *SimpleMap) Hash() []byte { | |||
| sm.kvz.Sort() | |||
| kvPairsH := make([]Hashable, 0, len(sm.kvz)) | |||
| for _, kvp := range sm.kvz { | |||
| kvPairsH = append(kvPairsH, kvp) | |||
| sm.Sort() | |||
| return hashKVPairs(sm.kvs) | |||
| } | |||
| func (sm *SimpleMap) Sort() { | |||
| if sm.sorted { | |||
| return | |||
| } | |||
| sm.kvs.Sort() | |||
| sm.sorted = true | |||
| } | |||
| // Returns a copy of sorted KVPairs. | |||
| // CONTRACT: The returned slice must not be mutated. | |||
| func (sm *SimpleMap) KVPairs() cmn.KVPairs { | |||
| sm.Sort() | |||
| kvs := make(cmn.KVPairs, len(sm.kvs)) | |||
| copy(kvs, sm.kvs) | |||
| return kvs | |||
| } | |||
| //---------------------------------------- | |||
| // A local extension to KVPair that can be hashed. | |||
| type kvPair cmn.KVPair | |||
| func (kv kvPair) Hash() []byte { | |||
| hasher, n, err := ripemd160.New(), new(int), new(error) | |||
| wire.WriteByteSlice(kv.Key, hasher, n, err) | |||
| if *err != nil { | |||
| panic(*err) | |||
| } | |||
| wire.WriteByteSlice(kv.Value, hasher, n, err) | |||
| if *err != nil { | |||
| panic(*err) | |||
| } | |||
| return hasher.Sum(nil) | |||
| } | |||
| func hashKVPairs(kvs cmn.KVPairs) []byte { | |||
| kvsH := make([]Hashable, 0, len(kvs)) | |||
| for _, kvp := range kvs { | |||
| kvsH = append(kvsH, kvPair(kvp)) | |||
| } | |||
| return SimpleHashFromHashables(kvPairsH) | |||
| return SimpleHashFromHashables(kvsH) | |||
| } | |||