Update libp2p package names

network/address.go

@@ -1,21 +1,21 @@
 package network
 
 import (
-	"github.com/libp2p/go-libp2p-core/peer"
-	ma "github.com/multiformats/go-multiaddr"
+	lp2ppeer "github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multiaddr"
 )
 
 // PeerAddrsToAddrInfo converts a slice of string peer addresses
 // to AddrInfo.
-func PeerAddrsToAddrInfo(addrs []string) ([]peer.AddrInfo, error) {
-	var pis []peer.AddrInfo
+func PeerAddrsToAddrInfo(addrs []string) ([]lp2ppeer.AddrInfo, error) {
+	var pis []lp2ppeer.AddrInfo
 	for _, addr := range addrs {
-		a, err := ma.NewMultiaddr(addr)
+		a, err := multiaddr.NewMultiaddr(addr)
 		if err != nil {
 			return nil, err
 		}
 
-		pinfo, err := peer.AddrInfoFromP2pAddr(a)
+		pinfo, err := lp2ppeer.AddrInfoFromP2pAddr(a)
 		if err != nil {
 			return nil, err
 		}

network/bootstrap.go

@@ -5,12 +5,11 @@ import (
 	"sync"
 	"time"
 
-	host "github.com/libp2p/go-libp2p-core/host"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	net "github.com/libp2p/go-libp2p-core/network"
-	peer "github.com/libp2p/go-libp2p-core/peer"
-	"github.com/libp2p/go-libp2p-core/routing"
-	dht "github.com/libp2p/go-libp2p-kad-dht"
+	lp2phost "github.com/libp2p/go-libp2p-core/host"
+	lp2pnet "github.com/libp2p/go-libp2p-core/network"
+	lp2ppeer "github.com/libp2p/go-libp2p-core/peer"
+	lp2prouting "github.com/libp2p/go-libp2p-core/routing"
+	lp2pdht "github.com/libp2p/go-libp2p-kad-dht"
 	"github.com/zarbchain/zarb-go/logger"
 )
 
@@ -22,12 +21,12 @@ import (
 type Bootstrapper struct {
 	config *BootstrapConfig
 
-	bootstrapPeers []peer.AddrInfo
+	bootstrapPeers []lp2ppeer.AddrInfo
 
 	// Dependencies
-	host    host.Host
-	dialer  inet.Dialer
-	routing routing.Routing
+	host    lp2phost.Host
+	dialer  lp2pnet.Dialer
+	routing lp2prouting.Routing
 
 	// Bookkeeping
 	ticker *time.Ticker
@@ -39,7 +38,7 @@ type Bootstrapper struct {
 
 // NewBootstrapper returns a new Bootstrapper that will attempt to keep connected
 // to the network by connecting to the given bootstrap peers.
-func NewBootstrapper(ctx context.Context, h host.Host, d inet.Dialer, r routing.Routing, conf *BootstrapConfig, logger *logger.Logger) *Bootstrapper {
+func NewBootstrapper(ctx context.Context, h lp2phost.Host, d lp2pnet.Dialer, r lp2prouting.Routing, conf *BootstrapConfig, logger *logger.Logger) *Bootstrapper {
 	b := &Bootstrapper{
 		ctx:     ctx,
 		config:  conf,
@@ -94,10 +93,10 @@ func (b *Bootstrapper) checkConnectivity() {
 	b.logger.Debug("Check connectivity", "peers", len(currentPeers))
 
 	// Let's check if some peers are disconnected
-	var connectedPeers []peer.ID
+	var connectedPeers []lp2ppeer.ID
 	for _, p := range currentPeers {
 		connectedness := b.dialer.Connectedness(p)
-		if connectedness == net.Connected {
+		if connectedness == lp2pnet.Connected {
 			connectedPeers = append(connectedPeers, p)
 		} else {
 			b.logger.Warn("Peer is not connected to us", "peer", p)
@@ -137,7 +136,7 @@ func (b *Bootstrapper) checkConnectivity() {
 			}
 
 			wg.Add(1)
-			go func(pi peer.AddrInfo) {
+			go func(pi lp2ppeer.AddrInfo) {
 				if err := b.host.Connect(ctx, pi); err != nil {
 					b.logger.Error("got error trying to connect to bootstrap node ", "info", pi, "err", err.Error())
 				}
@@ -150,7 +149,7 @@ func (b *Bootstrapper) checkConnectivity() {
 	}
 }
 
-func hasPID(pids []peer.ID, pid peer.ID) bool {
+func hasPID(pids []lp2ppeer.ID, pid lp2ppeer.ID) bool {
 	for _, p := range pids {
 		if p == pid {
 			return true
@@ -160,7 +159,7 @@ func hasPID(pids []peer.ID, pid peer.ID) bool {
 }
 
 func (b *Bootstrapper) bootstrapIpfsRouting() error {
-	dht, ok := b.routing.(*dht.IpfsDHT)
+	dht, ok := b.routing.(*lp2pdht.IpfsDHT)
 	if !ok {
 		b.logger.Warn("No bootstrapping to do exit quietly.")
 		// No bootstrapping to do exit quietly.

network/kademlia.go

@@ -4,19 +4,19 @@ import (
 	"context"
 	"fmt"
 
-	host "github.com/libp2p/go-libp2p-core/host"
-	dht "github.com/libp2p/go-libp2p-kad-dht"
-	protocol "github.com/libp2p/go-libp2p-protocol"
+	lp2pcore "github.com/libp2p/go-libp2p-core"
+	lp2phost "github.com/libp2p/go-libp2p-core/host"
+	lp2pdht "github.com/libp2p/go-libp2p-kad-dht"
 )
 
-func (n *network) setupKademlia(ctx context.Context, host host.Host) (*dht.IpfsDHT, error) {
+func (n *network) setupKademlia(ctx context.Context, host lp2phost.Host) (*lp2pdht.IpfsDHT, error) {
 
-	opts := []dht.Option{
-		dht.Mode(dht.ModeAuto),
-		dht.ProtocolPrefix(protocol.ID(fmt.Sprintf("/zarb/kad/%s", n.config.Name))),
+	opts := []lp2pdht.Option{
+		lp2pdht.Mode(lp2pdht.ModeAuto),
+		lp2pdht.ProtocolPrefix(lp2pcore.ProtocolID(fmt.Sprintf("/zarb/kad/%s", n.config.Name))),
 	}
 
-	dht, err := dht.New(ctx, host, opts...)
+	dht, err := lp2pdht.New(ctx, host, opts...)
 	if err != nil {
 		return nil, err
 	}

network/mdns.go

@@ -4,9 +4,9 @@ import (
 	"context"
 	"time"
 
-	host "github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"github.com/libp2p/go-libp2p/p2p/discovery"
+	lp2phost "github.com/libp2p/go-libp2p-core/host"
+	lp2ppeer "github.com/libp2p/go-libp2p-core/peer"
+	lp2pdiscovery "github.com/libp2p/go-libp2p/p2p/discovery"
 )
 
 // DiscoveryInterval is how often we re-publish our mDNS records.
@@ -18,7 +18,7 @@ const DiscoveryServiceTag = "pubsub-zarb"
 // HandlePeerFound connects to peers discovered via mDNS. Once they're connected,
 // the PubSub system will automatically start interacting with them if they also
 // support PubSub.
-func (n *network) HandlePeerFound(pi peer.AddrInfo) {
+func (n *network) HandlePeerFound(pi lp2ppeer.AddrInfo) {
 	n.logger.Trace("discovered new peer", "id", pi.ID.Pretty())
 	ctx, cancel := context.WithTimeout(n.ctx, time.Second*10)
 	defer cancel()
@@ -29,9 +29,9 @@ func (n *network) HandlePeerFound(pi peer.AddrInfo) {
 
 // setupDiscovery creates an mDNS discovery service and attaches it to the libp2p Host.
 // This lets us automatically discover peers on the same LAN and connect to them.
-func (n *network) setupMNSDiscovery(ctx context.Context, h host.Host) (discovery.Service, error) {
+func (n *network) setupMNSDiscovery(ctx context.Context, h lp2phost.Host) (lp2pdiscovery.Service, error) {
 	// setup mDNS discovery to find local peers
-	service, err := discovery.NewMdnsService(ctx, h, DiscoveryInterval, DiscoveryServiceTag)
+	service, err := lp2pdiscovery.NewMdnsService(ctx, h, DiscoveryInterval, DiscoveryServiceTag)
 	if err != nil {
 		return nil, err
 	}

network/network.go

@@ -6,15 +6,14 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/libp2p/go-libp2p"
-	circuit "github.com/libp2p/go-libp2p-circuit"
-	acrypto "github.com/libp2p/go-libp2p-core/crypto"
-	"github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/peer"
-	libp2pdht "github.com/libp2p/go-libp2p-kad-dht"
-	libp2pps "github.com/libp2p/go-libp2p-pubsub"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/p2p/discovery"
+	lp2p "github.com/libp2p/go-libp2p"
+	lp2pcircuit "github.com/libp2p/go-libp2p-circuit"
+	lp2pcrypto "github.com/libp2p/go-libp2p-core/crypto"
+	lp2phost "github.com/libp2p/go-libp2p-core/host"
+	lp2peer "github.com/libp2p/go-libp2p-core/peer"
+	lp2pdht "github.com/libp2p/go-libp2p-kad-dht"
+	lp2pps "github.com/libp2p/go-libp2p-pubsub"
+	lp2pdiscovery "github.com/libp2p/go-libp2p/p2p/discovery"
 	"github.com/sasha-s/go-deadlock"
 	"github.com/zarbchain/zarb-go/errors"
 	"github.com/zarbchain/zarb-go/logger"
@@ -27,25 +26,25 @@ type network struct {
 
 	ctx            context.Context
 	config         *Config
-	host           host.Host
+	host           lp2phost.Host
 	wg             sync.WaitGroup
-	mdns           discovery.Service
-	kademlia       *libp2pdht.IpfsDHT
-	pubsub         *libp2pps.PubSub
-	generalTopic   *pubsub.Topic
-	downloadTopic  *pubsub.Topic
-	dataTopic      *pubsub.Topic
-	consensusTopic *pubsub.Topic
-	generalSub     *pubsub.Subscription
-	downloadSub    *pubsub.Subscription
-	dataSub        *pubsub.Subscription
-	consensusSub   *pubsub.Subscription
+	mdns           lp2pdiscovery.Service
+	kademlia       *lp2pdht.IpfsDHT
+	pubsub         *lp2pps.PubSub
+	generalTopic   *lp2pps.Topic
+	downloadTopic  *lp2pps.Topic
+	dataTopic      *lp2pps.Topic
+	consensusTopic *lp2pps.Topic
+	generalSub     *lp2pps.Subscription
+	downloadSub    *lp2pps.Subscription
+	dataSub        *lp2pps.Subscription
+	consensusSub   *lp2pps.Subscription
 	callback       CallbackFn
 	bootstrapper   *Bootstrapper
 	logger         *logger.Logger
 }
 
-func loadOrCreateKey(path string) (acrypto.PrivKey, error) {
+func loadOrCreateKey(path string) (lp2pcrypto.PrivKey, error) {
 	if util.PathExists(path) {
 		h, err := util.ReadFile(path)
 		if err != nil {
@@ -55,17 +54,17 @@ func loadOrCreateKey(path string) (acrypto.PrivKey, error) {
 		if err != nil {
 			return nil, err
 		}
-		key, err := acrypto.UnmarshalPrivateKey(bs)
+		key, err := lp2pcrypto.UnmarshalPrivateKey(bs)
 		if err != nil {
 			return nil, err
 		}
 		return key, nil
 	}
-	key, _, err := acrypto.GenerateEd25519Key(nil)
+	key, _, err := lp2pcrypto.GenerateEd25519Key(nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to generate private key")
 	}
-	bs, err := acrypto.MarshalPrivateKey(key)
+	bs, err := lp2pcrypto.MarshalPrivateKey(key)
 	if err != nil {
 		return nil, err
 	}
@@ -85,27 +84,27 @@ func NewNetwork(conf *Config) (Network, error) {
 		return nil, errors.Errorf(errors.ErrNetwork, err.Error())
 	}
 
-	opts := []libp2p.Option{
-		libp2p.Identity(nodeKey),
-		libp2p.ListenAddrStrings(conf.ListenAddress...),
-		libp2p.Ping(true),
-		libp2p.UserAgent("zarb-" + version.Version()),
+	opts := []lp2p.Option{
+		lp2p.Identity(nodeKey),
+		lp2p.ListenAddrStrings(conf.ListenAddress...),
+		lp2p.Ping(true),
+		lp2p.UserAgent("zarb-" + version.Version()),
 	}
 	if conf.EnableNATService {
 		opts = append(opts,
-			libp2p.EnableNATService(),
-			libp2p.NATPortMap())
+			lp2p.EnableNATService(),
+			lp2p.NATPortMap())
 	}
 	if conf.EnableRelay {
 		opts = append(opts,
-			libp2p.EnableRelay(circuit.OptHop))
+			lp2p.EnableRelay(lp2pcircuit.OptHop))
 	}
-	host, err := libp2p.New(ctx, opts...)
+	host, err := lp2p.New(ctx, opts...)
 	if err != nil {
 		return nil, errors.Errorf(errors.ErrNetwork, err.Error())
 	}
 
-	pubsub, err := libp2pps.NewGossipSub(ctx, host)
+	pubsub, err := lp2pps.NewGossipSub(ctx, host)
 	if err != nil {
 		return nil, errors.Errorf(errors.ErrNetwork, err.Error())
 	}
@@ -169,11 +168,11 @@ func (n *network) Stop() {
 	}
 }
 
-func (n *network) SelfID() peer.ID {
+func (n *network) SelfID() lp2peer.ID {
 	return n.host.ID()
 }
 
-func (n *network) CloseConnection(pid peer.ID) {
+func (n *network) CloseConnection(pid lp2peer.ID) {
 	if err := n.host.Network().ClosePeer(pid); err != nil {
 		n.logger.Warn("Unable to close connection", "peer", pid)
 	}
@@ -183,7 +182,7 @@ func (n *network) Fingerprint() string {
 	return fmt.Sprintf("{%d}", len(n.host.Network().Peers()))
 }
 
-func (n *network) joinTopic(name string) (*pubsub.Topic, error) {
+func (n *network) joinTopic(name string) (*lp2pps.Topic, error) {
 	topic := fmt.Sprintf("/zarb/pubsub/%s/v1/%s", n.config.Name, name)
 	return n.pubsub.Join(topic)
 }

network/topics.go

@@ -1,7 +1,7 @@
 package network
 
 import (
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	lp2pps "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/zarbchain/zarb-go/errors"
 	"github.com/zarbchain/zarb-go/sync/message"
 	"github.com/zarbchain/zarb-go/sync/message/payload"
@@ -175,7 +175,7 @@ func (n *network) closeTopics() {
 	n.wg.Wait()
 }
 
-func (n *network) topic(msg *message.Message) *pubsub.Topic {
+func (n *network) topic(msg *message.Message) *lp2pps.Topic {
 	switch msg.Payload.Type() {
 	case payload.PayloadTypeSalam,
 		payload.PayloadTypeAleyk,
@@ -204,7 +204,7 @@ func (n *network) topic(msg *message.Message) *pubsub.Topic {
 	}
 }
 
-func (n *network) onReceiveMessage(m *pubsub.Message) {
+func (n *network) onReceiveMessage(m *lp2pps.Message) {
 	// only forward messages delivered by others
 	if m.ReceivedFrom == n.SelfID() {
 		return