Merge pull request #852 from wavesplatform/node-543-update-scrypto

NODE-543 Dirty move to Scrypto 2.0

it/src/test/scala/com/wavesplatform/it/WideStateGenerationSuite.scala

@@ -4,7 +4,6 @@ import java.util.concurrent.TimeoutException
 
 import com.typesafe.config.{Config, ConfigFactory}
 import com.wavesplatform.it.api.AsyncHttpApi._
-import com.wavesplatform.it.api._
 import com.wavesplatform.it.transactions.NodesFromDocker
 import com.wavesplatform.it.util._
 import org.scalatest._

it/src/test/scala/com/wavesplatform/it/matcher/MatcherMassOrdersTestSuite.scala

@@ -2,14 +2,15 @@ package com.wavesplatform.it.matcher
 
 import com.google.common.primitives.Longs
 import com.typesafe.config.{Config, ConfigFactory}
+import com.wavesplatform.crypto
 import com.wavesplatform.it._
 import com.wavesplatform.it.api.AsyncHttpApi._
 import com.wavesplatform.it.api.OrderbookHistory
 import com.wavesplatform.it.transactions.NodesFromDocker
 import com.wavesplatform.state2.ByteStr
 import org.scalatest.{BeforeAndAfterAll, CancelAfterFailure, FreeSpec, Matchers}
-import scorex.crypto.EllipticCurveImpl
 import scorex.transaction.assets.exchange.{AssetPair, Order, OrderType}
+
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.concurrent.{Await, Future}
@@ -42,7 +43,7 @@ class MatcherMassOrdersTestSuite extends FreeSpec with NodesFromDocker with Matc
       case head +: tail =>
         val r = result.flatMap { _ =>
           matcherNode.placeOrder(prepareOrder(node, matcherNode, assetPair, orderType,
-            Order.PriceConstant, amount, (70 + Random.nextInt(70)).seconds)).map(_ => ())
+            Order.PriceConstant, amount, (120 + Random.nextInt(70)).seconds)).map(_ => ())
         }
         execute(tail, r)
     }
@@ -54,7 +55,7 @@ class MatcherMassOrdersTestSuite extends FreeSpec with NodesFromDocker with Matc
   private def aliceOrderHistory(): Seq[OrderbookHistory] = {
     val ts = System.currentTimeMillis()
     val privateKey = aliceNode.privateKey
-    val signature = ByteStr(EllipticCurveImpl.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
+    val signature = ByteStr(crypto.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
     Await.result(matcherNode.getOrderbookByPublicKey(aliceNode.publicKeyStr, ts, signature), 1.minute)
   }
 
@@ -76,8 +77,8 @@ class MatcherMassOrdersTestSuite extends FreeSpec with NodesFromDocker with Matc
     waitForAssetBalance(aliceNode, aliceAsset, AssetQuantity)
     waitForAssetBalance(aliceNode, aliceSecondAsset, AssetQuantity)
     waitForAssetBalance(matcherNode, aliceAsset, 0)
-    Await.result(aliceNode.transfer(aliceNode.address, bobNode.address, AssetQuantity / 2, 100000, Some(aliceAsset)), 1.minute);
-    Await.result(aliceNode.transfer(aliceNode.address, bobNode.address, AssetQuantity / 2, 100000, Some(aliceSecondAsset)), 1.minute);
+    Await.result(aliceNode.transfer(aliceNode.address, bobNode.address, AssetQuantity / 2, 100000, Some(aliceAsset)), 1.minute)
+    Await.result(aliceNode.transfer(aliceNode.address, bobNode.address, AssetQuantity / 2, 100000, Some(aliceSecondAsset)), 1.minute)
     waitForAssetBalance(bobNode, aliceAsset, AssetQuantity / 2)
 
     // Alice places sell order
@@ -88,7 +89,7 @@ class MatcherMassOrdersTestSuite extends FreeSpec with NodesFromDocker with Matc
       prepareOrder(aliceNode, matcherNode, aliceSecondWavesPair, OrderType.SELL, Order.PriceConstant, 3, 10.minutes))
 
     val (aliceOrderToCancelId, _) = matcherPlaceOrder(matcherNode,
-      prepareOrder(aliceNode, matcherNode, aliceSecondWavesPair, OrderType.SELL, Order.PriceConstant, 3, 70.seconds))
+      prepareOrder(aliceNode, matcherNode, aliceSecondWavesPair, OrderType.SELL, Order.PriceConstant, 3, 2.minutes))
 
     val (aliceActiveOrderId, _) = matcherPlaceOrder(matcherNode,
       prepareOrder(aliceNode, matcherNode, aliceSecondWavesPair, OrderType.SELL, Order.PriceConstant + 1, 3, 10.minutes))

it/src/test/scala/com/wavesplatform/it/matcher/MatcherTestSuite.scala

@@ -3,6 +3,7 @@ package matcher
 
 import com.google.common.primitives.Longs
 import com.typesafe.config.{Config, ConfigFactory}
+import com.wavesplatform.crypto
 import com.wavesplatform.it.api.AsyncHttpApi._
 import com.wavesplatform.it.api._
 import com.wavesplatform.it.transactions.NodesFromDocker
@@ -11,7 +12,6 @@ import com.wavesplatform.state2.ByteStr
 import org.scalatest.{BeforeAndAfterAll, CancelAfterFailure, FreeSpec, Matchers}
 import play.api.libs.json.JsNumber
 import play.api.libs.json.Json.parse
-import scorex.crypto.EllipticCurveImpl
 import scorex.crypto.encode.Base58
 import scorex.transaction.assets.exchange.{AssetPair, Order, OrderType}
 
@@ -86,7 +86,7 @@ class MatcherTestSuite extends FreeSpec with Matchers with BeforeAndAfterAll wit
   "frozen amount should be listed via matcherBalance REST endpoint" in {
     val ts = System.currentTimeMillis()
     val privateKey = aliceNode.privateKey
-    val signature = Base58.encode(EllipticCurveImpl.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
+    val signature = Base58.encode(crypto.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
 
     val json = parse(Await.result(matcherNode.matcherGet(s"/matcher/matcherBalance/${aliceNode.publicKeyStr}", _
       .addHeader("Timestamp", ts)
@@ -98,7 +98,7 @@ class MatcherTestSuite extends FreeSpec with Matchers with BeforeAndAfterAll wit
   "and should be listed by trader's publiс key via REST" in {
     val ts = System.currentTimeMillis()
     val privateKey = aliceNode.privateKey
-    val signature = ByteStr(EllipticCurveImpl.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
+    val signature = ByteStr(crypto.sign(privateKey, aliceNode.publicKey.publicKey ++ Longs.toByteArray(ts)))
     val orderIds = Await.result(matcherNode.getOrderbookByPublicKey(aliceNode.publicKeyStr, ts, signature), 1.minute)
       .map(_.id)
 
@@ -288,7 +288,7 @@ class MatcherTestSuite extends FreeSpec with Matchers with BeforeAndAfterAll wit
     val privateKey = node.privateKey
     val publicKey = node.publicKey
     val request = CancelOrderRequest(publicKey, Base58.decode(orderId).get, Array.emptyByteArray)
-    val sig = EllipticCurveImpl.sign(privateKey, request.toSign)
+    val sig = crypto.sign(privateKey, request.toSign)
     val signedRequest = request.copy(signature = sig)
     val futureResult = matcherNode.cancelOrder(pair.amountAssetStr, pair.priceAssetStr, signedRequest)
 

it/src/test/scala/com/wavesplatform/it/matcher/OrderExclusionTestSuite.scala

@@ -2,22 +2,20 @@ package com.wavesplatform.it.matcher
 
 import com.google.common.primitives.Longs
 import com.typesafe.config.{Config, ConfigFactory}
+import com.wavesplatform.crypto
 import com.wavesplatform.it._
 import com.wavesplatform.it.api.AsyncHttpApi._
-import com.wavesplatform.it.api._
 import com.wavesplatform.it.transactions.NodesFromDocker
 import com.wavesplatform.state2.ByteStr
 import org.scalatest.{BeforeAndAfterAll, CancelAfterFailure, FreeSpec, Matchers}
-import scorex.crypto.EllipticCurveImpl
 import scorex.transaction.assets.exchange.{AssetPair, Order, OrderType}
 
 import scala.concurrent.Await
-import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.util.Random
 
 class OrderExclusionTestSuite extends FreeSpec with Matchers with BeforeAndAfterAll with CancelAfterFailure
-  with ReportingTestName with NodesFromDocker with MatcherUtils{
+  with ReportingTestName with NodesFromDocker with MatcherUtils {
 
   import OrderExclusionTestSuite._
 
@@ -61,7 +59,7 @@ class OrderExclusionTestSuite extends FreeSpec with Matchers with BeforeAndAfter
     matcherCheckOrderStatus(matcherNode, aliceAsset, id) shouldBe "Accepted"
 
     // Alice check that order is correct
-    val orders = matcherGetOrderBook(matcherNode, aliceAsset )
+    val orders = matcherGetOrderBook(matcherNode, aliceAsset)
     orders.asks.head.amount shouldBe 500
     orders.asks.head.price shouldBe 2 * Waves * Order.PriceConstant
   }
@@ -80,7 +78,7 @@ class OrderExclusionTestSuite extends FreeSpec with Matchers with BeforeAndAfter
     val privateKey = aliceNode.privateKey
 
     val pk = node.publicKey.publicKey
-    val signature = ByteStr(EllipticCurveImpl.sign(privateKey, pk ++ Longs.toByteArray(ts)))
+    val signature = ByteStr(crypto.sign(privateKey, pk ++ Longs.toByteArray(ts)))
 
     val orderhistory = Await.result(matcherNode.getOrderbookByPublicKey(node.publicKeyStr, ts, signature), 1.minute)
     orderhistory.seq(0).status

it/src/test/scala/com/wavesplatform/it/matcher/package.scala

@@ -1,7 +1,7 @@
 package com.wavesplatform.it
 
+import com.wavesplatform.crypto
 import com.wavesplatform.it.matcher.OrderExclusionTestSuite.MatcherFee
-import scorex.crypto.EllipticCurveImpl
 import scorex.transaction.assets.exchange.{AssetPair, Order, OrderType}
 
 import scala.concurrent.duration._
@@ -13,7 +13,7 @@ package object matcher {
     val timeToLiveTimestamp = creationTime + timeToLive.toMillis
     val matcherPublicKey = matcherNode.publicKey
     val unsigned = Order(node.publicKey, matcherPublicKey, pair, orderType, price, amount, creationTime, timeToLiveTimestamp, MatcherFee, Array())
-    val signature = EllipticCurveImpl.sign(node.privateKey, unsigned.toSign)
+    val signature = crypto.sign(node.privateKey, unsigned.toSign)
     unsigned.copy(signature = signature)
   }
 }

it/src/test/scala/com/wavesplatform/it/transactions/MassTransferTransactionSuite.scala

@@ -15,7 +15,6 @@ import scorex.transaction.assets.TransferTransaction.MaxAttachmentSize
 
 class MassTransferTransactionSuite extends BaseTransactionSuite with CancelAfterFailure {
 
-  private val Timeout = 2.minutes
   private val assetQuantity = 100.waves
   private val transferAmount = 5.waves
   private val leasingAmount = 5.waves

lang/shared/src/main/scala/com/wavesplatform/lang/Evaluator.scala

@@ -2,7 +2,7 @@ package com.wavesplatform.lang
 
 import com.wavesplatform.lang.Terms._
 import scodec.bits.ByteVector
-import scorex.crypto.signatures.Curve25519
+import scorex.crypto.signatures.{Curve25519, PublicKey, Signature}
 
 import scala.util.{Failure, Success, Try}
 
@@ -141,7 +141,7 @@ object Evaluator {
           s <- r[ByteVector](ctx, sig)
           m <- r[ByteVector](ctx, msg)
           p <- r[ByteVector](ctx, pk)
-        } yield s.flatMap(ss => m.flatMap(mm => p.map(pp => Curve25519.verify(ss.toArray, mm.toArray, pp.toArray))))
+        } yield s.flatMap(ss => m.flatMap(mm => p.map(pp => Curve25519.verify(Signature(ss.toArray), mm.toArray, PublicKey(pp.toArray)))))
       }
 
       case Typed.GETTER(expr, field, _) => tailcall {

project/Dependencies.scala

@@ -1,5 +1,5 @@
-import sbt._
 import org.portablescala.sbtplatformdeps.PlatformDepsPlugin.autoImport.toPlatformDepsGroupID
+import sbt._
 
 object Dependencies {
 
@@ -79,7 +79,7 @@ object Dependencies {
   lazy val scodec = Def.setting(Seq("org.scodec" %%% "scodec-core" % "1.10.3"))
   lazy val fastparse = Def.setting(Seq("com.lihaoyi" %%% "fastparse" % "1.0.0"))
   lazy val ficus = Seq("com.iheart" %% "ficus" % "1.4.2")
-  lazy val scorex = Seq(("org.scorexfoundation" %% "scrypto" % "1.2.2").exclude("org.slf4j", "slf4j-api"))
+  lazy val scorex = Seq(("org.scorexfoundation" %% "scrypto" % "2.0.4").exclude("org.slf4j", "slf4j-api"))
   lazy val commons_net = Seq("commons-net" % "commons-net" % "3.+")
   lazy val scalatest = Seq("org.scalatest" %% "scalatest" % "3.0.3")
   lazy val scalactic = Seq("org.scalactic" %% "scalactic" % "3.0.3")

src/main/scala/com/wavesplatform/crypto/package.scala

@@ -0,0 +1,30 @@
+package com.wavesplatform
+
+import scorex.account.PrivateKeyAccount
+import scorex.crypto.hash.{Blake2b256, Keccak256}
+import scorex.crypto.signatures._
+
+package object crypto {
+  val SignatureLength: Int = Curve25519.SignatureLength
+
+  val DigestSize: Int = 32
+
+  def fastHash(m: Array[Byte]): Array[Byte] = Blake2b256.hash(m)
+
+  def fastHash(s: String): Array[Byte] = fastHash(s.getBytes())
+
+  def secureHash(m: Array[Byte]): Array[Byte] = Keccak256.hash(Blake2b256.hash(m))
+
+  def secureHash(s: String): Array[Byte] = secureHash(s.getBytes())
+
+  def sign(account: PrivateKeyAccount, message: Array[Byte]): Array[Byte] =
+    Curve25519.sign(PrivateKey(account.privateKey), message)
+
+  def sign(privateKeyBytes: Array[Byte], message: Array[Byte]): Array[Byte] =
+    Curve25519.sign(PrivateKey(privateKeyBytes), message)
+
+  def verify(signature: Array[Byte], message: Array[Byte], publicKey: Array[Byte]): Boolean =
+    Curve25519.verify(Signature(signature), message, PublicKey(publicKey))
+
+  def createKeyPair(seed: Array[Byte]): (Array[Byte], Array[Byte]) = Curve25519.createKeyPair(seed)
+}

src/main/scala/com/wavesplatform/history/CheckpointServiceImpl.scala

@@ -1,10 +1,10 @@
 package com.wavesplatform.history
 
+import com.wavesplatform.crypto
 import com.wavesplatform.db.{CheckpointCodec, PropertiesStorage, SubStorage}
 import com.wavesplatform.network.Checkpoint
 import com.wavesplatform.settings.CheckpointsSettings
 import org.iq80.leveldb.DB
-import scorex.crypto.EllipticCurveImpl
 import scorex.transaction.ValidationError.GenericError
 import scorex.transaction.{CheckpointService, ValidationError}
 
@@ -17,7 +17,7 @@ class CheckpointServiceImpl(db: DB, settings: CheckpointsSettings)
 
   override def set(cp: Checkpoint): Either[ValidationError, Unit] = for {
     _ <- Either.cond(!get.forall(_.signature sameElements cp.signature), (), GenericError("Checkpoint already applied"))
-    _ <- Either.cond(EllipticCurveImpl.verify(cp.signature, cp.toSign, settings.publicKey.arr),
+    _ <- Either.cond(crypto.verify(cp.signature, cp.toSign, settings.publicKey.arr),
       putProperty(CheckpointProperty, CheckpointCodec.encode(cp), None),
       GenericError("Invalid checkpoint signature"))
   } yield ()

src/main/scala/com/wavesplatform/matcher/api/CancelOrderRequest.scala

@@ -1,11 +1,11 @@
 package com.wavesplatform.matcher.api
 
+import com.wavesplatform.crypto
 import io.swagger.annotations.ApiModelProperty
 import play.api.libs.functional.syntax._
 import play.api.libs.json.Reads._
 import play.api.libs.json.{JsObject, JsPath, Json, Reads}
 import scorex.account.PublicKeyAccount
-import scorex.crypto.EllipticCurveImpl
 import scorex.crypto.encode.Base58
 import scorex.transaction.assets.exchange.OrderJson._
 
@@ -16,7 +16,7 @@ case class CancelOrderRequest(@ApiModelProperty(dataType = "java.lang.String") s
   lazy val toSign: Array[Byte] = senderPublicKey.publicKey ++ orderId
 
   @ApiModelProperty(hidden = true)
-  def isSignatureValid = EllipticCurveImpl.verify(signature, toSign, senderPublicKey.publicKey)
+  def isSignatureValid: Boolean = crypto.verify(signature, toSign, senderPublicKey.publicKey)
 
   def json: JsObject = Json.obj(
     "sender" -> Base58.encode(senderPublicKey.publicKey),

src/main/scala/com/wavesplatform/matcher/api/MatcherApiRoute.scala

@@ -8,6 +8,7 @@ import akka.http.scaladsl.server.{Directive1, Route}
 import akka.pattern.ask
 import akka.util.Timeout
 import com.google.common.primitives.Longs
+import com.wavesplatform.crypto
 import com.wavesplatform.matcher.MatcherSettings
 import com.wavesplatform.matcher.market.MatcherActor.{GetMarkets, GetMarketsResponse}
 import com.wavesplatform.matcher.market.MatcherTransactionWriter.GetTransactionsByOrder
@@ -18,7 +19,6 @@ import io.swagger.annotations._
 import play.api.libs.json._
 import scorex.account.PublicKeyAccount
 import scorex.api.http._
-import scorex.crypto.EllipticCurveImpl
 import scorex.crypto.encode.Base58
 import scorex.transaction.assets.exchange.OrderJson._
 import scorex.transaction.assets.exchange.{AssetPair, Order}
@@ -155,7 +155,7 @@ case class MatcherApiRoute(wallet: Wallet,
       json[CancelOrderRequest] { req =>
         if (req.isSignatureValid) {
           (orderHistory ? DeleteOrderFromHistory(pair, req.senderPublicKey.address,
-              Base58.encode(req.orderId), NTP.correctedTime()))
+            Base58.encode(req.orderId), NTP.correctedTime()))
             .mapTo[MatcherResponse]
             .map(r => r.code -> r.json)
         } else {
@@ -171,7 +171,7 @@ case class MatcherApiRoute(wallet: Wallet,
       val sig = Base58.decode(signature).get
       val ts = timestamp.toLong
       require(math.abs(ts - NTP.correctedTime()).millis < matcherSettings.maxTimestampDiff, "Incorrect timestamp")
-      require(EllipticCurveImpl.verify(sig, pk ++ Longs.toByteArray(ts), pk), "Incorrect signature")
+      require(crypto.verify(sig, pk ++ Longs.toByteArray(ts), pk), "Incorrect signature")
       PublicKeyAccount(pk).address
     }
   }
@@ -235,7 +235,9 @@ case class MatcherApiRoute(wallet: Wallet,
     implicit val timeout = Timeout(10.seconds)
     val resp: Future[MatcherResponse] = (orderHistory ? ForceCancelOrderFromHistory(orderId)).flatMap {
       case Some(order: Order) => (matcher ? ForceCancelOrder(order.assetPair, orderId)).mapTo[MatcherResponse]
-      case None => Future { OrderCancelRejected("Order not found") }
+      case None => Future {
+        OrderCancelRejected("Order not found")
+      }
     }
 
     complete(resp.map(r => r.code -> r.json))
@@ -247,7 +249,7 @@ case class MatcherApiRoute(wallet: Wallet,
     httpMethod = "GET")
   @ApiImplicitParams(Array(
     new ApiImplicitParam(name = "address", value = "Address", dataType = "string", paramType = "path")
-   ))
+  ))
   def getAllOrderHistory: Route = (path("orders" / Segment) & get & withAuth) { addr =>
     implicit val timeout = Timeout(10.seconds)
     complete((orderHistory ? GetAllOrderHistory(addr, NTP.correctedTime()))

src/main/scala/com/wavesplatform/network/BasicMessagesRepo.scala

@@ -8,7 +8,6 @@ import com.wavesplatform.mining.Miner.MaxTransactionsPerMicroblock
 import com.wavesplatform.state2.ByteStr
 import scorex.account.PublicKeyAccount
 import scorex.block.{Block, MicroBlock}
-import scorex.crypto.signatures.SigningFunctions.Signature
 import scorex.network.message.Message._
 import scorex.network.message._
 import scorex.transaction.TransactionParser._
@@ -76,9 +75,9 @@ trait SignaturesSeqSpec[A <: AnyRef] extends MessageSpec[A] {
 
   private val DataLength = 4
 
-  def wrap(signatures: Seq[Signature]): A
+  def wrap(signatures: Seq[Array[Byte]]): A
 
-  def unwrap(v: A): Seq[Signature]
+  def unwrap(v: A): Seq[Array[Byte]]
 
   override val maxLength: Int = DataLength + (200 * SignatureLength)
 
@@ -105,15 +104,15 @@ trait SignaturesSeqSpec[A <: AnyRef] extends MessageSpec[A] {
 }
 
 object GetSignaturesSpec extends SignaturesSeqSpec[GetSignatures] {
-  override def wrap(signatures: Seq[Signature]): GetSignatures = GetSignatures(signatures.map(ByteStr(_)))
+  override def wrap(signatures: Seq[Array[Byte]]): GetSignatures = GetSignatures(signatures.map(ByteStr(_)))
 
   override def unwrap(v: GetSignatures): Seq[Array[MessageCode]] = v.signatures.map(_.arr)
 
   override val messageCode: MessageCode = 20: Byte
 }
 
 object SignaturesSpec extends SignaturesSeqSpec[Signatures] {
-  override def wrap(signatures: Seq[Signature]): Signatures = Signatures(signatures.map(ByteStr(_)))
+  override def wrap(signatures: Seq[Array[Byte]]): Signatures = Signatures(signatures.map(ByteStr(_)))
 
   override def unwrap(v: Signatures): Seq[Array[MessageCode]] = v.signatures.map(_.arr)