compilable version

diff --git a/crypto/crypto.go b/crypto/crypto.go
index cd33037..1cfc690 100644 (file)
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -22,6 +22,15 @@ import (
        "golang.org/x/crypto/sha3"
 )
 
+func DoubleSha256(b []byte) []byte {
+       hasher := sha3.New256()
+       hasher.Write(b)
+       sum := hasher.Sum(nil)
+       hasher.Reset()
+       hasher.Write(sum)
+       return hasher.Sum(nil)
+}
+
 func Sha256(data ...[]byte) []byte {
        d := sha3.New256()
        for _, b := range data {

diff --git a/netsync/handle.go b/netsync/handle.go
index 2fdc03b..a0b569b 100644 (file)
--- a/netsync/handle.go
+++ b/netsync/handle.go
@@ -11,6 +11,7 @@ import (
 
        cfg "github.com/bytom/config"
        "github.com/bytom/p2p"
+       "github.com/bytom/p2p/pex"
        core "github.com/bytom/protocol"
        "github.com/bytom/protocol/bc"
        "github.com/bytom/version"
@@ -54,11 +55,14 @@ func NewSyncManager(config *cfg.Config, chain *core.Chain, txPool *core.TxPool,
        }
 
        trustHistoryDB := dbm.NewDB("trusthistory", config.DBBackend, config.DBDir())
-       manager.sw = p2p.NewSwitch(config.P2P, trustHistoryDB)
+       addrBook := pex.NewAddrBook(config.P2P.AddrBookFile(), config.P2P.AddrBookStrict)
+       manager.sw = p2p.NewSwitch(config.P2P, addrBook, trustHistoryDB)
+
+       pexReactor := pex.NewPEXReactor(addrBook)
+       manager.sw.AddReactor("PEX", pexReactor)
 
        manager.blockKeeper = newBlockKeeper(manager.chain, manager.sw, manager.peers, manager.dropPeerCh)
        manager.fetcher = NewFetcher(chain, manager.sw, manager.peers)
-
        protocolReactor := NewProtocolReactor(chain, txPool, manager.sw, manager.blockKeeper, manager.fetcher, manager.peers, manager.newPeerCh, manager.txSyncCh, manager.dropPeerCh)
        manager.sw.AddReactor("PROTOCOL", protocolReactor)
 

diff --git a/p2p/connection.go b/p2p/connection.go
index 0b966f0..7e16b15 100644 (file)
--- a/p2p/connection.go
+++ b/p2p/connection.go
@@ -465,11 +465,7 @@ FOR_LOOP:
                        }
                        channel, ok := c.channelsIdx[pkt.ChannelID]
                        if !ok || channel == nil {
-                               if pkt.ChannelID == PexChannel {
-                                       continue
-                               } else {
-                                       cmn.PanicQ(cmn.Fmt("Unknown channel %X", pkt.ChannelID))
-                               }
+                               cmn.PanicQ(cmn.Fmt("Unknown channel %X", pkt.ChannelID))
                        }
                        msgBytes, err := channel.recvMsgPacket(pkt)
                        if err != nil {

diff --git a/p2p/pex/addrbook.go b/p2p/pex/addrbook.go
index 5902cce..8350832 100644 (file)
--- a/p2p/pex/addrbook.go
+++ b/p2p/pex/addrbook.go
@@ -10,8 +10,11 @@ import (
        "time"
 
        log "github.com/sirupsen/logrus"
-       "github.com/tendermint/go-crypto"
+       tcrypto "github.com/tendermint/go-crypto"
        cmn "github.com/tendermint/tmlibs/common"
+
+       "github.com/bytom/crypto"
+       "github.com/bytom/p2p"
 )
 
 // AddrBook - concurrency safe peer address manager.
@@ -25,7 +28,7 @@ type AddrBook struct {
 
        mtx        sync.RWMutex
        rand       *rand.Rand
-       ourAddrs   map[string]*NetAddress
+       ourAddrs   map[string]*p2p.NetAddress
        addrLookup map[string]*knownAddress // new & old
        bucketsNew []map[string]*knownAddress
        bucketsOld []map[string]*knownAddress
@@ -38,9 +41,9 @@ func NewAddrBook(filePath string, routabilityStrict bool) *AddrBook {
        a := &AddrBook{
                filePath:          filePath,
                routabilityStrict: routabilityStrict,
-               key:               crypto.CRandHex(24),
+               key:               tcrypto.CRandHex(24),
                rand:              rand.New(rand.NewSource(time.Now().UnixNano())),
-               ourAddrs:          make(map[string]*NetAddress),
+               ourAddrs:          make(map[string]*p2p.NetAddress),
                addrLookup:        make(map[string]*knownAddress),
                bucketsNew:        make([]map[string]*knownAddress, newBucketCount),
                bucketsOld:        make([]map[string]*knownAddress, oldBucketCount),
@@ -75,14 +78,22 @@ func (a *AddrBook) OnStop() {
 }
 
 // AddAddress add address to address book
-func (a *AddrBook) AddAddress(addr, src *NetAddress) error {
+func (a *AddrBook) AddAddress(addr, src *p2p.NetAddress) error {
        a.mtx.Lock()
        defer a.mtx.Unlock()
        return a.addAddress(addr, src)
 }
 
+// AddOurAddress one of our addresses.
+func (a *AddrBook) AddOurAddress(addr *p2p.NetAddress) {
+       a.mtx.Lock()
+       defer a.mtx.Unlock()
+
+       a.ourAddrs[addr.String()] = addr
+}
+
 // GetSelection randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
-func (a *AddrBook) GetSelection() []*NetAddress {
+func (a *AddrBook) GetSelection() []*p2p.NetAddress {
        a.mtx.RLock()
        defer a.mtx.RUnlock()
 
@@ -93,7 +104,7 @@ func (a *AddrBook) GetSelection() []*NetAddress {
 
        numAddresses := cmn.MaxInt(cmn.MinInt(minGetSelection, bookSize), bookSize*getSelectionPercent/100)
        numAddresses = cmn.MinInt(maxGetSelection, numAddresses)
-       allAddr := []*NetAddress{}
+       allAddr := []*p2p.NetAddress{}
        for _, ka := range a.addrLookup {
                allAddr = append(allAddr, ka.Addr)
        }
@@ -106,7 +117,7 @@ func (a *AddrBook) GetSelection() []*NetAddress {
 }
 
 // MarkGood marks the peer as good and moves it into an "old" bucket.
-func (a *AddrBook) MarkGood(addr *NetAddress) {
+func (a *AddrBook) MarkGood(addr *p2p.NetAddress) {
        a.mtx.Lock()
        defer a.mtx.Unlock()
 
@@ -119,7 +130,7 @@ func (a *AddrBook) MarkGood(addr *NetAddress) {
 }
 
 // MarkAttempt marks that an attempt was made to connect to the address.
-func (a *AddrBook) MarkAttempt(addr *NetAddress) {
+func (a *AddrBook) MarkAttempt(addr *p2p.NetAddress) {
        a.mtx.Lock()
        defer a.mtx.Unlock()
 
@@ -134,7 +145,7 @@ func (a *AddrBook) NeedMoreAddrs() bool {
 }
 
 // PickAddress picks a random address from random bucket
-func (a *AddrBook) PickAddress(bias int) *NetAddress {
+func (a *AddrBook) PickAddress(bias int) *p2p.NetAddress {
        a.mtx.RLock()
        defer a.mtx.RUnlock()
 
@@ -176,7 +187,7 @@ func (a *AddrBook) PickAddress(bias int) *NetAddress {
 }
 
 // RemoveAddress removes the address from the book.
-func (a *AddrBook) RemoveAddress(addr *NetAddress) {
+func (a *AddrBook) RemoveAddress(addr *p2p.NetAddress) {
        a.mtx.Lock()
        defer a.mtx.Unlock()
 
@@ -192,7 +203,7 @@ func (a *AddrBook) Size() int {
        return a.size()
 }
 
-func (a *AddrBook) addAddress(addr, src *NetAddress) error {
+func (a *AddrBook) addAddress(addr, src *p2p.NetAddress) error {
        if addr == nil || src == nil {
                return errors.New("can't add nil to address book")
        }
@@ -267,12 +278,12 @@ func (a *AddrBook) addToOldBucket(ka *knownAddress, bucketIdx int) error {
        return nil
 }
 
-func (a *AddrBook) calcNewBucket(addr, src *NetAddress) int {
+func (a *AddrBook) calcNewBucket(addr, src *p2p.NetAddress) int {
        data1 := []byte{}
        data1 = append(data1, []byte(a.key)...)
        data1 = append(data1, []byte(a.groupKey(addr))...)
        data1 = append(data1, []byte(a.groupKey(src))...)
-       hash1 := doubleSha256(data1)
+       hash1 := crypto.DoubleSha256(data1)
        hash64 := binary.BigEndian.Uint64(hash1)
        hash64 %= newBucketsPerGroup
        var hashbuf [8]byte
@@ -282,15 +293,15 @@ func (a *AddrBook) calcNewBucket(addr, src *NetAddress) int {
        data2 = append(data2, a.groupKey(src)...)
        data2 = append(data2, hashbuf[:]...)
 
-       hash2 := doubleSha256(data2)
+       hash2 := crypto.DoubleSha256(data2)
        return int(binary.BigEndian.Uint64(hash2) % newBucketCount)
 }
 
-func (a *AddrBook) calcOldBucket(addr *NetAddress) int {
+func (a *AddrBook) calcOldBucket(addr *p2p.NetAddress) int {
        data1 := []byte{}
        data1 = append(data1, []byte(a.key)...)
        data1 = append(data1, []byte(addr.String())...)
-       hash1 := doubleSha256(data1)
+       hash1 := crypto.DoubleSha256(data1)
        hash64 := binary.BigEndian.Uint64(hash1)
        hash64 %= oldBucketsPerGroup
        var hashbuf [8]byte
@@ -300,14 +311,14 @@ func (a *AddrBook) calcOldBucket(addr *NetAddress) int {
        data2 = append(data2, a.groupKey(addr)...)
        data2 = append(data2, hashbuf[:]...)
 
-       hash2 := doubleSha256(data2)
+       hash2 := crypto.DoubleSha256(data2)
        return int(binary.BigEndian.Uint64(hash2) % oldBucketCount)
 }
 
 func (a *AddrBook) expireNew(bucketIdx int) {
-       for addrStr, ka := range a.bucketsNew[bucketIdx] {
+       for _, ka := range a.bucketsNew[bucketIdx] {
                if ka.isBad() {
-                       a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
+                       a.removeFromBucket(ka, bucketIdx)
                        return
                }
        }
@@ -328,7 +339,7 @@ func (a *AddrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAd
        }
 }
 
-func (a *AddrBook) groupKey(na *NetAddress) string {
+func (a *AddrBook) groupKey(na *p2p.NetAddress) string {
        if a.routabilityStrict && na.Local() {
                return "local"
        }
@@ -409,7 +420,7 @@ func (a *AddrBook) removeFromBucket(ka *knownAddress, bucketIdx int) {
        delete(bucket, ka.Addr.String())
        if ka.removeBucketRef(bucketIdx) == 0 {
                delete(a.addrLookup, ka.Addr.String())
-               if ka.bucketType == bucketTypeNew {
+               if ka.BucketType == bucketTypeNew {
                        a.nNew--
                } else {
                        a.nOld--

diff --git a/p2p/pex/file.go b/p2p/pex/file.go
index 103ba05..3e735cb 100644 (file)
--- a/p2p/pex/file.go
+++ b/p2p/pex/file.go
@@ -4,6 +4,9 @@ import (
        "encoding/json"
        "os"
        "time"
+
+       log "github.com/sirupsen/logrus"
+       cmn "github.com/tendermint/tmlibs/common"
 )
 
 type addrBookJSON struct {
@@ -11,7 +14,7 @@ type addrBookJSON struct {
        Addrs []*knownAddress
 }
 
-func (a *AddrBook) saveToFile() error {
+func (a *AddrBook) SaveToFile() error {
        a.mtx.RLock()
        defer a.mtx.RUnlock()
 
@@ -34,7 +37,7 @@ func (a *AddrBook) loadFromFile() error {
 
        r, err := os.Open(a.filePath)
        if err != nil {
-               return error
+               return err
        }
 
        defer r.Close()
@@ -64,11 +67,11 @@ func (a *AddrBook) saveRoutine() {
        for {
                select {
                case <-ticker.C:
-                       if err := a.saveToFile(); err != nil {
+                       if err := a.SaveToFile(); err != nil {
                                log.WithField("err", err).Error("failed to save AddrBook to file")
                        }
                case <-a.Quit:
-                       a.saveToFile()
+                       a.SaveToFile()
                        return
                }
        }

diff --git a/p2p/pex/pex_message.go b/p2p/pex/pex_message.go
index c7cf133..329c2b1 100644 (file)
--- a/p2p/pex/pex_message.go
+++ b/p2p/pex/pex_message.go
@@ -5,6 +5,8 @@ import (
        "fmt"
 
        wire "github.com/tendermint/go-wire"
+
+       "github.com/bytom/p2p"
 )
 
 const (
@@ -36,7 +38,7 @@ type pexRequestMessage struct{}
 func (m *pexRequestMessage) String() string { return "[pexRequest]" }
 
 type pexAddrsMessage struct {
-       Addrs []*NetAddress
+       Addrs []*p2p.NetAddress
 }
 
 func (m *pexAddrsMessage) String() string { return fmt.Sprintf("[pexAddrs %v]", m.Addrs) }

diff --git a/p2p/pex/pex_reactor.go b/p2p/pex/pex_reactor.go
index 79e3da0..3fd8617 100644 (file)
--- a/p2p/pex/pex_reactor.go
+++ b/p2p/pex/pex_reactor.go
@@ -9,6 +9,8 @@ import (
 
        log "github.com/sirupsen/logrus"
        cmn "github.com/tendermint/tmlibs/common"
+
+       "github.com/bytom/p2p"
 )
 
 const (
@@ -24,7 +26,7 @@ const (
 
 // PEXReactor handles peer exchange and ensures that an adequate number of peers are connected to the switch.
 type PEXReactor struct {
-       BaseReactor
+       p2p.BaseReactor
        book           *AddrBook
        msgCountByPeer *cmn.CMap
 }
@@ -35,7 +37,7 @@ func NewPEXReactor(b *AddrBook) *PEXReactor {
                book:           b,
                msgCountByPeer: cmn.NewCMap(),
        }
-       r.BaseReactor = *NewBaseReactor("PEXReactor", r)
+       r.BaseReactor = *p2p.NewBaseReactor("PEXReactor", r)
        return r
 }
 
@@ -55,8 +57,8 @@ func (r *PEXReactor) OnStop() {
 }
 
 // GetChannels implements Reactor
-func (r *PEXReactor) GetChannels() []*ChannelDescriptor {
-       return []*ChannelDescriptor{&ChannelDescriptor{
+func (r *PEXReactor) GetChannels() []*p2p.ChannelDescriptor {
+       return []*p2p.ChannelDescriptor{&p2p.ChannelDescriptor{
                ID:                PexChannel,
                Priority:          1,
                SendQueueCapacity: 10,
@@ -64,7 +66,7 @@ func (r *PEXReactor) GetChannels() []*ChannelDescriptor {
 }
 
 // AddPeer adding peer to the address book
-func (r *PEXReactor) AddPeer(p *Peer) error {
+func (r *PEXReactor) AddPeer(p *p2p.Peer) error {
        if p.IsOutbound() {
                if r.book.NeedMoreAddrs() && !r.RequestAddrs(p) {
                        return errors.New("Send pex message fail")
@@ -72,13 +74,13 @@ func (r *PEXReactor) AddPeer(p *Peer) error {
                return nil
        }
 
-       addr, err := NewNetAddressString(p.ListenAddr)
+       addr, err := p2p.NewNetAddressString(p.ListenAddr)
        if err != nil {
                return errors.New("addPeer: invalid peer address")
        }
 
        r.book.AddAddress(addr, addr)
-       if r.Switch.peers.Size() >= r.Switch.config.MaxNumPeers {
+       if r.Switch.Peers().Size() >= r.Switch.Config.MaxNumPeers {
                if r.SendAddrs(p, r.book.GetSelection()) {
                        <-time.After(1 * time.Second)
                        r.Switch.StopPeerGracefully(p)
@@ -89,7 +91,7 @@ func (r *PEXReactor) AddPeer(p *Peer) error {
 }
 
 // Receive implements Reactor by handling incoming PEX messages.
-func (r *PEXReactor) Receive(chID byte, p *Peer, rawMsg []byte) {
+func (r *PEXReactor) Receive(chID byte, p *p2p.Peer, rawMsg []byte) {
        srcAddr := p.Connection().RemoteAddress
        srcAddrStr := srcAddr.String()
        r.incrementMsgCount(srcAddrStr)
@@ -108,7 +110,7 @@ func (r *PEXReactor) Receive(chID byte, p *Peer, rawMsg []byte) {
 
        switch msg := msg.(type) {
        case *pexRequestMessage:
-               if !r.SendAddrs(src, r.book.GetSelection()) {
+               if !r.SendAddrs(p, r.book.GetSelection()) {
                        log.Error("failed to send pex address message")
                }
 
@@ -127,10 +129,10 @@ func (r *PEXReactor) Receive(chID byte, p *Peer, rawMsg []byte) {
 }
 
 // RemovePeer implements Reactor.
-func (r *PEXReactor) RemovePeer(p *Peer, reason interface{}) {}
+func (r *PEXReactor) RemovePeer(p *p2p.Peer, reason interface{}) {}
 
 // RequestPEX asks peer for more addresses.
-func (r *PEXReactor) RequestAddrs(p *Peer) bool {
+func (r *PEXReactor) RequestAddrs(p *p2p.Peer) bool {
        ok := p.TrySend(PexChannel, struct{ PexMessage }{&pexRequestMessage{}})
        if !ok {
                r.Switch.StopPeerGracefully(p)
@@ -139,7 +141,7 @@ func (r *PEXReactor) RequestAddrs(p *Peer) bool {
 }
 
 // SendAddrs sends addrs to the peer.
-func (r *PEXReactor) SendAddrs(p *Peer, addrs []*NetAddress) bool {
+func (r *PEXReactor) SendAddrs(p *p2p.Peer, addrs []*p2p.NetAddress) bool {
        ok := p.TrySend(PexChannel, struct{ PexMessage }{&pexAddrsMessage{Addrs: addrs}})
        if !ok {
                r.Switch.StopPeerGracefully(p)
@@ -147,8 +149,8 @@ func (r *PEXReactor) SendAddrs(p *Peer, addrs []*NetAddress) bool {
        return ok
 }
 
-func (r *PEXReactor) dialPeerWorker(a *NetAddress, wg *sync.WaitGroup) {
-       if _, err := r.Switch.DialPeerWithAddress(a, false); err != nil {
+func (r *PEXReactor) dialPeerWorker(a *p2p.NetAddress, wg *sync.WaitGroup) {
+       if err := r.Switch.DialPeerWithAddress(a); err != nil {
                r.book.MarkAttempt(a)
        } else {
                r.book.MarkGood(a)
@@ -169,8 +171,14 @@ func (r *PEXReactor) ensurePeers() {
        }
 
        newBias := cmn.MinInt(numOutPeers, 8)*10 + 10
-       toDial := make(map[string]*NetAddress)
+       toDial := make(map[string]*p2p.NetAddress)
        maxAttempts := numToDial * 3
+
+       connectedPeers := make(map[string]struct{})
+       for _, peer := range r.Switch.Peers().List() {
+               connectedPeers[peer.RemoteAddrHost()] = struct{}{}
+       }
+
        for i := 0; i < maxAttempts && len(toDial) < numToDial; i++ {
                try := r.book.PickAddress(newBias)
                if try == nil {
@@ -182,7 +190,7 @@ func (r *PEXReactor) ensurePeers() {
                if dialling := r.Switch.IsDialing(try); dialling {
                        continue
                }
-               if connected := r.Switch.Peers().Has(try.ID); connected {
+               if _, ok := connectedPeers[try.IP.String()]; ok {
                        continue
                }
 
@@ -215,7 +223,7 @@ func (r *PEXReactor) ensurePeersRoutine() {
                case <-ticker.C:
                        r.ensurePeers()
                case <-quickTicker.C:
-                       if r.Switch.peers.Size() < 3 {
+                       if r.Switch.Peers().Size() < 3 {
                                r.ensurePeers()
                        }
                case <-r.Quit:

diff --git a/p2p/switch.go b/p2p/switch.go
index 8f0134a..63b6ca1 100644 (file)
--- a/p2p/switch.go
+++ b/p2p/switch.go
@@ -30,6 +30,15 @@ var (
        ErrConnectBannedPeer = errors.New("Connect banned peer")
 )
 
+// An AddrBook represents an address book from the pex package, which is used to store peer addresses.
+type AddrBook interface {
+       AddAddress(*NetAddress, *NetAddress) error
+       AddOurAddress(*NetAddress)
+       MarkGood(*NetAddress)
+       RemoveAddress(*NetAddress)
+       SaveToFile() error
+}
+
 //-----------------------------------------------------------------------------
 
 // Switch handles peer connections and exposes an API to receive incoming messages
@@ -39,7 +48,7 @@ var (
 type Switch struct {
        cmn.BaseService
 
-       config       *cfg.P2PConfig
+       Config       *cfg.P2PConfig
        peerConfig   *PeerConfig
        listeners    []Listener
        reactors     map[string]Reactor
@@ -49,16 +58,16 @@ type Switch struct {
        dialing      *cmn.CMap
        nodeInfo     *NodeInfo             // our node info
        nodePrivKey  crypto.PrivKeyEd25519 // our node privkey
-       addrBook     *AddrBook
+       addrBook     AddrBook
        bannedPeer   map[string]time.Time
        db           dbm.DB
        mtx          sync.Mutex
 }
 
 // NewSwitch creates a new Switch with the given config.
-func NewSwitch(config *cfg.P2PConfig, trustHistoryDB dbm.DB) *Switch {
+func NewSwitch(config *cfg.P2PConfig, addrBook AddrBook, trustHistoryDB dbm.DB) *Switch {
        sw := &Switch{
-               config:       config,
+               Config:       config,
                peerConfig:   DefaultPeerConfig(config),
                reactors:     make(map[string]Reactor),
                chDescs:      make([]*ChannelDescriptor, 0),
@@ -66,17 +75,10 @@ func NewSwitch(config *cfg.P2PConfig, trustHistoryDB dbm.DB) *Switch {
                peers:        NewPeerSet(),
                dialing:      cmn.NewCMap(),
                nodeInfo:     nil,
+               addrBook:     addrBook,
                db:           trustHistoryDB,
        }
        sw.BaseService = *cmn.NewBaseService(nil, "P2P Switch", sw)
-
-       // Optionally, start the pex reactor
-       if config.PexReactor {
-               sw.addrBook = NewAddrBook(config.AddrBookFile(), config.AddrBookStrict)
-               pexReactor := NewPEXReactor(sw.addrBook, sw)
-               sw.AddReactor("PEX", pexReactor)
-       }
-
        sw.bannedPeer = make(map[string]time.Time)
        if datajson := sw.db.Get([]byte(bannedPeerKey)); datajson != nil {
                if err := json.Unmarshal(datajson, &sw.bannedPeer); err != nil {
@@ -259,7 +261,7 @@ func (sw *Switch) DialSeeds(seeds []string) error {
                        sw.addrBook.AddAddress(netAddr, ourAddr)
                }
 
-               sw.addrBook.Save()
+               sw.addrBook.SaveToFile()
        }
 
        //permute the list, dial them in random order.
@@ -403,7 +405,7 @@ func (sw *Switch) listenerRoutine(l Listener) {
                // disconnect if we alrady have 2 * MaxNumPeers, we do this because we wanna address book get exchanged even if
                // the connect is full. The pex will disconnect the peer after address exchange, the max connected peer won't
                // be double of MaxNumPeers
-               if sw.peers.Size() >= sw.config.MaxNumPeers*2 {
+               if sw.peers.Size() >= sw.Config.MaxNumPeers*2 {
                        inConn.Close()
                        log.Info("Ignoring inbound connection: already have enough peers.")
                        continue
@@ -419,7 +421,7 @@ func (sw *Switch) listenerRoutine(l Listener) {
 }
 
 func (sw *Switch) addPeerWithConnection(conn net.Conn) error {
-       peerConn, err := newInboundPeerConn(conn, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.nodePrivKey, sw.config)
+       peerConn, err := newInboundPeerConn(conn, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.nodePrivKey, sw.Config)
        if err != nil {
                conn.Close()
                return err

diff --git a/p2p/test_util.go b/p2p/test_util.go
index aad9723..c16a6b4 100644 (file)
--- a/p2p/test_util.go
+++ b/p2p/test_util.go
@@ -77,7 +77,7 @@ func makeSwitch(cfg *cfg.P2PConfig, i int, network, version string, initSwitch f
        privKey := crypto.GenPrivKeyEd25519()
        // new switch, add reactors
        // TODO: let the config be passed in?
-       s := initSwitch(i, NewSwitch(cfg, nil))
+       s := initSwitch(i, NewSwitch(cfg, nil, nil))
        s.SetNodeInfo(&NodeInfo{
                PubKey:     privKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
                Moniker:    cmn.Fmt("switch%d", i),

diff --git a/p2p/util.go b/p2p/util.go
deleted file mode 100644 (file)
index 2be3202..0000000
--- a/p2p/util.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package p2p
-
-import (
-       "crypto/sha256"
-)
-
-// doubleSha256 calculates sha256(sha256(b)) and returns the resulting bytes.
-func doubleSha256(b []byte) []byte {
-       hasher := sha256.New()
-       hasher.Write(b)
-       sum := hasher.Sum(nil)
-       hasher.Reset()
-       hasher.Write(sum)
-       return hasher.Sum(nil)
-}