chore: remove backwards compatibility with 2.6.0

pkg/bzz/address_test.go

@@ -47,7 +47,12 @@ func TestBzzAddress(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	bzzAddress2, err := bzz.ParseAddress(node1ma.Bytes(), overlay.Bytes(), bzzAddress.Signature, nonce, 1, 3, chequebook.Bytes())
+	node1maSerialized, err := bzz.SerializeUnderlays([]multiaddr.Multiaddr{node1ma})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bzzAddress2, err := bzz.ParseAddress(node1maSerialized, overlay.Bytes(), bzzAddress.Signature, nonce, 1, 3, chequebook.Bytes())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -100,8 +105,13 @@ func TestParseAddress_ChequebookIsSigned(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	node1maSerialized, err := bzz.SerializeUnderlays([]multiaddr.Multiaddr{node1ma})
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	// Swapping the chequebook between sign and parse must invalidate the record.
-	if _, err := bzz.ParseAddress(node1ma.Bytes(), overlay.Bytes(), addr.Signature, nonce, 1, 3, tamperedChequebook.Bytes()); !errors.Is(err, bzz.ErrInvalidAddress) {
+	if _, err := bzz.ParseAddress(node1maSerialized, overlay.Bytes(), addr.Signature, nonce, 1, 3, tamperedChequebook.Bytes()); !errors.Is(err, bzz.ErrInvalidAddress) {
 		t.Fatalf("ParseAddress with tampered chequebook: want ErrInvalidAddress, got %v", err)
 	}
 }
@@ -148,9 +158,14 @@ func TestParseAddress_RejectsNonCanonicalChequebookLength(t *testing.T) {
 		{"long 48 bytes", long48},
 	}
 
+	node1maSerialized, err := bzz.SerializeUnderlays([]multiaddr.Multiaddr{node1ma})
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			if _, err := bzz.ParseAddress(node1ma.Bytes(), overlay.Bytes(), addr.Signature, nonce, 1, 3, tc.wire); !errors.Is(err, bzz.ErrInvalidAddress) {
+			if _, err := bzz.ParseAddress(node1maSerialized, overlay.Bytes(), addr.Signature, nonce, 1, 3, tc.wire); !errors.Is(err, bzz.ErrInvalidAddress) {
 				t.Fatalf("want ErrInvalidAddress for %d-byte chequebook wire, got %v", len(tc.wire), err)
 			}
 		})
@@ -161,10 +176,10 @@ func TestParseAddress_RejectsNonCanonicalChequebookLength(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if _, err := bzz.ParseAddress(node1ma.Bytes(), overlay.Bytes(), emptyAddr.Signature, nonce, 1, 3, nil); err != nil {
+	if _, err := bzz.ParseAddress(node1maSerialized, overlay.Bytes(), emptyAddr.Signature, nonce, 1, 3, nil); err != nil {
 		t.Fatalf("empty chequebook must parse, got %v", err)
 	}
-	if _, err := bzz.ParseAddress(node1ma.Bytes(), overlay.Bytes(), addr.Signature, nonce, 1, 3, cbBytes); err != nil {
+	if _, err := bzz.ParseAddress(node1maSerialized, overlay.Bytes(), addr.Signature, nonce, 1, 3, cbBytes); err != nil {
 		t.Fatalf("20-byte chequebook must parse, got %v", err)
 	}
 }

pkg/bzz/export_test.go

@@ -5,7 +5,6 @@
 package bzz
 
 const (
-	UnderlayListPrefix  = underlayListPrefix
 	MaxUnderlaysPerPeer = maxUnderlaysPerPeer
 	MaxUnderlayBytes    = maxUnderlayBytes
 )

pkg/bzz/underlay.go

@@ -23,12 +23,6 @@ var (
 	ErrUnderlayCountExceeded = errors.New("underlay count exceeded")
 )
 
-// underlayListPrefix is a magic byte designated for identifying a serialized list of multiaddrs.
-// A value of 0x99 (153) was chosen as it is not a defined multiaddr protocol code.
-// This ensures that a failure is triggered by the original multiaddr.NewMultiaddrBytes function,
-// which expects a valid protocol code at the start of the data.
-const underlayListPrefix byte = 0x99
-
 // maxUnderlaysPerPeer is the maximum number of underlay addresses allowed per peer.
 // This prevents abuse where a malicious peer sends a huge number of multiaddrs.
 const maxUnderlaysPerPeer = 20
@@ -39,29 +33,13 @@ const maxUnderlaysPerPeer = 20
 const maxUnderlayBytes = 2048
 
 // SerializeUnderlays serializes a slice of multiaddrs into a single byte slice.
-// If the slice contains exactly one address, the standard, backward-compatible
-// multiaddr format is used. For zero or more than one address, a custom list format
-// prefixed with a magic byte is utilized.
-// Returns an error wrapping ErrUnderlayCountExceeded or ErrUnderlayByteSizeExceeded
-// if the limits are violated.
 func SerializeUnderlays(addrs []multiaddr.Multiaddr) ([]byte, error) {
 	if len(addrs) > maxUnderlaysPerPeer {
 		return nil, fmt.Errorf("underlay count %d exceeds maximum of %d: %w", len(addrs), maxUnderlaysPerPeer, ErrUnderlayCountExceeded)
 	}
 
-	// Backward compatibility if exactly one address is present.
-	if len(addrs) == 1 {
-		b := addrs[0].Bytes()
-		if len(b) > maxUnderlayBytes {
-			return nil, fmt.Errorf("underlay data size %d exceeds maximum of %d bytes: %w", len(b), maxUnderlayBytes, ErrUnderlayByteSizeExceeded)
-		}
-		return b, nil
-	}
-
-	// For 0 or 2+ addresses, the custom list format with the prefix is used.
-	// The format is: [prefix_byte][varint_len_1][addr_1_bytes]...
+	// The format is: [varint_len_1][addr_1_bytes]...
 	var buf bytes.Buffer
-	buf.WriteByte(underlayListPrefix)
 
 	for _, addr := range addrs {
 		addrBytes := addr.Bytes()
@@ -77,33 +55,19 @@ func SerializeUnderlays(addrs []multiaddr.Multiaddr) ([]byte, error) {
 }
 
 // DeserializeUnderlays deserializes a byte slice into a slice of multiaddrs.
-// The data format is automatically detected as either a single legacy multiaddr
-// or a list of multiaddrs (identified by underlayListPrefix), and is parsed accordingly.
 func DeserializeUnderlays(data []byte) ([]multiaddr.Multiaddr, error) {
 	if len(data) == 0 {
-		return nil, errors.New("cannot deserialize empty byte slice")
+		return nil, nil
 	}
 
 	if len(data) > maxUnderlayBytes {
 		return nil, fmt.Errorf("underlay data size %d exceeds maximum of %d bytes: %w", len(data), maxUnderlayBytes, ErrUnderlayByteSizeExceeded)
 	}
 
-	// If the data begins with the magic prefix, it is handled as a list.
-	if data[0] == underlayListPrefix {
-		return deserializeList(data[1:])
-	}
-
-	// Otherwise, the data is handled as a single, backward-compatible multiaddr.
-	addr, err := multiaddr.NewMultiaddrBytes(data)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse as single multiaddr: %w", err)
-	}
-	// The result is returned as a single-element slice for a consistent return type.
-	return []multiaddr.Multiaddr{addr}, nil
+	return deserializeList(data)
 }
 
-// deserializeList handles the parsing of the custom list format.
-// The provided data is expected to have already been stripped of the underlayListPrefix.
+// deserializeList handles the parsing of the underlays list format.
 func deserializeList(data []byte) ([]multiaddr.Multiaddr, error) {
 	var addrs []multiaddr.Multiaddr
 	r := bytes.NewReader(data)

pkg/bzz/underlay_test.go

@@ -24,28 +24,15 @@ func TestSerializeUnderlays(t *testing.T) {
 		addrs := []multiaddr.Multiaddr{ip4TCPAddr, p2pAddr, wssAddr, dnsSwarmAddr}
 		serialized := mustSerializeUnderlays(t, addrs)
 
-		if serialized[0] != bzz.UnderlayListPrefix {
-			t.Errorf("expected prefix %x for multiple addresses, got %x", bzz.UnderlayListPrefix, serialized[0])
-		}
-	})
-
-	t.Run("single address list", func(t *testing.T) {
-		addrs := []multiaddr.Multiaddr{dnsSwarmAddr}
-		serialized := mustSerializeUnderlays(t, addrs)
-		expected := dnsSwarmAddr.Bytes() // Should be legacy format without prefix
-
-		if !bytes.Equal(serialized, expected) {
-			t.Errorf("expected single address to serialize to legacy format %x, got %x", expected, serialized)
-		}
-		if serialized[0] == bzz.UnderlayListPrefix {
-			t.Error("single address serialization should not have the list prefix")
+		if len(serialized) == 0 {
+			t.Error("expected serialized bytes for non-empty list")
 		}
 	})
 
 	t.Run("empty list", func(t *testing.T) {
 		addrs := []multiaddr.Multiaddr{}
 		serialized := mustSerializeUnderlays(t, addrs)
-		expected := []byte{bzz.UnderlayListPrefix}
+		expected := []byte{}
 		if !bytes.Equal(serialized, expected) {
 			t.Errorf("expected %x for empty list, got %x", expected, serialized)
 		}
@@ -54,7 +41,7 @@ func TestSerializeUnderlays(t *testing.T) {
 	t.Run("nil list", func(t *testing.T) {
 		var addrs []multiaddr.Multiaddr = nil
 		serialized := mustSerializeUnderlays(t, addrs)
-		expected := []byte{bzz.UnderlayListPrefix}
+		expected := []byte{}
 		if !bytes.Equal(serialized, expected) {
 			t.Errorf("expected %x for nil list, got %x", expected, serialized)
 		}
@@ -90,26 +77,8 @@ func TestDeserializeUnderlays(t *testing.T) {
 		}
 	})
 
-	t.Run("single legacy multiaddr", func(t *testing.T) {
-		singleBytes := wssAddr.Bytes()
-		deserialized, err := bzz.DeserializeUnderlays(singleBytes)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(deserialized) != 1 || !deserialized[0].Equal(wssAddr) {
-			t.Errorf("expected [%v], got %v", wssAddr, deserialized)
-		}
-	})
-
 	t.Run("empty byte slice", func(t *testing.T) {
-		_, err := bzz.DeserializeUnderlays([]byte{})
-		if err == nil {
-			t.Error("expected an error for empty slice, but got nil")
-		}
-	})
-
-	t.Run("list with only prefix", func(t *testing.T) {
-		deserialized, err := bzz.DeserializeUnderlays([]byte{bzz.UnderlayListPrefix})
+		deserialized, err := bzz.DeserializeUnderlays([]byte{})
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -121,8 +90,8 @@ func TestDeserializeUnderlays(t *testing.T) {
 	t.Run("serialize deserialize empty list", func(t *testing.T) {
 		addrs := []multiaddr.Multiaddr{}
 		serialized := mustSerializeUnderlays(t, addrs)
-		if !bytes.Equal(serialized, []byte{bzz.UnderlayListPrefix}) {
-			t.Errorf("expected %v, got %v", []byte{bzz.UnderlayListPrefix}, serialized)
+		if !bytes.Equal(serialized, []byte{}) {
+			t.Errorf("expected %v, got %v", []byte{}, serialized)
 		}
 		deserialized, err := bzz.DeserializeUnderlays(serialized)
 		if err != nil {
@@ -135,8 +104,8 @@ func TestDeserializeUnderlays(t *testing.T) {
 
 	t.Run("serialize deserialize nil list", func(t *testing.T) {
 		serialized := mustSerializeUnderlays(t, nil)
-		if !bytes.Equal(serialized, []byte{bzz.UnderlayListPrefix}) {
-			t.Errorf("expected %v, got %v", []byte{bzz.UnderlayListPrefix}, serialized)
+		if !bytes.Equal(serialized, []byte{}) {
+			t.Errorf("expected %v, got %v", []byte{}, serialized)
 		}
 		deserialized, err := bzz.DeserializeUnderlays(serialized)
 		if err != nil {
@@ -150,7 +119,6 @@ func TestDeserializeUnderlays(t *testing.T) {
 	t.Run("corrupted list - length too long", func(t *testing.T) {
 		maBytes := ip4TCPAddr.Bytes()
 		var buf bytes.Buffer
-		buf.WriteByte(bzz.UnderlayListPrefix)
 		buf.Write(varint.ToUvarint(uint64(len(maBytes) + 5))) // Write a length that is too long
 		buf.Write(maBytes)
 
@@ -163,7 +131,6 @@ func TestDeserializeUnderlays(t *testing.T) {
 	t.Run("corrupted list - invalid multiaddr bytes", func(t *testing.T) {
 		invalidAddrBytes := []byte{0xde, 0xad, 0xbe, 0xef}
 		var buf bytes.Buffer
-		buf.WriteByte(bzz.UnderlayListPrefix)
 		buf.Write(varint.ToUvarint(uint64(len(invalidAddrBytes))))
 		buf.Write(invalidAddrBytes)
 
@@ -177,7 +144,6 @@ func TestDeserializeUnderlays(t *testing.T) {
 		// Build a list with MaxUnderlaysPerPeer+1 entries.
 		addr := mustNewMultiaddr(t, "/ip4/1.2.3.4/tcp/80")
 		var buf bytes.Buffer
-		buf.WriteByte(bzz.UnderlayListPrefix)
 		for range bzz.MaxUnderlaysPerPeer + 1 {
 			addrBytes := addr.Bytes()
 			buf.Write(varint.ToUvarint(uint64(len(addrBytes))))
@@ -193,7 +159,6 @@ func TestDeserializeUnderlays(t *testing.T) {
 		// Build a list with exactly MaxUnderlaysPerPeer entries.
 		addr := mustNewMultiaddr(t, "/ip4/1.2.3.4/tcp/80")
 		var buf bytes.Buffer
-		buf.WriteByte(bzz.UnderlayListPrefix)
 		for range bzz.MaxUnderlaysPerPeer {
 			addrBytes := addr.Bytes()
 			buf.Write(varint.ToUvarint(uint64(len(addrBytes))))
@@ -212,7 +177,6 @@ func TestDeserializeUnderlays(t *testing.T) {
 		// Build a payload larger than MaxUnderlayBytes.
 		addr := mustNewMultiaddr(t, "/ip4/1.2.3.4/tcp/80")
 		var buf bytes.Buffer
-		buf.WriteByte(bzz.UnderlayListPrefix)
 		for buf.Len() <= bzz.MaxUnderlayBytes {
 			addrBytes := addr.Bytes()
 			buf.Write(varint.ToUvarint(uint64(len(addrBytes))))
@@ -268,42 +232,6 @@ func TestSerializeUnderlaysDeserializeUnderlays(t *testing.T) {
 	})
 }
 
-func TestLegacyCompatibility(t *testing.T) {
-	ip4TCPAddr := mustNewMultiaddr(t, "/ip4/1.2.3.4/tcp/5678/p2p/QmWqeeHEqG2db37JsuKUxyJ2JF8LtVJMGohKVT8h3aeCVH")
-	p2pAddr := mustNewMultiaddr(t, "/ip4/65.108.66.216/tcp/16341/p2p/QmVuCJ3M96c7vwv4MQBv7WY1HWQacyCEHvM99R8MUDj95d")
-	dnsSwarmAddr := mustNewMultiaddr(t, "/dnsaddr/mainnet.ethswarm.org")
-
-	t.Run("legacy parser fails on new list format", func(t *testing.T) {
-		addrs := []multiaddr.Multiaddr{ip4TCPAddr, p2pAddr, dnsSwarmAddr}
-		listBytes := mustSerializeUnderlays(t, addrs) // This will have the prefix
-		_, err := multiaddr.NewMultiaddrBytes(listBytes)
-		if err == nil {
-			t.Error("expected legacy NewMultiaddrBytes to fail on list format, but it succeeded")
-		}
-	})
-
-	t.Run("legacy parser succeeds on new single-addr format", func(t *testing.T) {
-		addrs := []multiaddr.Multiaddr{dnsSwarmAddr}
-		singleBytes := mustSerializeUnderlays(t, addrs) // This will NOT have the prefix
-		_, err := multiaddr.NewMultiaddrBytes(singleBytes)
-		if err != nil {
-			t.Errorf("expected legacy NewMultiaddrBytes to succeed on single-addr format, but it failed: %v", err)
-		}
-	})
-
-	t.Run("new parser succeeds on legacy format", func(t *testing.T) {
-		singleBytes := p2pAddr.Bytes()
-		deserialized, err := bzz.DeserializeUnderlays(singleBytes)
-		if err != nil {
-			t.Fatalf("Deserialize failed on legacy bytes: %v", err)
-		}
-		expected := []multiaddr.Multiaddr{p2pAddr}
-		if !reflect.DeepEqual(expected, deserialized) {
-			t.Errorf("expected %v, got %v", expected, deserialized)
-		}
-	})
-}
-
 func mustSerializeUnderlays(tb testing.TB, addrs []multiaddr.Multiaddr) []byte {
 	tb.Helper()
 	b, err := bzz.SerializeUnderlays(addrs)

pkg/hive/hive.go

@@ -69,7 +69,7 @@ type Options struct {
 }
 
 type Service struct {
-	streamer          p2p.Bee260CompatibilityStreamer
+	streamer          p2p.Streamer
 	addressBook       addressbook.GetPutter
 	addPeersHandler   func(...swarm.Address)
 	networkID         uint64
@@ -92,7 +92,7 @@ type Service struct {
 	chequebookStorer   ChequebookStorer
 }
 
-func New(streamer p2p.Bee260CompatibilityStreamer, addressbook addressbook.GetPutter, networkID uint64, overlay swarm.Address, logger log.Logger, o Options) *Service {
+func New(streamer p2p.Streamer, addressbook addressbook.GetPutter, networkID uint64, overlay swarm.Address, logger log.Logger, o Options) *Service {
 	svc := &Service{
 		streamer:           streamer,
 		logger:             logger.WithName(loggerName).Register(),