multi: remove tor v2 onion address encoder paths

erickcestari · erickcestari · commit 6706f450e8dd · 2026-05-14T14:50:24.000-03:00
Drop the v2 onion encoder branches from lnwire.WriteOnionAddr,
graph/db.encodeOnionAddr, graph/db.collectAddressRecords, and the
tor.OnionHostToFakeIP helper. lnd no longer produces v2 onion addresses
on any code path.

Decoders for v2 addresses are intentionally retained in lnwire,
graph/db, and tor so that existing graph databases and peer-announced
v2 addresses continue to deserialize. Update unit tests to use v3 onion
fixtures.
diff --git a/chanbackup/single_test.go b/chanbackup/single_test.go
@@ -38,8 +38,9 @@ var (
 	addr1, _ = net.ResolveTCPAddr("tcp", "10.0.0.2:9000")
 	addr2, _ = net.ResolveTCPAddr("tcp", "10.0.0.3:9000")
 	addr3    = &tor.OnionAddr{
-		OnionService: "3g2upl4pq6kufc4m.onion",
-		Port:         9735,
+		OnionService: "vww6ybal4bd7szmgncyruucpgfkqahzd" +
+			"di37ktceo3ah7ngmcopnpyyd.onion",
+		Port: 9735,
 	}
 	addr4 = &lnwire.DNSAddress{
 		Hostname: "example.com",
diff --git a/graph/db/addr.go b/graph/db/addr.go
@@ -104,11 +104,6 @@ func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
 	var suffixIndex int
 	hostLen := len(addr.OnionService)
 	switch hostLen {
-	case tor.V2Len:
-		if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {
-			return err
-		}
-		suffixIndex = tor.V2Len - tor.OnionSuffixLen
 	case tor.V3Len:
 		if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {
 			return err
@@ -131,12 +126,7 @@ func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
 	}
 
 	// Sanity check the decoded length.
-	switch {
-	case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:
-		return fmt.Errorf("onion service %v decoded to invalid host %x",
-			addr.OnionService, host)
-
-	case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:
+	if hostLen == tor.V3Len && len(host) != tor.V3DecodedLen {
 		return fmt.Errorf("onion service %v decoded to invalid host %x",
 			addr.OnionService, host)
 	}
diff --git a/graph/db/addr_test.go b/graph/db/addr_test.go
@@ -29,11 +29,6 @@ var (
 		Port: 65535,
 	}
 
-	testOnionV2Addr = &tor.OnionAddr{
-		OnionService: "3g2upl4pq6kufc4m.onion",
-		Port:         9735,
-	}
-
 	testOnionV3Addr = &tor.OnionAddr{
 		OnionService: "vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd.onion", //nolint:ll
 		Port:         80,
@@ -63,9 +58,6 @@ var addrTests = []struct {
 	{
 		expAddr: testIPV6Addr,
 	},
-	{
-		expAddr: testOnionV2Addr,
-	},
 	{
 		expAddr: testOnionV3Addr,
 	},
diff --git a/graph/db/graph_test.go b/graph/db/graph_test.go
@@ -400,8 +400,7 @@ func testNodeInsertionAndDeletion(t *testing.T, v lnwire.GossipVersion) {
 		// Add 2 IPV6 addresses.
 		testIPV6Addr,
 		anotherAddr,
-		// Add one v2 and one v3 onion address.
-		testOnionV2Addr,
+		// Add a v3 onion address.
 		testOnionV3Addr,
 		// Add a DNS host address.
 		testDNSAddr,
@@ -439,7 +438,6 @@ func testNodeInsertionAndDeletion(t *testing.T, v lnwire.GossipVersion) {
 
 	// Finally, update the set to only contain the Tor addresses.
 	expAddrs = []net.Addr{
-		testOnionV2Addr,
 		testOnionV3Addr,
 	}
 	node = nodeWithAddrs(expAddrs)
diff --git a/graph/db/sql_store.go b/graph/db/sql_store.go
@@ -4821,7 +4821,6 @@ func collectAddressRecords(addresses []net.Addr) (map[dbAddressType][]string,
 	newAddresses := map[dbAddressType][]string{
 		addressTypeIPv4:   {},
 		addressTypeIPv6:   {},
-		addressTypeTorV2:  {},
 		addressTypeTorV3:  {},
 		addressTypeDNS:    {},
 		addressTypeOpaque: {},
@@ -4844,8 +4843,6 @@ func collectAddressRecords(addresses []net.Addr) (map[dbAddressType][]string,
 
 		case *tor.OnionAddr:
 			switch len(addr.OnionService) {
-			case tor.V2Len:
-				addAddr(addressTypeTorV2, addr)
 			case tor.V3Len:
 				addAddr(addressTypeTorV3, addr)
 			default:
diff --git a/itest/lnd_channel_graph_test.go b/itest/lnd_channel_graph_test.go
@@ -378,7 +378,6 @@ func testNodeAnnouncement(ht *lntest.HarnessTest) {
 	advertisedAddrs := []string{
 		"192.168.1.1:8333",
 		"[2001:db8:85a3:8d3:1319:8a2e:370:7348]:8337",
-		"bkb6azqggsaiskzi.onion:9735",
 		"fomvuglh6h6vcag73xo5t5gv56ombih3zr2xvplkpbfd7wrog4swj" +
 			"wid.onion:1234",
 	}
@@ -435,7 +434,6 @@ func testUpdateNodeAnnouncement(ht *lntest.HarnessTest) {
 	extraAddrs := []string{
 		"192.168.1.1:8333",
 		"[2001:db8:85a3:8d3:1319:8a2e:370:7348]:8337",
-		"bkb6azqggsaiskzi.onion:9735",
 		"fomvuglh6h6vcag73xo5t5gv56ombih3zr2xvplkpbfd7wrog4swj" +
 			"wid.onion:1234",
 	}
diff --git a/lnwire/lnwire_test.go b/lnwire/lnwire_test.go
@@ -137,8 +137,11 @@ func TestDecodeUnknownAddressType(t *testing.T) {
 
 	// Add an onion address.
 	onionAddr := &tor.OnionAddr{
-		OnionService: "abcdefghijklmnop.onion",
-		Port:         9065,
+		OnionService: "abcdefghij" +
+			"abcdefghijabcdefghij" +
+			"abcdefghijabcdefghij" +
+			"234567.onion",
+		Port: 9065,
 	}
 
 	// Now add an address with an unknown type.
diff --git a/lnwire/message_test.go b/lnwire/message_test.go
@@ -964,24 +964,6 @@ func randTCP6Addr(t testing.TB, r *rand.Rand) *net.TCPAddr {
 	return &net.TCPAddr{IP: addrIP, Port: addrPort}
 }
 
-func randV2OnionAddr(t testing.TB, r *rand.Rand) *tor.OnionAddr {
-	t.Helper()
-
-	var serviceID [tor.V2DecodedLen]byte
-	_, err := r.Read(serviceID[:])
-	require.NoError(t, err, "unable to read serviceID")
-
-	var port [2]byte
-	_, err = r.Read(port[:])
-	require.NoError(t, err, "unable to read port")
-
-	onionService := tor.Base32Encoding.EncodeToString(serviceID[:])
-	onionService += tor.OnionSuffix
-	addrPort := int(binary.BigEndian.Uint16(port[:]))
-
-	return &tor.OnionAddr{OnionService: onionService, Port: addrPort}
-}
-
 func randV3OnionAddr(t testing.TB, r *rand.Rand) *tor.OnionAddr {
 	t.Helper()
 
@@ -1021,11 +1003,10 @@ func randDNSAddr(t testing.TB, r *rand.Rand) *lnwire.DNSAddress {
 func randAddrs(t testing.TB, r *rand.Rand) []net.Addr {
 	tcp4Addr := randTCP4Addr(t, r)
 	tcp6Addr := randTCP6Addr(t, r)
-	v2OnionAddr := randV2OnionAddr(t, r)
 	v3OnionAddr := randV3OnionAddr(t, r)
 	dnsAddr := randDNSAddr(t, r)
 
-	return []net.Addr{tcp4Addr, tcp6Addr, v2OnionAddr, v3OnionAddr, dnsAddr}
+	return []net.Addr{tcp4Addr, tcp6Addr, v3OnionAddr, dnsAddr}
 }
 
 func randAlias(r *rand.Rand) lnwire.NodeAlias {
diff --git a/lnwire/writer.go b/lnwire/writer.go
@@ -336,10 +336,6 @@ func WriteOnionAddr(buf *bytes.Buffer, addr *tor.OnionAddr) error {
 
 	// Decide the suffixIndex and descriptor.
 	switch len(addr.OnionService) {
-	case tor.V2Len:
-		descriptor = []byte{byte(v2OnionAddr)}
-		suffixIndex = tor.V2Len - tor.OnionSuffixLen
-
 	case tor.V3Len:
 		descriptor = []byte{byte(v3OnionAddr)}
 		suffixIndex = tor.V3Len - tor.OnionSuffixLen
diff --git a/lnwire/writer_test.go b/lnwire/writer_test.go
@@ -501,26 +501,14 @@ func TestWriteOnionAddr(t *testing.T) {
 			// the error is returned.
 			name: "invalid base32 encoding",
 			addr: &tor.OnionAddr{
-				OnionService: "1234567890123456.onion",
+				OnionService: "1111111111" +
+					"11111111111111111111" +
+					"11111111111111111111" +
+					"111111.onion",
 			},
 			expectedErr:   base32.CorruptInputError(0),
 			expectedBytes: nil,
 		},
-		{
-			// Check write onion v2.
-			name: "onion address v2",
-			addr: &tor.OnionAddr{
-				OnionService: "abcdefghijklmnop.onion",
-				Port:         9065,
-			},
-			expectedErr: nil,
-			expectedBytes: []byte{
-				0x3,                         // The descriptor.
-				0x0, 0x44, 0x32, 0x14, 0xc7, // The host.
-				0x42, 0x54, 0xb6, 0x35, 0xcf,
-				0x23, 0x69, // The port.
-			},
-		},
 		{
 			// Check write onion v3.
 			name: "onion address v3",
@@ -566,8 +554,11 @@ func TestWriteNetAddrs(t *testing.T) {
 		Port: 8080,
 	}
 	onionAddr := &tor.OnionAddr{
-		OnionService: "abcdefghijklmnop.onion",
-		Port:         9065,
+		OnionService: "abcdefghij" +
+			"abcdefghijabcdefghij" +
+			"abcdefghijabcdefghij" +
+			"234567.onion",
+		Port: 9065,
 	}
 	dnsAddr := &DNSAddress{
 		Hostname: "example.com",
@@ -602,14 +593,18 @@ func TestWriteNetAddrs(t *testing.T) {
 			addr:        []net.Addr{tcpAddr, onionAddr, dnsAddr},
 			expectedErr: nil,
 			expectedBytes: []byte{
-				// 7 bytes for TCP and 13 bytes for onion,
+				// 7 bytes for TCP, 38 bytes for v3 onion,
 				// 15 bytes for DNS.
-				0x0, 0x23,
+				0x0, 0x3c,
 				// TCP address.
 				0x1, 0x7f, 0x0, 0x0, 0x1, 0x1f, 0x90,
-				// Onion address.
-				0x3, 0x0, 0x44, 0x32, 0x14, 0xc7, 0x42,
-				0x54, 0xb6, 0x35, 0xcf, 0x23, 0x69,
+				// V3 onion address.
+				0x4, 0x0, 0x44, 0x32, 0x14, 0xc7, 0x42, 0x40,
+				0x11, 0xc, 0x85, 0x31, 0xd0, 0x90, 0x4,
+				0x43, 0x21, 0x4c, 0x74, 0x24, 0x1, 0x10,
+				0xc8, 0x53, 0x1d, 0x9, 0x0, 0x44, 0x32,
+				0x14, 0xc7, 0x42, 0x75, 0xbe, 0x77, 0xdf,
+				0x23, 0x69,
 				// DNS address.
 				0x5, 0xb, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c,
 				0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x1f, 0x90,
diff --git a/tor/tor.go b/tor/tor.go
@@ -300,27 +300,6 @@ func IsOnionFakeIP(addr net.Addr) bool {
 	return err == nil
 }
 
-// OnionHostToFakeIP encodes an Onion v2 address into a fake IPv6 address that
-// encodes the same information but can be used for libraries that operate on an
-// IP address base only, like btcd's address manager. For example, this will
-// turn the onion host ld47qlr6h2b7hrrf.onion into the ip6 address
-// fd87:d87e:eb43:58f9:f82e:3e3e:83f3:c625.
-func OnionHostToFakeIP(host string) (net.IP, error) {
-	if len(host) != V2Len {
-		return nil, fmt.Errorf("invalid onion v2 host: %v", host)
-	}
-
-	data, err := Base32Encoding.DecodeString(host[:V2Len-OnionSuffixLen])
-	if err != nil {
-		return nil, err
-	}
-
-	ip := make([]byte, len(onionPrefixBytes)+len(data))
-	copy(ip, onionPrefixBytes)
-	copy(ip[len(onionPrefixBytes):], data)
-	return ip, nil
-}
-
 // FakeIPToOnionHost turns a fake IPv6 address that encodes an Onion v2 address
 // back into its onion host address representation. For example, this will turn
 // the fake tcp6 address [fd87:d87e:eb43:58f9:f82e:3e3e:83f3:c625]:8333 back
diff --git a/tor/tor_test.go b/tor/tor_test.go
@@ -13,14 +13,6 @@ const (
 	testFakeIP = "fd87:d87e:eb43:58f9:f82e:3e3e:83f3:c625"
 )
 
-// TestOnionHostToFakeIP tests that an onion host address can be converted into
-// a fake tcp6 address successfully.
-func TestOnionHostToFakeIP(t *testing.T) {
-	ip, err := OnionHostToFakeIP(testOnion)
-	require.NoError(t, err)
-	require.Equal(t, testFakeIP, ip.String())
-}
-
 // TestFakeIPToOnionHost tests that a fake tcp6 address can be converted back
 // into its original .onion host address successfully.
 func TestFakeIPToOnionHost(t *testing.T) {
diff --git a/watchtower/wtdb/codec_test.go b/watchtower/wtdb/codec_test.go
@@ -59,24 +59,6 @@ func randTCP6Addr(r *rand.Rand) (*net.TCPAddr, error) {
 	return &net.TCPAddr{IP: addrIP, Port: addrPort}, nil
 }
 
-func randV2OnionAddr(r *rand.Rand) (*tor.OnionAddr, error) {
-	var serviceID [tor.V2DecodedLen]byte
-	if _, err := r.Read(serviceID[:]); err != nil {
-		return nil, err
-	}
-
-	var port [2]byte
-	if _, err := r.Read(port[:]); err != nil {
-		return nil, err
-	}
-
-	onionService := tor.Base32Encoding.EncodeToString(serviceID[:])
-	onionService += tor.OnionSuffix
-	addrPort := int(binary.BigEndian.Uint16(port[:]))
-
-	return &tor.OnionAddr{OnionService: onionService, Port: addrPort}, nil
-}
-
 func randV3OnionAddr(r *rand.Rand) (*tor.OnionAddr, error) {
 	var serviceID [tor.V3DecodedLen]byte
 	if _, err := r.Read(serviceID[:]); err != nil {
@@ -106,17 +88,12 @@ func randAddrs(r *rand.Rand) ([]net.Addr, error) {
 		return nil, err
 	}
 
-	v2OnionAddr, err := randV2OnionAddr(r)
-	if err != nil {
-		return nil, err
-	}
-
 	v3OnionAddr, err := randV3OnionAddr(r)
 	if err != nil {
 		return nil, err
 	}
 
-	return []net.Addr{tcp4Addr, tcp6Addr, v2OnionAddr, v3OnionAddr}, nil
+	return []net.Addr{tcp4Addr, tcp6Addr, v3OnionAddr}, nil
 }
 
 // dbObject is abstract object support encoding and decoding.
