Remove redundant Dto

node/src/main/scala/com/wavesplatform/Application.scala

@@ -481,7 +481,7 @@ class Application(val actorSystem: ActorSystem, val settings: WavesSettings, con
       log.info(s"REST API was bound on ${settings.restAPISettings.bindAddress}:${settings.restAPISettings.port}")
     }
 
-    for (addr <- settings.networkSettings.declaredAddress if settings.networkSettings.uPnPSettings.enable) {
+    for (addr <- settings.networkSettings.derivedDeclaredAddress if settings.networkSettings.uPnPSettings.enable) {
       upnp.addPort(addr.getPort)
     }
 
@@ -501,7 +501,7 @@ class Application(val actorSystem: ActorSystem, val settings: WavesSettings, con
       log.info("Closing REST API")
       if (settings.restAPISettings.enable)
         Try(Await.ready(serverBinding.unbind(), 2.minutes)).failed.map(e => log.error("Failed to unbind REST API port", e))
-      for (addr <- settings.networkSettings.declaredAddress if settings.networkSettings.uPnPSettings.enable) upnp.deletePort(addr.getPort)
+      for (addr <- settings.networkSettings.derivedDeclaredAddress if settings.networkSettings.uPnPSettings.enable) upnp.deletePort(addr.getPort)
 
       log.debug("Closing peer database")
       peerDatabase.close()
@@ -604,12 +604,12 @@ object Application extends ScorexLogging {
   }
 
   private[wavesplatform] def loadBlockAt(rdb: RDB, blockchainUpdater: BlockchainUpdaterImpl)(
-    height: Int
+      height: Int
   ): Option[(BlockMeta, Seq[(TxMeta, Transaction)])] =
     loadBlockInfoAt(rdb, blockchainUpdater)(height)
 
   private[wavesplatform] def loadBlockInfoAt(rdb: RDB, blockchainUpdater: BlockchainUpdaterImpl)(
-    height: Int
+      height: Int
   ): Option[(BlockMeta, Seq[(TxMeta, Transaction)])] =
     loadBlockMetaAt(rdb.db, blockchainUpdater)(height).map { meta =>
       meta -> blockchainUpdater

node/src/main/scala/com/wavesplatform/network/NetworkServer.scala

@@ -39,7 +39,7 @@ object NetworkServer extends ScorexLogging {
       peerDatabase: PeerDatabase,
       allChannels: ChannelGroup,
       peerInfo: ConcurrentHashMap[Channel, PeerInfo],
-      protocolSpecificPipeline: => Seq[ChannelHandlerAdapter],
+      protocolSpecificPipeline: => Seq[ChannelHandlerAdapter]
   ): NetworkServer = {
     @volatile var shutdownInitiated = false
 
@@ -48,21 +48,21 @@ object NetworkServer extends ScorexLogging {
     val handshake = Handshake(
       applicationName,
       Version.VersionTuple,
-      networkSettings.nodeName,
-      networkSettings.nonce,
-      networkSettings.declaredAddress
+      networkSettings.derivedNodeName,
+      networkSettings.derivedNonce,
+      networkSettings.derivedDeclaredAddress
     )
 
     val excludedAddresses: Set[InetSocketAddress] =
-      networkSettings.bindAddress.fold(Set.empty[InetSocketAddress]) { bindAddress =>
+      networkSettings.derivedBindAddress.fold(Set.empty[InetSocketAddress]) { bindAddress =>
         val isLocal = Option(bindAddress.getAddress).exists(_.isAnyLocalAddress)
         val localAddresses = if (isLocal) {
           NetworkInterface.getNetworkInterfaces.asScala
             .flatMap(_.getInetAddresses.asScala.map(a => new InetSocketAddress(a, bindAddress.getPort)))
             .toSet
         } else Set(bindAddress)
 
-        localAddresses ++ networkSettings.declaredAddress.toSet
+        localAddresses ++ networkSettings.derivedDeclaredAddress.toSet
       }
 
     val lengthFieldPrepender = new LengthFieldPrepender(4)
@@ -90,7 +90,7 @@ object NetworkServer extends ScorexLogging {
       ) ++ protocolSpecificPipeline ++
         Seq(writeErrorHandler, channelClosedHandler, fatalErrorHandler)
 
-    val serverChannel = networkSettings.bindAddress.map { bindAddress =>
+    val serverChannel = networkSettings.derivedBindAddress.map { bindAddress =>
       new ServerBootstrap()
         .group(bossGroup, workerGroup)
         .channel(classOf[NioServerSocketChannel])
@@ -203,7 +203,8 @@ object NetworkServer extends ScorexLogging {
     }
 
     def scheduleConnectTask(): Unit = if (!shutdownInitiated) {
-      val delay = (if (peerConnectionsMap.isEmpty || networkSettings.minConnections.exists(_ > peerConnectionsMap.size())) AverageHandshakePeriod else 5.seconds) +
+      val delay = (if (peerConnectionsMap.isEmpty || networkSettings.minConnections.exists(_ > peerConnectionsMap.size())) AverageHandshakePeriod
+                   else 5.seconds) +
         (Random.nextInt(1000) - 500).millis // add some noise so that nodes don't attempt to connect to each other simultaneously
 
       workerGroup.schedule(delay) {

node/src/main/scala/com/wavesplatform/network/PeerDatabaseImpl.scala

@@ -49,7 +49,7 @@ class PeerDatabaseImpl(settings: NetworkSettings, ticker: Ticker = Ticker.system
 
   override def addCandidate(socketAddress: InetSocketAddress): Boolean = unverifiedPeers.synchronized {
     val r = !socketAddress.getAddress.isAnyLocalAddress &&
-      !(socketAddress.getAddress.isLoopbackAddress && settings.bindAddress.exists(_.getPort == socketAddress.getPort)) &&
+      !(socketAddress.getAddress.isLoopbackAddress && settings.derivedBindAddress.exists(_.getPort == socketAddress.getPort)) &&
       Option(peersPersistence.getIfPresent(socketAddress)).isEmpty &&
       !unverifiedPeers.contains(socketAddress)
     if (r) unverifiedPeers.add(socketAddress)

node/src/main/scala/com/wavesplatform/settings/NetworkSettings.scala

@@ -2,17 +2,14 @@ package com.wavesplatform.settings
 
 import com.wavesplatform.network.TrafficLogger
 import com.wavesplatform.utils.*
-import pureconfig.*
-import pureconfig.generic.auto.*
-
 import java.io.File
 import java.net.{InetSocketAddress, URI}
 import scala.concurrent.duration.FiniteDuration
 import scala.util.Random
 
 case class UPnPSettings(enable: Boolean, gatewayTimeout: FiniteDuration, discoverTimeout: FiniteDuration)
 
-case class NetworkSettingsDto(
+case class NetworkSettings(
     file: Option[File],
     bindAddress: Option[String],
     port: Option[Int],
@@ -38,79 +35,35 @@ case class NetworkSettingsDto(
     upnp: UPnPSettings,
     trafficLogger: TrafficLogger.Settings
 ) {
-  def toNetworkSettings: NetworkSettings = {
-    def randomNonce: Long = {
-      val base = 1000
-      (Random.nextInt(base) + base) * Random.nextInt(base) + Random.nextInt(base)
-    }
-    val MaxNodeNameBytesLength = 127
 
-    val declaredAddress1 = declaredAddress.map { address =>
-      val uri = new URI(s"my://$address")
-      new InetSocketAddress(uri.getHost, uri.getPort)
-    }
-    val nonce1    = nonce.getOrElse(randomNonce)
-    val nodeName1 = nodeName.getOrElse(s"Node-$nonce1")
-    require(nodeName1.utf8Bytes.length <= MaxNodeNameBytesLength, s"Node name should have length less than $MaxNodeNameBytesLength bytes")
-    val bindAddress1 = for {
-      addr <- bindAddress
-      p    <- port
-    } yield new InetSocketAddress(addr, p)
-
-    NetworkSettings(
-      file = file,
-      bindAddress = bindAddress1,
-      declaredAddress = declaredAddress1,
-      nodeName = nodeName1,
-      nonce = nonce1,
-      knownPeers = knownPeers,
-      peersDataResidenceTime = peersDataResidenceTime,
-      blackListResidenceTime = blackListResidenceTime,
-      breakIdleConnectionsTimeout = breakIdleConnectionsTimeout,
-      maxInboundConnections = maxInboundConnections,
-      maxOutboundConnections = maxOutboundConnections,
-      maxConnectionsPerHost = maxSingleHostConnections,
-      minConnections = minConnections,
-      connectionTimeout = connectionTimeout,
-      maxUnverifiedPeers = maxUnverifiedPeers,
-      enablePeersExchange = enablePeersExchange,
-      enableBlacklisting = enableBlacklisting,
-      peersBroadcastInterval = peersBroadcastInterval,
-      handshakeTimeout = handshakeTimeout,
-      suspensionResidenceTime = suspensionResidenceTime,
-      receivedTxsCacheTimeout = receivedTxsCacheTimeout,
-      uPnPSettings = upnp,
-      trafficLogger = trafficLogger
-    )
+  val derivedDeclaredAddress: Option[InetSocketAddress] = declaredAddress.map { address =>
+    val uri = new URI(s"my://$address")
+    new InetSocketAddress(uri.getHost, uri.getPort)
   }
-}
 
-case class NetworkSettings(
-    file: Option[File],
-    bindAddress: Option[InetSocketAddress],
-    declaredAddress: Option[InetSocketAddress],
-    nodeName: String,
-    nonce: Long,
-    knownPeers: Seq[String],
-    peersDataResidenceTime: FiniteDuration,
-    blackListResidenceTime: FiniteDuration,
-    breakIdleConnectionsTimeout: FiniteDuration,
-    maxInboundConnections: Int,
-    maxOutboundConnections: Int,
-    maxConnectionsPerHost: Int,
-    minConnections: Option[Int],
-    connectionTimeout: FiniteDuration,
-    maxUnverifiedPeers: Int,
-    enablePeersExchange: Boolean,
-    enableBlacklisting: Boolean,
-    peersBroadcastInterval: FiniteDuration,
-    handshakeTimeout: FiniteDuration,
-    suspensionResidenceTime: FiniteDuration,
-    receivedTxsCacheTimeout: FiniteDuration,
-    uPnPSettings: UPnPSettings,
-    trafficLogger: TrafficLogger.Settings
-)
+  val derivedNonce: Long = nonce.getOrElse(NetworkSettings.randomNonce)
+
+  val derivedNodeName: String = nodeName.getOrElse(s"Node-$derivedNonce")
+  require(
+    derivedNodeName.utf8Bytes.length <= NetworkSettings.MaxNodeNameBytesLength,
+    s"Node name should have length less than ${NetworkSettings.MaxNodeNameBytesLength} bytes"
+  )
+
+  val derivedBindAddress: Option[InetSocketAddress] = for {
+    addr <- bindAddress
+    p    <- port
+  } yield new InetSocketAddress(addr, p)
+
+  val maxConnectionsPerHost: Int = maxSingleHostConnections
+
+  val uPnPSettings: UPnPSettings = upnp
+}
 
 object NetworkSettings {
-  implicit val configReader: ConfigReader[NetworkSettings] = ConfigReader[NetworkSettingsDto].map(_.toNetworkSettings)
+  val MaxNodeNameBytesLength = 127
+
+  def randomNonce: Long = {
+    val base = 1000
+    (Random.nextInt(base) + base) * Random.nextInt(base) + Random.nextInt(base)
+  }
 }

node/tests/src/test/scala/com/wavesplatform/network/BlacklistParallelSpecification.scala

@@ -5,6 +5,7 @@ import com.wavesplatform.settings.{NetworkSettings, loadConfig}
 import com.wavesplatform.test.FeatureSpec
 import org.scalatest.{GivenWhenThen, ParallelTestExecution}
 import pureconfig.ConfigSource
+import pureconfig.generic.auto.*
 
 import java.net.{InetAddress, InetSocketAddress}
 

node/tests/src/test/scala/com/wavesplatform/network/BlacklistSpecification.scala

@@ -6,6 +6,7 @@ import com.wavesplatform.settings.NetworkSettings
 import com.wavesplatform.test.FeatureSpec
 import org.scalatest.GivenWhenThen
 import pureconfig.ConfigSource
+import pureconfig.generic.auto.*
 
 import java.net.{InetAddress, InetSocketAddress}
 
@@ -29,9 +30,12 @@ class BlacklistSpecification extends FeatureSpec with GivenWhenThen {
   Feature("Blacklist") {
     Scenario("Peer blacklist another peer") {
       Given("Peer database is empty")
-      val peerDatabase = new PeerDatabaseImpl(networkSettings, new Ticker {
-        override def read(): Long = timestamp
-      })
+      val peerDatabase = new PeerDatabaseImpl(
+        networkSettings,
+        new Ticker {
+          override def read(): Long = timestamp
+        }
+      )
 
       def isBlacklisted(address: InetSocketAddress) = peerDatabase.isBlacklisted(address.getAddress)
 

node/tests/src/test/scala/com/wavesplatform/network/peer/PeerDatabaseImplSpecification.scala

@@ -6,6 +6,7 @@ import com.wavesplatform.network.{PeerDatabase, PeerDatabaseImpl}
 import com.wavesplatform.settings.NetworkSettings
 import com.wavesplatform.test.FreeSpec
 import pureconfig.ConfigSource
+import pureconfig.generic.auto.*
 
 import java.net.InetSocketAddress
 import scala.concurrent.duration.*

node/tests/src/test/scala/com/wavesplatform/settings/NetworkSettingsSpecification.scala

@@ -4,6 +4,7 @@ import java.net.InetSocketAddress
 import com.typesafe.config.ConfigFactory
 import com.wavesplatform.test.FlatSpec
 import pureconfig.ConfigSource
+import pureconfig.generic.auto.*
 import pureconfig.error.ConfigReaderException
 import scala.concurrent.duration.*
 
@@ -41,10 +42,10 @@ class NetworkSettingsSpecification extends FlatSpec {
                                                         |}""".stripMargin))
     val networkSettings = ConfigSource.fromConfig(config).at("waves.network").loadOrThrow[NetworkSettings]
 
-    networkSettings.bindAddress should be(Some(new InetSocketAddress("127.0.0.1", 6868)))
-    networkSettings.nodeName should be("default-node-name")
-    networkSettings.declaredAddress should be(Some(new InetSocketAddress("127.0.0.1", 6868)))
-    networkSettings.nonce should be(0)
+    networkSettings.derivedBindAddress should be(Some(new InetSocketAddress("127.0.0.1", 6868)))
+    networkSettings.derivedNodeName should be("default-node-name")
+    networkSettings.derivedDeclaredAddress should be(Some(new InetSocketAddress("127.0.0.1", 6868)))
+    networkSettings.derivedNonce should be(0)
     networkSettings.knownPeers should be(List("8.8.8.8:6868", "4.4.8.8:6868"))
     networkSettings.peersDataResidenceTime should be(1.day)
     networkSettings.blackListResidenceTime should be(10.minutes)