remove all circuit v1 related code (#2107)

* autorelay: remove support for circuit v1 nodes

* circuitv2: remove v1 backwards compatibility

* remove circuitv1 implementation only used for testing

* remove circuitv1 protocol implementation

limits.go

@@ -4,7 +4,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/protocol"
 	"github.com/libp2p/go-libp2p/p2p/host/autonat"
 	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
-	relayv1 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv1/relay"
 	circuit "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/proto"
 	relayv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
 	"github.com/libp2p/go-libp2p/p2p/protocol/holepunch"
@@ -76,18 +75,6 @@ func SetDefaultServiceLimits(config *rcmgr.ScalingLimitConfig) {
 		rcmgr.BaseLimitIncrease{},
 	)
 
-	// relay/v1
-	config.AddServiceLimit(
-		relayv1.ServiceName,
-		rcmgr.BaseLimit{StreamsInbound: 256, StreamsOutbound: 256, Streams: 256, Memory: 16 << 20},
-		rcmgr.BaseLimitIncrease{StreamsInbound: 256, StreamsOutbound: 256, Streams: 256, Memory: 16 << 20},
-	)
-	config.AddServicePeerLimit(
-		relayv1.ServiceName,
-		rcmgr.BaseLimit{StreamsInbound: 64, StreamsOutbound: 64, Streams: 64, Memory: 1 << 20},
-		rcmgr.BaseLimitIncrease{},
-	)
-
 	// relay/v2
 	config.AddServiceLimit(
 		relayv2.ServiceName,
@@ -101,7 +88,7 @@ func SetDefaultServiceLimits(config *rcmgr.ScalingLimitConfig) {
 	)
 
 	// circuit protocols, both client and service
-	for _, proto := range [...]protocol.ID{circuit.ProtoIDv1, circuit.ProtoIDv2Hop, circuit.ProtoIDv2Stop} {
+	for _, proto := range [...]protocol.ID{circuit.ProtoIDv2Hop, circuit.ProtoIDv2Stop} {
 		config.AddProtocolLimit(
 			proto,
 			rcmgr.BaseLimit{StreamsInbound: 640, StreamsOutbound: 640, Streams: 640, Memory: 16 << 20},

p2p/host/autorelay/autorelay_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/p2p/host/autorelay"
-	relayv1 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv1/relay"
 	circuitv2_proto "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/proto"
 
 	"github.com/benbjohnson/clock"
@@ -102,29 +101,6 @@ func newRelay(t *testing.T) host.Host {
 	return h
 }
 
-func newRelayV1(t *testing.T) host.Host {
-	t.Helper()
-	h, err := libp2p.New(
-		libp2p.DisableRelay(),
-		libp2p.ForceReachabilityPublic(),
-		libp2p.AddrsFactory(func(addrs []ma.Multiaddr) []ma.Multiaddr {
-			for i, addr := range addrs {
-				saddr := addr.String()
-				if strings.HasPrefix(saddr, "/ip4/127.0.0.1/") {
-					addrNoIP := strings.TrimPrefix(saddr, "/ip4/127.0.0.1")
-					addrs[i] = ma.StringCast("/dns4/localhost" + addrNoIP)
-				}
-			}
-			return addrs
-		}),
-	)
-	require.NoError(t, err)
-	r, err := relayv1.NewRelay(h)
-	require.NoError(t, err)
-	t.Cleanup(func() { r.Close() })
-	return h
-}
-
 func TestSingleCandidate(t *testing.T) {
 	var counter int
 	h := newPrivateNode(t,
@@ -180,32 +156,6 @@ func TestSingleRelay(t *testing.T) {
 	// test that we don't add any more relays
 	require.Never(t, func() bool { return numRelays(h) > 1 }, 200*time.Millisecond, 50*time.Millisecond)
 }
-func TestPreferRelayV2(t *testing.T) {
-	r := newRelay(t)
-	defer r.Close()
-	// The relay supports both v1 and v2. The v1 stream handler should never be called,
-	// if we prefer v2 relays.
-	r.SetStreamHandler(relayv1.ProtoID, func(str network.Stream) {
-		str.Reset()
-		t.Fatal("used relay v1")
-	})
-
-	h := newPrivateNode(t,
-		func(context.Context, int) <-chan peer.AddrInfo {
-			peerChan := make(chan peer.AddrInfo, 1)
-			defer close(peerChan)
-			peerChan <- peer.AddrInfo{ID: r.ID(), Addrs: r.Addrs()}
-			return peerChan
-		},
-		autorelay.WithMaxCandidates(1),
-		autorelay.WithNumRelays(99999),
-		autorelay.WithBootDelay(0),
-		autorelay.WithMinInterval(time.Hour),
-	)
-	defer h.Close()
-
-	require.Eventually(t, func() bool { return numRelays(h) > 0 }, 3*time.Second, 100*time.Millisecond)
-}
 
 func TestWaitForCandidates(t *testing.T) {
 	peerChan := make(chan peer.AddrInfo)
@@ -305,46 +255,6 @@ func TestStaticRelays(t *testing.T) {
 	require.Eventually(t, func() bool { return numRelays(h) > 0 }, 2*time.Second, 50*time.Millisecond)
 }
 
-func TestRelayV1(t *testing.T) {
-	t.Run("relay v1 support disabled", func(t *testing.T) {
-		peerChan := make(chan peer.AddrInfo, 1)
-		r := newRelayV1(t)
-		t.Cleanup(func() { r.Close() })
-		peerChan <- peer.AddrInfo{ID: r.ID(), Addrs: r.Addrs()}
-		close(peerChan)
-
-		h := newPrivateNode(t,
-			func(context.Context, int) <-chan peer.AddrInfo { return peerChan },
-			autorelay.WithBootDelay(0),
-			autorelay.WithMinInterval(time.Hour),
-		)
-		defer h.Close()
-
-		require.Never(t, func() bool { return numRelays(h) > 0 }, 250*time.Millisecond, 100*time.Millisecond)
-	})
-
-	t.Run("relay v1 support enabled", func(t *testing.T) {
-		peerChan := make(chan peer.AddrInfo, 1)
-		r := newRelayV1(t)
-		t.Cleanup(func() { r.Close() })
-		peerChan <- peer.AddrInfo{ID: r.ID(), Addrs: r.Addrs()}
-		close(peerChan)
-
-		h := newPrivateNode(t,
-			func(context.Context, int) <-chan peer.AddrInfo { return peerChan },
-			autorelay.WithBootDelay(0),
-			autorelay.WithCircuitV1Support(),
-			autorelay.WithMinInterval(time.Hour),
-		)
-		defer h.Close()
-
-		addrUpdated, err := h.EventBus().Subscribe(new(event.EvtLocalAddressesUpdated))
-		require.NoError(t, err)
-
-		expectDeltaInAddrUpdated(t, addrUpdated, 1)
-	})
-}
-
 func TestConnectOnDisconnect(t *testing.T) {
 	const num = 3
 	peerChan := make(chan peer.AddrInfo, num)

p2p/host/autorelay/options.go

@@ -42,7 +42,6 @@ type config struct {
 	// see WithMaxCandidateAge
 	maxCandidateAge  time.Duration
 	setMinCandidates bool
-	enableCircuitV1  bool
 }
 
 var defaultConfig = config{
@@ -151,14 +150,6 @@ func WithBackoff(d time.Duration) Option {
 	}
 }
 
-// WithCircuitV1Support enables support for circuit v1 relays.
-func WithCircuitV1Support() Option {
-	return func(c *config) error {
-		c.enableCircuitV1 = true
-		return nil
-	}
-}
-
 // WithMaxCandidateAge sets the maximum age of a candidate.
 // When we are connected to the desired number of relays, we don't ask the peer source for new candidates.
 // This can lead to AutoRelay's candidate list becoming outdated, and means we won't be able

p2p/host/autorelay/relay_finder.go

@@ -15,21 +15,17 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 	basic "github.com/libp2p/go-libp2p/p2p/host/basic"
 	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
-	relayv1 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv1/relay"
 	circuitv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/client"
 	circuitv2_proto "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/proto"
 
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
 )
 
-const (
-	protoIDv1 = relayv1.ProtoID
-	protoIDv2 = circuitv2_proto.ProtoIDv2Hop
-)
+const protoIDv2 = circuitv2_proto.ProtoIDv2Hop
 
 // Terminology:
-// Candidate: Once we connect to a node and it supports (v1 / v2) relay protocol,
+// Candidate: Once we connect to a node and it supports relay protocol,
 // we call it a candidate, and consider using it as a relay.
 // Relay: Out of the list of candidates, we select a relay to connect to.
 // Currently, we just randomly select a candidate, but we can employ more sophisticated
@@ -77,7 +73,7 @@ type relayFinder struct {
 	relayUpdated chan struct{}
 
 	relayMx sync.Mutex
-	relays  map[peer.ID]*circuitv2.Reservation // rsvp will be nil if it is a v1 relay
+	relays  map[peer.ID]*circuitv2.Reservation
 
 	cachedAddrs       []ma.Multiaddr
 	cachedAddrsExpiry time.Time
@@ -288,7 +284,7 @@ func (rf *relayFinder) notifyNewCandidate() {
 	}
 }
 
-// handleNewNode tests if a peer supports circuit v1 or v2.
+// handleNewNode tests if a peer supports circuit v2.
 // This method is only run on private nodes.
 // If a peer does, it is added to the candidates map.
 // Note that just supporting the protocol doesn't guarantee that we can also obtain a reservation.
@@ -322,7 +318,7 @@ func (rf *relayFinder) handleNewNode(ctx context.Context, pi peer.AddrInfo) (add
 	return true
 }
 
-// tryNode checks if a peer actually supports either circuit v1 or circuit v2.
+// tryNode checks if a peer actually supports either circuit v2.
 // It does not modify any internal state.
 func (rf *relayFinder) tryNode(ctx context.Context, pi peer.AddrInfo) (supportsRelayV2 bool, err error) {
 	if err := rf.host.Connect(ctx, pi); err != nil {
@@ -357,42 +353,14 @@ func (rf *relayFinder) tryNode(ctx context.Context, pi peer.AddrInfo) (supportsR
 		return false, ctx.Err()
 	}
 
-	protos, err := rf.host.Peerstore().SupportsProtocols(pi.ID, protoIDv1, protoIDv2)
+	protos, err := rf.host.Peerstore().SupportsProtocols(pi.ID, protoIDv2)
 	if err != nil {
 		return false, fmt.Errorf("error checking relay protocol support for peer %s: %w", pi.ID, err)
 	}
-
-	// If the node speaks both, prefer circuit v2
-	var maybeSupportsV1, supportsV2 bool
-	for _, proto := range protos {
-		switch proto {
-		case protoIDv1:
-			maybeSupportsV1 = true
-		case protoIDv2:
-			supportsV2 = true
-		}
-	}
-
-	if supportsV2 {
-		return true, nil
-	}
-
-	if !rf.conf.enableCircuitV1 && !supportsV2 {
+	if len(protos) == 0 {
 		return false, errors.New("doesn't speak circuit v2")
 	}
-	if !maybeSupportsV1 && !supportsV2 {
-		return false, errors.New("doesn't speak circuit v1 or v2")
-	}
-
-	// The node *may* support circuit v1.
-	supportsV1, err := relayv1.CanHop(ctx, rf.host, pi.ID)
-	if err != nil {
-		return false, fmt.Errorf("CanHop failed: %w", err)
-	}
-	if !supportsV1 {
-		return false, errors.New("doesn't speak circuit v1 or v2")
-	}
-	return false, nil
+	return true, nil
 }
 
 // When a new node that could be a relay is found, we receive a notification on the maybeConnectToRelayTrigger chan.
@@ -520,9 +488,6 @@ func (rf *relayFinder) refreshReservations(ctx context.Context, now time.Time) b
 	// find reservations about to expire and refresh them in parallel
 	g := new(errgroup.Group)
 	for p, rsvp := range rf.relays {
-		if rsvp == nil { // this is a circuit v1 relay, there is no reservation
-			continue
-		}
 		if now.Add(rsvpExpirationSlack).Before(rsvp.Expiration) {
 			continue
 		}