perma module

scorex-basics/build.sbt

@@ -5,6 +5,7 @@ libraryDependencies ++=
     Dependencies.akka ++
     Dependencies.spray ++
     Dependencies.testKit ++
+    Dependencies.db ++
     Dependencies.logging ++ Seq(
       "org.whispersystems" % "curve25519-java" % "+",
       "commons-net" % "commons-net" % "3.+"

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

@@ -12,22 +12,22 @@ import scorex.utils.ScorexLogging
 import scala.util.{Failure, Try}
 
 /**
- * A block is a an atomic piece of data network participates are agreed on.
- *
- * A block has:
- * - transactions data: a sequence of transactions, where a transaction is an atomic state update.
- * Some metadata is possible as well(transactions Merkle tree root, state Merkle tree root etc).
- *
- * - consensus data to check whether block was generated by a right party in a right way. E.g.
- * "baseTarget" & "generatorSignature" fields in the Nxt block structure, nonce & difficulty in the
- * Bitcoin block structure.
- *
- * - a signature(s) of a block generator(s)
- *
- * - additional data: block structure version no, timestamp etc
- */
-
-trait Block {
+  * A block is a an atomic piece of data network participates are agreed on.
+  *
+  * A block has:
+  * - transactions data: a sequence of transactions, where a transaction is an atomic state update.
+  * Some metadata is possible as well(transactions Merkle tree root, state Merkle tree root etc).
+  *
+  * - consensus data to check whether block was generated by a right party in a right way. E.g.
+  * "baseTarget" & "generatorSignature" fields in the Nxt block structure, nonce & difficulty in the
+  * Bitcoin block structure.
+  *
+  * - a signature(s) of a block generator(s)
+  *
+  * - additional data: block structure version no, timestamp etc
+  */
+
+trait Block extends ScorexLogging {
   type ConsensusDataType
   type TransactionDataType
 
@@ -79,13 +79,21 @@ trait Block {
 
   lazy val bytesWithoutSignature = bytes.dropRight(EllipticCurveImpl.SignatureLength)
 
-  def isValid =
-    consensusModule.isValid(this) &&
+  def isValid: Boolean = {
+    val v = consensusModule.isValid(this) &&
       transactionModule.isValid(this) &&
       transactionModule.history.contains(referenceField.value) &&
       EllipticCurveImpl.verify(signerDataField.value.signature,
         bytesWithoutSignature,
         signerDataField.value.generator.publicKey)
+    if (!v) log.debug(
+      s"Block checks: ${consensusModule.isValid(this)} && ${transactionModule.isValid(this)} && " +
+        s"${transactionModule.history.contains(referenceField.value)} && " +
+        EllipticCurveImpl.verify(signerDataField.value.signature, bytesWithoutSignature,
+          signerDataField.value.generator.publicKey)
+    )
+    v
+  }
 }
 
 

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

@@ -8,22 +8,22 @@ import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 
 
-trait ConsensusModule[ConsensusBlockData] extends BlockProcessingModule[ConsensusBlockData]{
+trait ConsensusModule[ConsensusBlockData] extends BlockProcessingModule[ConsensusBlockData] {
 
   def isValid[TT](block: Block)(implicit transactionModule: TransactionModule[TT]): Boolean
 
   /**
-  * Fees could go to a single miner(forger) usually, but can go to many parties, e.g. see
-  * Meni Rosenfeld's Proof-of-Activity proposal http://eprint.iacr.org/2014/452.pdf
-   */
+    * Fees could go to a single miner(forger) usually, but can go to many parties, e.g. see
+    * Meni Rosenfeld's Proof-of-Activity proposal http://eprint.iacr.org/2014/452.pdf
+    */
   def feesDistribution(block: Block): Map[Account, Long]
 
   /**
-   * Get block producers(miners/forgers). Usually one miner produces a block, but in some proposals not
-   * (see e.g. Meni Rosenfeld's Proof-of-Activity paper http://eprint.iacr.org/2014/452.pdf)
-   * @param block
-   * @return
-   */
+    * Get block producers(miners/forgers). Usually one miner produces a block, but in some proposals not
+    * (see e.g. Meni Rosenfeld's Proof-of-Activity paper http://eprint.iacr.org/2014/452.pdf)
+    * @param block
+    * @return
+    */
   def generators(block: Block): Seq[Account]
 
   def blockScore(block: Block)(implicit transactionModule: TransactionModule[_]): BigInt

scorex-basics/src/main/scala/scorex/crypto/CryptographicHash.scala

@@ -21,10 +21,12 @@ import java.security.MessageDigest
 trait CryptographicHash {
   import CryptographicHash._
 
-  val ValueSize: Int //in bytes
+  val DigestSize: Int //in bytes
 
   def hash(input: Message): Digest
 
+  def hash(input: String): Digest = hash(input.getBytes)
+
   def doubleHash(input: Message): Digest = hash(hash(input))
 }
 
@@ -37,7 +39,7 @@ object CryptographicHash {
  * Hashing functions implementation with sha256 impl from Java SDK
  */
 object Sha256 extends CryptographicHash {
-  override val ValueSize = 32
+  override val DigestSize = 32
 
   override def hash(input: Array[Byte]) = MessageDigest.getInstance("SHA-256").digest(input)
 }

scorex-basics/src/main/scala/scorex/crypto/ads/merkle/AuthDataBlock.scala

@@ -0,0 +1,73 @@
+package scorex.crypto.ads.merkle
+
+import play.api.libs.json._
+import scorex.crypto.CryptographicHash._
+import scorex.crypto.ads.merkle.TreeStorage.Position
+import scorex.crypto.{Base58, CryptographicHash, Sha256}
+
+import scala.annotation.tailrec
+
+/**
+  * @param data - data block
+  * @param merklePath - merkle path, complementary to data block
+  */
+case class AuthDataBlock[Block](data: Block, merklePath: Seq[Digest]) {
+
+  def check[HashImpl <: CryptographicHash](index: Position, rootHash: Digest)
+                                      (hashFunction: HashImpl = Sha256): Boolean = {
+
+    @tailrec
+    def calculateHash(idx: Position, nodeHash: Digest, path: Seq[Digest]): Digest = {
+      val hash = if (idx % 2 == 0)
+        hashFunction.hash(nodeHash ++ path.head)
+      else
+        hashFunction.hash(path.head ++ nodeHash)
+
+      if (path.size == 1)
+        hash
+      else
+        calculateHash(idx / 2, hash, path.tail)
+    }
+
+    if (merklePath.nonEmpty)
+      calculateHash(index, hashFunction.hash(data.asInstanceOf[Message]), merklePath) sameElements rootHash
+    else
+      false
+  }
+}
+
+object AuthDataBlock {
+
+  implicit def authDataBlockReads[T](implicit fmt: Reads[T]): Reads[AuthDataBlock[T]] = new Reads[AuthDataBlock[T]] {
+    def reads(json: JsValue): JsResult[AuthDataBlock[T]] = JsSuccess(AuthDataBlock[T](
+      (json \ "data").get match {
+        case JsString(ts) =>
+          Base58.decode(ts).get.asInstanceOf[T]
+        case _ =>
+          throw new RuntimeException("Data MUST be a string")
+      },
+      (json \ "merklePath").get match {
+        case JsArray(ts) => ts.map { t =>
+          t match {
+            case JsString(digest) =>
+              Base58.decode(digest)
+            case m =>
+              throw new RuntimeException("MerklePath MUST be array of strings" + m + " given")
+          }
+        }.map(_.get)
+        case m =>
+          throw new RuntimeException("MerklePath MUST be a list " + m + " given")
+      }
+    ))
+  }
+
+  implicit def authDataBlockWrites[T](implicit fmt: Writes[T]): Writes[AuthDataBlock[T]] = new Writes[AuthDataBlock[T]] {
+    def writes(ts: AuthDataBlock[T]) = JsObject(Seq(
+      "data" -> JsString(Base58.encode(ts.data.asInstanceOf[Array[Byte]])),
+      "merklePath" -> JsArray(
+        ts.merklePath.map(digest => JsString(Base58.encode(digest)))
+      )
+    ))
+  }
+}
+