Style fixes

Author: catena2w

scalastyle-config.xml

@@ -97,7 +97,7 @@
     <check level="warning" class="org.scalastyle.scalariform.PublicMethodsHaveTypeChecker" enabled="true"></check>
     <check level="warning" class="org.scalastyle.file.NewLineAtEofChecker" enabled="true"></check>
     <check level="warning" class="org.scalastyle.file.NoNewLineAtEofChecker" enabled="false"></check>
-    <check level="warning" class="org.scalastyle.scalariform.TodoCommentChecker" enabled="true">
+    <check level="warning" class="org.scalastyle.scalariform.TodoCommentChecker" enabled="false">
         <parameters>
             <parameter name="words">TODO|FIXME|todo|fixme|bug|BUG</parameter>
         </parameters>

src/main/scala/scorex/api/http/ApiError.scala

@@ -28,4 +28,4 @@ object ApiError {
   val invalidNotNumber: Json = ApiError(109, "Argument is not a number")
   val invalidMessage: Json = ApiError(110, "Invalid message")
   val blockNotExists: Json = ApiError(301, "Block does not exist")
-}
+}

src/main/scala/scorex/api/http/CommonApiFunctions.scala

@@ -15,4 +15,4 @@ trait CommonApiFunctions {
       case Some(block) => action(block)
       case None => blockNotExists
     }
-}
+}

src/main/scala/scorex/api/http/SignedMessage.scala

@@ -1,3 +1,3 @@
 package scorex.api.http
 
-case class SignedMessage(message: String, signature: String, publickey: String)
+case class SignedMessage(message: String, signature: String, publickey: String)

src/main/scala/scorex/api/http/swagger/CorsSupport.scala

@@ -34,4 +34,4 @@ trait CorsSupport {
   def corsHandler(r: Route): Route = withAccessControlHeaders {
     preflightRequestHandler ~ r
   }
-}
+}

src/main/scala/scorex/api/http/swagger/SwaggerDocService.scala

@@ -29,4 +29,4 @@ class SwaggerDocService(system: ActorSystem, val apiTypes: Seq[Type], settings:
 
   //Let swagger-ui determine the host and port
   override def swaggerConfig: Swagger = new Swagger().basePath(prependSlashIfNecessary(basePath)).info(info).scheme(scheme)
-}
+}

src/main/scala/scorex/block/Block.scala

@@ -36,7 +36,8 @@ class Block[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData
   type TDataExposed = TData
   type BlockId = ConsensusData.BlockId
 
-  val blockFields = version :: timestamp :: consensusData.consensusFields :: transactionalData.transactionalFields :: HNil
+  val blockFields =
+    version :: timestamp :: consensusData.consensusFields :: transactionalData.transactionalFields :: HNil
 
   lazy val bytes: Array[Byte] = ???
 
@@ -63,35 +64,44 @@ object Block extends ScorexLogging {
   val Version = 1: Byte
 
 
-  def parse[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_], B <: Block[P, CData, TData]](bytes: Array[Byte])
-                                                                                                                 (implicit consensusModule: ConsensusModule[P, CData, B],
-                                                                                                                  transactionalModule: TransactionModule[P, _, TData]): Try[B] = {
+  def parse[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_], B <: Block[P, CData, TData]]
+  (bytes: Array[Byte])
+  (implicit consensusModule: ConsensusModule[P, CData, B],
+   transactionalModule: TransactionModule[P, _, TData]): Try[B] = {
+
     ???
   }
 
-  def build[P <: Proposition, TX <: Transaction[P, TX], CData <: ConsensusData, TData <: TransactionalData[TX]](consensusData: CData)
-                                                                                                               (implicit transactionalModule: TransactionModule[P, TX, TData]): Block[P, CData, TData] = {
+  def build[P <: Proposition, TX <: Transaction[P, TX], CData <: ConsensusData, TData <: TransactionalData[TX]]
+  (consensusData: CData)
+  (implicit transactionalModule: TransactionModule[P, TX, TData]): Block[P, CData, TData] = {
+
     val timestamp = System.currentTimeMillis()
     new Block(Version, timestamp, consensusData, transactionalModule.packUnconfirmed())
   }
 
-  def genesis[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_]](genesisTimestamp: Long)
-                                                                                      (implicit consensusModule: ConsensusModule[P, CData, _ <: Block[P, CData, TData]],
-                                                                                       transactionalModule: TransactionModule[P, _, TData]): Block[P, CData, TData] = {
+  def genesis[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_]]
+  (genesisTimestamp: Long)
+  (implicit consensusModule: ConsensusModule[P, CData, _ <: Block[P, CData, TData]],
+   transactionalModule: TransactionModule[P, _, TData]): Block[P, CData, TData] = {
+
     new Block(Version, genesisTimestamp, consensusModule.genesisData, transactionalModule.genesisData)
   }
 
-  def isValid[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_], B <: Block[P, CData, TData]](block: B)(implicit consensusModule: ConsensusModule[P, CData, B],
-                                                                                                                              transactionalModule: TransactionModule[P, _, TData]): Boolean = {
+  def isValid[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_], B <: Block[P, CData, TData]]
+  (block: B)
+  (implicit consensusModule: ConsensusModule[P, CData, B],
+   transactionalModule: TransactionModule[P, _, TData]): Boolean = {
+
     if (consensusModule.contains(block)) true //applied blocks are valid
     else {
       lazy val consensus = consensusModule.isValid(block)
       lazy val transaction = transactionalModule.isValid(block)
 
-      if (!consensus) log.debug(s"Invalid block ${consensusModule.encodedId(block)}: consensus data is not valid")
-      else if (!transaction) log.debug(s"Invalid block ${consensusModule.encodedId(block)}: transaction data is not valid")
+      if (!consensus) log.debug(s"Invalid consensus data in block ${consensusModule.encodedId(block)}")
+      else if (!transaction) log.debug(s"Invalid transaction data in block ${consensusModule.encodedId(block)}")
 
       consensus && transaction
     }
   }
-}
+}

src/main/scala/scorex/consensus/BlockChain.scala

@@ -29,4 +29,4 @@ trait BlockChain[P <: Proposition, CData <: ConsensusData, B <: Block[P, CData,
   def children(blockId: BlockId): Seq[B]
 
   override lazy val genesisBlock: B = blockAt(1).get
-}
+}

src/main/scala/scorex/consensus/ConsensusModule.scala

@@ -82,4 +82,4 @@ trait ConsensusModule[P <: Proposition, CData <: ConsensusData, B <: Block[P, CD
   }
 
   val genesisData: CData
-}
+}

src/main/scala/scorex/network/Buffering.scala

@@ -47,4 +47,4 @@ trait Buffering {
     }
     multiPacket(List[ByteString](), data)
   }
-}
+}

src/main/scala/scorex/network/Handshake.scala

@@ -79,4 +79,4 @@ object Handshake extends ScorexLogging with BytesParseable[Handshake] {
 
     Handshake(an, av, nodeName, nonce, isaOpt, time)
   }
-}
+}

src/main/scala/scorex/network/HistorySynchronizer.scala

@@ -40,7 +40,10 @@ class HistorySynchronizer(val application: Application) extends ViewSynchronizer
 
   private lazy val blockGenerator = application.blockGenerator
 
-  private val GettingBlockTimeout = application.settings.historySynchronizerTimeout
+  private val settings = application.settings
+  private val GettingBlockTimeout = settings.historySynchronizerTimeout
+  //TODO increase from small number up to maxRollback
+  private val blocksToSend = 100
 
   var lastUpdate = System.currentTimeMillis()
 
@@ -56,8 +59,7 @@ class HistorySynchronizer(val application: Application) extends ViewSynchronizer
 
   }
 
-  override def receive: Receive =
-    if (application.settings.offlineGeneration) gotoSynced() else gotoSyncing()
+  override def receive: Receive = if (settings.offlineGeneration) gotoSynced() else gotoSyncing()
 
   def state(status: Status, logic: Receive): Receive =
   //combine specific logic with common for all the states
@@ -75,7 +77,7 @@ class HistorySynchronizer(val application: Application) extends ViewSynchronizer
 
       case ConsideredValue(None, _) =>
         log.info("Got no score from outer world")
-        if (application.settings.offlineGeneration) gotoSynced() else gotoSyncing()
+        if (settings.offlineGeneration) gotoSynced() else gotoSyncing()
 
       case SelfCheck =>
         if (status != Syncing && System.currentTimeMillis() - lastUpdate > GettingBlockTimeout.toMillis) gotoSyncing()
@@ -92,7 +94,7 @@ class HistorySynchronizer(val application: Application) extends ViewSynchronizer
       val localScore = history.score()
       if (networkScore > localScore) {
         log.info(s"networkScore=$networkScore > localScore=$localScore")
-        val lastIds = history.lastBlocks(100).map(consensusModule.id)
+        val lastIds = history.lastBlocks(blocksToSend).map(consensusModule.id)
         val msg = Message(GetSignaturesSpec, Right(lastIds), None)
         networkControllerRef ! NetworkController.SendToNetwork(msg, SendToChosen(witnesses))
         gotoGettingExtension(networkScore, witnesses)
@@ -252,4 +254,4 @@ object HistorySynchronizer {
 
   case object SelfCheck
 
-}
+}

src/main/scala/scorex/network/PeerConnectionHandler.scala

@@ -165,4 +165,4 @@ object PeerConnectionHandler {
 
   case object Blacklist
 
-}
+}

src/main/scala/scorex/network/PeerSynchronizer.scala

@@ -53,4 +53,4 @@ class PeerSynchronizer(application: Application) extends ViewSynchronizer with S
 
     case nonsense: Any => log.warn(s"PeerSynchronizer: got something strange $nonsense")
   }
-}
+}

src/main/scala/scorex/network/ScoreObserver.scala

@@ -73,4 +73,4 @@ object ScoreObserver {
 
   case class ConsideredValue(value: Option[BigInt], witnesses: Seq[ConnectedPeer])
 
-}
+}

src/main/scala/scorex/network/UPnP.scala

@@ -62,4 +62,4 @@ class UPnP(settings: Settings) extends ScorexLogging {
   }.recover { case t: Throwable =>
     log.error("Unable to delete mapping for port " + port + ": " + t.toString)
   }
-}
+}

src/main/scala/scorex/network/message/BasicMessagesRepo.scala

@@ -15,9 +15,10 @@ import scorex.transaction.proof.Signature25519
 import scala.util.Try
 
 
-class BasicMessagesRepo[P <: Proposition, CData <: ConsensusData, TData <: TransactionalData[_], B <: Block[P, CData, TData]]()
-                                                                                                                             (implicit val transactionalModule: TransactionModule[P, _, TData],
-                                                                                                                              consensusModule: ConsensusModule[P, CData, B]) {
+class BasicMessagesRepo[P <: Proposition, CD <: ConsensusData, TD <: TransactionalData[_], B <: Block[P, CD, TD]]
+()
+(implicit val transactionalModule: TransactionModule[P, _, TD],
+ consensusModule: ConsensusModule[P, CD, B]) {
 
   type BlockId = ConsensusData.BlockId
 
@@ -143,4 +144,4 @@ class BasicMessagesRepo[P <: Proposition, CData <: ConsensusData, TData <: Trans
 
   val specs = Seq(GetPeersSpec, PeersSpec, GetSignaturesSpec, SignaturesSpec,
     GetBlockSpec, BlockMessageSpec, ScoreMessageSpec)
-}
+}

src/main/scala/scorex/network/message/Message.scala

@@ -44,4 +44,4 @@ object Message {
   val MagicLength = MAGIC.length
 
   val ChecksumLength = 4
-}
+}

src/main/scala/scorex/network/peer/PeerDatabaseImpl.scala

@@ -48,4 +48,4 @@ class PeerDatabaseImpl(settings: Settings, filename: Option[String]) extends Pee
 
   override def blacklistedPeers(): Seq[String] = blacklist.keys.toSeq
 
-}
+}

src/main/scala/scorex/settings/SizedConstants.scala

@@ -18,4 +18,4 @@ object SizedConstants {
   type PubKey25519 = Nat32
 
   type Signature25519 = Nat64
-}
+}

src/main/scala/scorex/storage/Storage.scala

@@ -11,4 +11,4 @@ trait Storage[Key, Value] {
   def close(): Unit
 
   def containsKey(key: Key): Boolean = get(key).isDefined
-}
+}

src/main/scala/scorex/transaction/Signable.scala

@@ -9,4 +9,4 @@ trait Signable extends BytesSerializable {
   override lazy val bytes: Array[Byte] = messageToSign ++ proof.bytes
 
   def messageToSign: Array[Byte]
-}
+}

src/main/scala/scorex/transaction/Transaction.scala

@@ -94,4 +94,4 @@ abstract class BoxTransaction[P <: Proposition] extends Transaction[P, BoxTransa
   }
 
   def semanticValidity: Try[Unit]
-}
+}

src/main/scala/scorex/transaction/TransactionModule.scala

@@ -34,4 +34,4 @@ trait TransactionModule[P <: Proposition, TX <: Transaction[P, TX], TBD <: Trans
   def onNewOffchainTransaction(transaction: TX): Unit
 
   val genesisData: TBD
-}
+}

src/main/scala/scorex/transaction/UnconfirmedTransactionsDatabase.scala

@@ -9,4 +9,4 @@ trait UnconfirmedTransactionsDatabase[TX <: Transaction[_, TX]] {
   def getBySignature(signature: Array[Byte]): Option[TX]
 
   def remove(tx: TX)
-}
+}

src/main/scala/scorex/transaction/account/AccountTransactionsHistory.scala

@@ -5,4 +5,4 @@ import scorex.transaction.box.proposition.Proposition
 
 trait AccountTransactionsHistory[P <: Proposition, TX <: Transaction[P, TX]] {
   def accountTransactions(id: P): Array[TX]
-}
+}

src/main/scala/scorex/transaction/account/PublicKey25519NoncedBox.scala

@@ -18,4 +18,4 @@ case class PublicKey25519NoncedBox(
 object PublicKey25519NoncedBox {
   def apply(proposition: PublicKey25519Proposition, value: Long): PublicKey25519NoncedBox =
     PublicKey25519NoncedBox(proposition, 0, value)
-}
+}

src/main/scala/scorex/transaction/box/BoxUnlocker.scala

@@ -6,4 +6,4 @@ import scorex.transaction.proof.Proof
 trait BoxUnlocker[P <: Proposition] {
   val closedBoxId: Array[Byte]
   val boxKey: Proof[P]
-}
+}

src/main/scala/scorex/transaction/box/proposition/Proposition.scala

@@ -11,4 +11,4 @@ trait EmptyProposition extends Proposition
 
 case class HeightOpenProposition(height: Int) extends Proposition {
   override val bytes = Ints.toByteArray(height)
-}
+}

src/main/scala/scorex/transaction/box/proposition/PublicKey25519Proposition.scala

@@ -45,4 +45,4 @@ object PublicKey25519Proposition {
         else Failure(new Exception("Wrong checksum"))
       }
     }
-}
+}

src/main/scala/scorex/transaction/box/sigmacoin/ErgakiBox.scala

@@ -21,4 +21,4 @@ trait ErgakiBox[SL <: SigmaProposition] extends SigmaBox[SL] {
     (bytes.length - SMin + 1) * (gcLock.height - currentHeight)
 
   val memo: Array[Byte]
-}
+}

src/main/scala/scorex/transaction/proof/AndProofs.scala

@@ -8,4 +8,4 @@ case class AndProofs[P <: Proposition](proofs: (Proof[P], Proof[P])) extends Pro
 
   override def isValid(proposition: P, message: Array[Byte]): Boolean =
     proofs._1.isValid(proposition, message) && proofs._2.isValid(proposition, message)
-}
+}

src/main/scala/scorex/transaction/proof/OrProofs.scala

@@ -8,4 +8,4 @@ case class OrProofs[P <: Proposition](proofs: (Proof[P], Proof[P])) extends Proo
 
   override def isValid(proposition: P, message: Array[Byte]): Boolean =
     proofs._1.isValid(proposition, message) || proofs._2.isValid(proposition, message)
-}
+}

src/main/scala/scorex/transaction/proof/Signature25519.scala

@@ -17,4 +17,4 @@ case class Signature25519(signature: Array[Byte]) extends Proof[PublicKey25519Pr
 
 object Signature25519 {
   lazy val SignatureSize = Curve25519.SignatureLength25519
-}
+}

src/main/scala/scorex/transaction/state/MinimalState.scala

@@ -25,4 +25,4 @@ trait MinimalState[P <: Proposition, TX <: Transaction[P, TX]] {
   def rollbackTo(height: Int): Try[Unit]
 
   def closedBox(boxId: Array[Byte]): Option[Box[P]]
-}
+}

src/main/scala/scorex/transaction/state/SecretHolder.scala

@@ -59,4 +59,4 @@ object SecretGenerator25519 extends SecretHolderGenerator[PrivateKey25519Holder]
   override def generateKeys(randomSeed: Array[Byte]): PrivateKey25519Holder = ???
 
   override def parse(bytes: Array[Byte]): Try[PrivateKey25519Holder] = ???
-}
+}

src/main/scala/scorex/transaction/state/authenticated/AuthenticatedBoxMinimalState.scala

@@ -23,4 +23,4 @@ trait AuthenticatedBoxMinimalState[P <: Proposition, TX <: Transaction[P, TX], H
   val hashFunction: HashFunction
 
   override def rollbackTo(height: Int): Try[Unit]
-}
+}

src/main/scala/scorex/transaction/wallet/Wallet.scala

@@ -127,4 +127,4 @@ TM <: TransactionModule[P, _, _]](settings: Settings,
   def getAndIncrementNonce(): Int = synchronized {
     noncePersistence.put(NonceFieldName, nonce() + 1) - 1
   }
-}
+}