Merge branch 'master' of github.com:wavesplatform/Waves into version-…

…0.16.x

dexgenerator/src/main/resources/application.conf

@@ -6,7 +6,7 @@ generator {
 
   send-to = [
     {
-      address = "http://18.195.176.98:6869"
+      address = "http://devnet-aws-fr-4.wavesnodes.com:6869"
       port = 6869
     }
   ]

dexgenerator/src/main/resources/devnetM.conf

@@ -0,0 +1,51 @@
+generator {
+  chain-id = M
+  rich-accounts = [
+    ""
+  ]
+
+  send-to = [
+    {
+      address = "http://devnet-aws-fr-4.wavesnodes.com:6869"
+      port = 6869
+    }
+  ]
+
+  matcher-config {
+    endpoint = "http://devnet-aws-fr-4.wavesnodes.com:6886"
+    matcher-key = "BvfTcXu4d9Nsge8Woz42QW94Rf7MKcjtMYQz4L6MAPFX"
+  }
+
+  worker {
+    iterations = 1000
+    delay = 5s
+
+    auto-reconnect = false
+    reconnect-delay = 3s
+  }
+
+  accounts-distribution {
+    valid: 50
+    invalid: 1
+    fake: 1
+  }
+
+  mode = "DEX"
+
+  dex {
+    orders = 4
+    assets = 40
+    probabilities {
+      active-buy: 0.01
+      active-sell: 0.01
+      sell: 0.48
+      buy: 0.48
+      //      invalid-amount: 0
+      cancel: 0.02
+      //      fake-sell: 0
+    }
+  }
+
+}
+
+include "local.conf"

dexgenerator/src/main/scala/com/wavesplatform/dexgen/DexGenApp.scala

@@ -3,9 +3,10 @@ package com.wavesplatform.dexgen
 import java.util.concurrent.Executors
 
 import cats.implicits.showInterpolator
+import cats.instances.byte
 import com.typesafe.config.ConfigFactory
 import com.wavesplatform.account.{AddressOrAlias, AddressScheme, PrivateKeyAccount}
-import com.wavesplatform.api.http.assets.{SignedIssueV1Request, SignedMassTransferRequest}
+import com.wavesplatform.api.http.assets.{SignedIssueV2Request, SignedMassTransferRequest}
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.dexgen.cli.ScoptImplicits
 import com.wavesplatform.dexgen.config.FicusImplicits
@@ -14,10 +15,11 @@ import com.wavesplatform.it.api.Transaction
 import com.wavesplatform.it.util.GlobalTimer
 import com.wavesplatform.network.client.NetworkSender
 import com.wavesplatform.transaction.AssetId
-import com.wavesplatform.transaction.assets.IssueTransactionV1
+import com.wavesplatform.transaction.assets.IssueTransactionV2
 import com.wavesplatform.transaction.transfer.MassTransferTransaction
 import com.wavesplatform.transaction.transfer.MassTransferTransaction.ParsedTransfer
 import com.wavesplatform.utils.LoggerFacade
+import com.wavesplatform.common.utils.EitherExt2
 import net.ceedubs.ficus.Ficus._
 import net.ceedubs.ficus.readers.ArbitraryTypeReader._
 import net.ceedubs.ficus.readers.{EnumerationReader, NameMapper}
@@ -67,35 +69,39 @@ object DexGenApp extends App with ScoptImplicits with FicusImplicits with Enumer
   }
 
   implicit val signedMassTransferRequestWrites: Writes[SignedMassTransferRequest] =
-    Json.writes[SignedMassTransferRequest].transform((jsobj: JsObject) => jsobj + ("type" -> JsNumber(MassTransferTransaction.typeId.toInt)))
+    Json
+      .writes[SignedMassTransferRequest]
+      .transform((jsobj: JsObject) => jsobj + ("version" -> JsNumber(1)) + ("type" -> JsNumber(MassTransferTransaction.typeId.toInt)))
 
   val defaultConfig = ConfigFactory.load().as[GeneratorSettings]("generator")
+  AddressScheme.current = new AddressScheme { override val chainId: Byte = defaultConfig.chainId.head.toByte }
 
   def issueAssets(endpoint: String, richAddressSeed: String, n: Int)(implicit tag: String): Seq[AssetId] = {
     val node = api.to(endpoint)
 
-    val assetsTx: Seq[IssueTransactionV1] = (1 to n).map { i =>
-      IssueTransactionV1
+    val assetsTx: Seq[IssueTransactionV2] = (1 to n).map { i =>
+      IssueTransactionV2
         .selfSigned(
-          PrivateKeyAccount.fromSeed(richAddressSeed).right.get,
+          chainId = AddressScheme.current.chainId,
           name = s"asset$i".getBytes(),
           description = s"asset description - $i".getBytes(),
-          quantity = 99999999999999999L,
+          quantity = 999999999999999L,
           decimals = 2,
           reissuable = false,
           fee = 100000000,
-          timestamp = System.currentTimeMillis()
+          timestamp = System.currentTimeMillis(),
+          sender = PrivateKeyAccount.fromSeed(richAddressSeed).explicitGet(),
+          script = None
         )
-        .right
-        .get
+        .explicitGet()
     }
 
     val tradingAssets: Seq[AssetId]                    = assetsTx.map(tx => tx.id())
-    val signedIssueRequests: Seq[SignedIssueV1Request] = assetsTx.map(tx => api.createSignedIssueRequest(tx))
+    val signedIssueRequests: Seq[SignedIssueV2Request] = assetsTx.map(tx => api.createSignedIssueRequest(tx))
 
     val issued: Seq[Future[Transaction]] = signedIssueRequests
       .map { txReq =>
-        node.signedIssue(txReq).flatMap { tx =>
+        node.broadcastRequest(txReq).flatMap { tx =>
           node.waitForTransaction(tx.id)
         }
       }

dexgenerator/src/main/scala/com/wavesplatform/dexgen/Worker.scala

@@ -61,13 +61,14 @@ class Worker(workerSettings: Settings,
     to(matcherSettings.endpoint).orderBook(pair)
     val order = Order.buy(buyer, matcherPublicKey, pair, amount, price, now, now + 29.day.toMillis, fee)
     log.info(s"[$tag] Buy ${order.id()}: $order")
-    val response = to(matcherSettings.endpoint).placeOrder(order).andThen {
-      case Failure(e) => log.error(s"[$tag] Can't place buy order ${order.id()}: $e")
-    }
-    log.info(order.id().base58)
-    to(matcherSettings.endpoint).orderHistory(buyer)
-    to(matcherSettings.endpoint).orderBook(pair)
-    to(matcherSettings.endpoint).orderStatus(order.id().base58, pair)
+    val response = for {
+      placeOrder <- to(matcherSettings.endpoint).placeOrder(order).andThen {
+        case Failure(e) => log.error(s"[$tag] Can't place buy order ${order.id()}: $e")
+      }
+      orderHistory <- to(matcherSettings.endpoint).orderHistory(buyer)
+      orderbook    <- to(matcherSettings.endpoint).orderBook(pair)
+      orderStatus  <- to(matcherSettings.endpoint).orderStatus(order.id().base58, pair)
+    } yield placeOrder
     (order, response)
   }
 
@@ -76,12 +77,14 @@ class Worker(workerSettings: Settings,
     to(matcherSettings.endpoint).orderBook(pair)
     val order = Order.sell(seller, matcherPublicKey, pair, amount, price, now, now + 29.day.toMillis, fee)
     log.info(s"[$tag] Sell ${order.id()}: $order")
-    val response = to(matcherSettings.endpoint).placeOrder(order).andThen {
-      case Failure(e) => log.error(s"[$tag] Can't place sell order ${order.id()}: $e")
-    }
-    to(matcherSettings.endpoint).orderHistory(seller)
-    to(matcherSettings.endpoint).orderBook(pair)
-    to(matcherSettings.endpoint).orderStatus(order.id().base58, pair)
+    val response = for {
+      placeOrder <- to(matcherSettings.endpoint).placeOrder(order).andThen {
+        case Failure(e) => log.error(s"[$tag] Can't place sell order ${order.id()}: $e")
+      }
+      orderHistory <- to(matcherSettings.endpoint).orderHistory(seller)
+      orderbook    <- to(matcherSettings.endpoint).orderBook(pair)
+      orderStatus  <- to(matcherSettings.endpoint).orderStatus(order.id().base58, pair)
+    } yield placeOrder
     (order, response)
   }
 

dexgenerator/src/main/scala/com/wavesplatform/dexgen/utils/ApiRequests.scala

@@ -5,15 +5,25 @@ import java.util.concurrent.TimeoutException
 
 import com.google.common.primitives.Longs
 import com.wavesplatform.account.PrivateKeyAccount
-import com.wavesplatform.api.http.assets.{SignedIssueV1Request, SignedMassTransferRequest, SignedTransferV1Request}
+import com.wavesplatform.api.http.assets.{SignedIssueV2Request, SignedMassTransferRequest, SignedTransferV1Request}
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.crypto
-import com.wavesplatform.it.api.{AssetBalance, Balance, MatcherResponse, MatcherStatusResponse, OrderBookResponse, OrderbookHistory, ResponseFutureExt, Transaction, UnexpectedStatusCodeException}
+import com.wavesplatform.it.api.{
+  AssetBalance,
+  Balance,
+  MatcherResponse,
+  MatcherStatusResponse,
+  OrderBookResponse,
+  OrderbookHistory,
+  ResponseFutureExt,
+  Transaction,
+  UnexpectedStatusCodeException
+}
 import com.wavesplatform.it.util.GlobalTimer.{instance => timer}
 import com.wavesplatform.it.util._
 import com.wavesplatform.matcher.api.CancelOrderRequest
 import com.wavesplatform.transaction.AssetId
-import com.wavesplatform.transaction.assets.IssueTransactionV1
+import com.wavesplatform.transaction.assets.IssueTransactionV2
 import com.wavesplatform.transaction.assets.exchange.{AssetPair, Order}
 import com.wavesplatform.transaction.transfer.MassTransferTransaction.{ParsedTransfer, Transfer}
 import com.wavesplatform.transaction.transfer.{MassTransferTransaction, TransferTransactionV1}
@@ -64,9 +74,9 @@ class ApiRequests(client: AsyncHttpClient) extends ScorexLogging {
     executeRequest
   }
 
-  def createSignedIssueRequest(tx: IssueTransactionV1): SignedIssueV1Request = {
+  def createSignedIssueRequest(tx: IssueTransactionV2): SignedIssueV2Request = {
     import tx._
-    SignedIssueV1Request(
+    SignedIssueV2Request(
       Base58.encode(tx.sender.publicKey),
       new String(name),
       new String(description),
@@ -75,7 +85,8 @@ class ApiRequests(client: AsyncHttpClient) extends ScorexLogging {
       reissuable,
       fee,
       timestamp,
-      signature.base58
+      proofs.proofs.map(_.base58),
+      script.map(_.toString)
     )
   }
 
@@ -146,9 +157,6 @@ class ApiRequests(client: AsyncHttpClient) extends ScorexLogging {
       case _    => to(endpoint).assetBalance(address, asset.map(_.base58).get).map(_.balance)
     }
 
-    def signedIssue(issue: SignedIssueV1Request)(implicit tag: String): Future[Transaction] =
-      postJson("/assets/broadcast/issue", issue).as[Transaction]
-
     def orderbookByPublicKey(publicKey: String, ts: Long, signature: ByteStr, f: RequestBuilder => RequestBuilder = identity)(
         implicit tag: String): Future[Seq[OrderbookHistory]] =
       retrying {

it/src/main/resources/template.conf

@@ -38,6 +38,7 @@ waves {
           7 = 0
           9 = 0
           10 = 0
+          11 = 0
         }
         double-features-periods-after-height = 100000000
         max-transaction-time-back-offset = 120m

it/src/main/scala/com/wavesplatform/it/api/SyncHttpApi.scala

@@ -6,7 +6,7 @@ import java.util.concurrent.TimeoutException
 import akka.http.scaladsl.model.StatusCodes.{BadRequest, NotFound}
 import com.wavesplatform.api.http.AddressApiRoute
 import com.wavesplatform.api.http.assets.{SignedIssueV1Request, SignedIssueV2Request}
-import com.wavesplatform.features.api.ActivationStatus
+import com.wavesplatform.features.api.{ActivationStatus, FeatureActivationStatus}
 import com.wavesplatform.http.DebugMessage
 import com.wavesplatform.it.Node
 import com.wavesplatform.state.{AssetDistribution, AssetDistributionPage, DataEntry, Portfolio}
@@ -269,6 +269,9 @@ object SyncHttpApi extends Assertions {
     def waitForHeight(expectedHeight: Int, requestAwaitTime: FiniteDuration = RequestAwaitTime): Int =
       sync(async(n).waitForHeight(expectedHeight), requestAwaitTime)
 
+    def blacklist(address: InetSocketAddress): Unit =
+      sync(async(n).blacklist(address))
+
     def debugMinerInfo(): Seq[State] =
       sync(async(n).debugMinerInfo())
 
@@ -318,6 +321,9 @@ object SyncHttpApi extends Assertions {
     }
 
     def waitForUtxIncreased(fromSize: Int): Int = sync(async(n).waitForUtxIncreased(fromSize))
+
+    def featureActivationStatus(featureNum: Short): FeatureActivationStatus =
+      activationStatus.features.find(_.id == featureNum).get
   }
 
   implicit class NodesExtSync(nodes: Seq[Node]) {

it/src/test/scala/com/wavesplatform/it/async/matcher/CorrectStatusAfterPlaceTestSuite.scala

@@ -2,14 +2,14 @@ package com.wavesplatform.it.async.matcher
 
 import com.typesafe.config.{Config, ConfigFactory}
 import com.wavesplatform.account.PrivateKeyAccount
+import com.wavesplatform.common.utils.EitherExt2
 import com.wavesplatform.it._
 import com.wavesplatform.it.api.AsyncHttpApi.NodesAsyncHttpApi
 import com.wavesplatform.it.api.AsyncMatcherHttpApi._
 import com.wavesplatform.it.async.matcher.CorrectStatusAfterPlaceTestSuite._
 import com.wavesplatform.it.sync.createSignedIssueRequest
 import com.wavesplatform.it.transactions.NodesFromDocker
 import com.wavesplatform.it.util._
-import com.wavesplatform.common.utils.EitherExt2
 import com.wavesplatform.transaction.assets.IssueTransactionV1
 import com.wavesplatform.transaction.assets.exchange.{AssetPair, Order, OrderType}
 import com.wavesplatform.transaction.transfer.MassTransferTransaction