From 483d43a15af11a9c456e4d9df0520441b947cd35 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Sat, 21 Mar 2015 00:49:58 +0100
Subject: whisper: use package rlp

---
 whisper/envelope.go | 40 +++++++++++++++-------------------------
 whisper/peer.go     | 21 +++++++++------------
 2 files changed, 24 insertions(+), 37 deletions(-)

(limited to 'whisper')

diff --git a/whisper/envelope.go b/whisper/envelope.go
index 9ec9fc318..15a974a2c 100644
--- a/whisper/envelope.go
+++ b/whisper/envelope.go
@@ -28,9 +28,9 @@ type Envelope struct {
 
 func (self *Envelope) Hash() Hash {
 	if self.hash == EmptyHash {
-		self.hash = H(crypto.Sha3(common.Encode(self)))
+		enc, _ := rlp.EncodeToBytes(self)
+		self.hash = H(crypto.Sha3(enc))
 	}
-
 	return self.hash
 }
 
@@ -76,7 +76,8 @@ func (self *Envelope) Open(prv *ecdsa.PrivateKey) (msg *Message, err error) {
 func (self *Envelope) proveWork(dura time.Duration) {
 	var bestBit int
 	d := make([]byte, 64)
-	copy(d[:32], common.Encode(self.withoutNonce()))
+	enc, _ := rlp.EncodeToBytes(self.withoutNonce())
+	copy(d[:32], enc)
 
 	then := time.Now().Add(dura).UnixNano()
 	for n := uint32(0); time.Now().UnixNano() < then; {
@@ -96,39 +97,28 @@ func (self *Envelope) proveWork(dura time.Duration) {
 
 func (self *Envelope) valid() bool {
 	d := make([]byte, 64)
-	copy(d[:32], common.Encode(self.withoutNonce()))
+	enc, _ := rlp.EncodeToBytes(self.withoutNonce())
+	copy(d[:32], enc)
 	binary.BigEndian.PutUint32(d[60:], self.Nonce)
 	return common.FirstBitSet(common.BigD(crypto.Sha3(d))) > 0
 }
 
 func (self *Envelope) withoutNonce() interface{} {
-	return []interface{}{self.Expiry, self.Ttl, common.ByteSliceToInterface(self.Topics), self.Data}
+	return []interface{}{self.Expiry, self.Ttl, self.Topics, self.Data}
 }
 
-func (self *Envelope) RlpData() interface{} {
-	return []interface{}{self.Expiry, self.Ttl, common.ByteSliceToInterface(self.Topics), self.Data, self.Nonce}
-}
+// rlpenv is an Envelope but is not an rlp.Decoder.
+// It is used for decoding because we need to
+type rlpenv Envelope
 
 func (self *Envelope) DecodeRLP(s *rlp.Stream) error {
-	var extenv struct {
-		Expiry uint32
-		Ttl    uint32
-		Topics [][]byte
-		Data   []byte
-		Nonce  uint32
+	raw, err := s.Raw()
+	if err != nil {
+		return err
 	}
-	if err := s.Decode(&extenv); err != nil {
+	if err := rlp.DecodeBytes(raw, (*rlpenv)(self)); err != nil {
 		return err
 	}
-
-	self.Expiry = extenv.Expiry
-	self.Ttl = extenv.Ttl
-	self.Topics = extenv.Topics
-	self.Data = extenv.Data
-	self.Nonce = extenv.Nonce
-
-	// TODO We should use the stream directly here.
-	self.hash = H(crypto.Sha3(common.Encode(self)))
-
+	self.hash = H(crypto.Sha3(raw))
 	return nil
 }
diff --git a/whisper/peer.go b/whisper/peer.go
index ee5bffd0b..338166c25 100644
--- a/whisper/peer.go
+++ b/whisper/peer.go
@@ -10,7 +10,7 @@ import (
 )
 
 const (
-	protocolVersion = 0x02
+	protocolVersion uint64 = 0x02
 )
 
 type peer struct {
@@ -66,21 +66,18 @@ out:
 }
 
 func (self *peer) broadcast(envelopes []*Envelope) error {
-	envs := make([]interface{}, len(envelopes))
-	i := 0
-	for _, envelope := range envelopes {
-		if !self.known.Has(envelope.Hash()) {
-			envs[i] = envelope
-			self.known.Add(envelope.Hash())
-			i++
+	envs := make([]*Envelope, 0, len(envelopes))
+	for _, env := range envelopes {
+		if !self.known.Has(env.Hash()) {
+			envs = append(envs, env)
+			self.known.Add(env.Hash())
 		}
 	}
-
-	if i > 0 {
-		if err := p2p.Send(self.ws, envelopesMsg, envs[:i]); err != nil {
+	if len(envs) > 0 {
+		if err := p2p.Send(self.ws, envelopesMsg, envs); err != nil {
 			return err
 		}
-		self.peer.DebugDetailln("broadcasted", i, "message(s)")
+		self.peer.DebugDetailln("broadcasted", len(envs), "message(s)")
 	}
 	return nil
 }
-- 
cgit v1.2.3