whisper: use common.Hash

whisper/envelope.go

@@ -18,26 +18,31 @@ const (
 
 type Envelope struct {
 	Expiry uint32 // Whisper protocol specifies int32, really should be int64
-	Ttl    uint32 // ^^^^^^
+	TTL    uint32 // ^^^^^^
 	Topics [][]byte
 	Data   []byte
 	Nonce  uint32
 
-	hash Hash
+	hash common.Hash
 }
 
-func (self *Envelope) Hash() Hash {
+func (self *Envelope) Hash() common.Hash {
-	if self.hash == EmptyHash {
+	if (self.hash == common.Hash{}) {
 		enc, _ := rlp.EncodeToBytes(self)
-		self.hash = H(crypto.Sha3(enc))
+		self.hash = crypto.Sha3Hash(enc)
 	}
 	return self.hash
 }
 
 func NewEnvelope(ttl time.Duration, topics [][]byte, data *Message) *Envelope {
 	exp := time.Now().Add(ttl)
-
+	return &Envelope{
-	return &Envelope{uint32(exp.Unix()), uint32(ttl.Seconds()), topics, data.Bytes(), 0, Hash{}}
+		Expiry: uint32(exp.Unix()),
+		TTL:    uint32(ttl.Seconds()),
+		Topics: topics,
+		Data:   data.Bytes(),
+		Nonce:  0,
+	}
 }
 
 func (self *Envelope) Seal(pow time.Duration) {
@@ -104,7 +109,7 @@ func (self *Envelope) valid() bool {
 }
 
 func (self *Envelope) withoutNonce() interface{} {
-	return []interface{}{self.Expiry, self.Ttl, self.Topics, self.Data}
+	return []interface{}{self.Expiry, self.TTL, self.Topics, self.Data}
 }
 
 // rlpenv is an Envelope but is not an rlp.Decoder.
@@ -119,6 +124,6 @@ func (self *Envelope) DecodeRLP(s *rlp.Stream) error {
 	if err := rlp.DecodeBytes(raw, (*rlpenv)(self)); err != nil {
 		return err
 	}
-	self.hash = H(crypto.Sha3(raw))
+	self.hash = crypto.Sha3Hash(raw)
 	return nil
 }

whisper/sort.go

@@ -1,6 +1,10 @@
 package whisper
 
-import "sort"
+import (
+	"sort"
+
+	"github.com/ethereum/go-ethereum/common"
+)
 
 type sortedKeys struct {
 	k []int32
@@ -10,7 +14,7 @@ func (self *sortedKeys) Len() int           { return len(self.k) }
 func (self *sortedKeys) Less(i, j int) bool { return self.k[i] < self.k[j] }
 func (self *sortedKeys) Swap(i, j int)      { self.k[i], self.k[j] = self.k[j], self.k[i] }
 
-func sortKeys(m map[int32]Hash) []int32 {
+func sortKeys(m map[int32]common.Hash) []int32 {
 	sorted := new(sortedKeys)
 	sorted.k = make([]int32, len(m))
 	i := 0

whisper/sort_test.go

@@ -1,13 +1,17 @@
 package whisper
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
 
 func TestSorting(t *testing.T) {
-	m := map[int32]Hash{
+	m := map[int32]common.Hash{
-		1: HS("1"),
+		1: {1},
-		3: HS("3"),
+		3: {3},
-		2: HS("2"),
+		2: {2},
-		5: HS("5"),
+		5: {5},
 	}
 	exp := []int32{1, 2, 3, 5}
 	res := sortKeys(m)

whisper/whisper.go

@@ -1,12 +1,12 @@
 package whisper
 
 import (
-	"bytes"
 	"crypto/ecdsa"
 	"errors"
 	"sync"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/ecies"
 	"github.com/ethereum/go-ethereum/event/filter"
@@ -15,26 +15,6 @@ import (
 	"gopkg.in/fatih/set.v0"
 )
 
-// MOVE ME
-type Hash struct {
-	hash string
-}
-
-var EmptyHash Hash
-
-func H(hash []byte) Hash {
-	return Hash{string(hash)}
-}
-func HS(hash string) Hash {
-	return Hash{hash}
-}
-
-func (self Hash) Compare(other Hash) int {
-	return bytes.Compare([]byte(self.hash), []byte(other.hash))
-}
-
-// MOVE ME END
-
 const (
 	statusMsg    = 0x0
 	envelopesMsg = 0x01
@@ -55,7 +35,7 @@ type Whisper struct {
 	filters  *filter.Filters
 
 	mmu      sync.RWMutex
-	messages map[Hash]*Envelope
+	messages map[common.Hash]*Envelope
 	expiry   map[uint32]*set.SetNonTS
 
 	quit chan struct{}
@@ -65,7 +45,7 @@ type Whisper struct {
 
 func New() *Whisper {
 	whisper := &Whisper{
-		messages: make(map[Hash]*Envelope),
+		messages: make(map[common.Hash]*Envelope),
 		filters:  filter.New(),
 		expiry:   make(map[uint32]*set.SetNonTS),
 		quit:     make(chan struct{}),
@@ -239,7 +219,7 @@ func (self *Whisper) expire() {
 		}
 
 		hashSet.Each(func(v interface{}) bool {
-			delete(self.messages, v.(Hash))
+			delete(self.messages, v.(common.Hash))
 			return true
 		})
 		self.expiry[then].Clear()