wip

Author: phearnot

benchmark/src/test/scala/com/wavesplatform/common/BLSBenchmark.scala

@@ -0,0 +1,43 @@
+package com.wavesplatform.common
+
+import com.wavesplatform.crypto.bls.BlsUtils
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+
+import java.util.concurrent.TimeUnit
+import scala.compiletime.uninitialized
+
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@BenchmarkMode(Array(Mode.AverageTime))
+@Threads(1)
+@Fork(1)
+@Warmup(iterations = 30, time = 1)
+@Measurement(iterations = 30, time = 1)
+class BLSBenchmark {
+  @Benchmark
+  def verifyAgg(st: EndorsementSt, bh: Blackhole) = bh.consume(BlsUtils.verifyAgg(st.aggregatedSignature, st.message, st.publicKeys))
+}
+
+@State(Scope.Benchmark)
+class EndorsementSt {
+  @Param(Array("32", "64", "128"))
+  var generatorCount                   = 0
+  var publicKeys                       = Seq.empty[Array[Byte]]
+  var aggregatedSignature: Array[Byte] = uninitialized
+  val message: Array[Byte] = {
+    val bs = new Array[Byte](64)
+    bs
+  }
+
+  @Setup
+  def setup(): Unit = {
+    val privateKeys = Seq.tabulate(generatorCount) { i =>
+      val bs = new Array[Byte](32)
+      bs(0) = i.toByte
+      BlsUtils.mkBlsSecretKey(bs)
+    }
+
+    publicKeys = privateKeys.map(BlsUtils.mkBlsPublicKey)
+    aggregatedSignature = privateKeys.map(sk => BlsUtils.signBasic(sk, message)).reduceLeft(BlsUtils.aggSign)
+  }
+}

docker/Dockerfile

@@ -6,6 +6,8 @@ ARG CORRETTO_VERSION=2.5.0
 ARG ROCKSDB_VERSION=10.2.1
 
 ENV WAVES_LOG_LEVEL=INFO
+ENV WAVES_LOG_JAVA_OPTS=true
+
 ENV WAVES_HEAP_SIZE=2g
 ENV WAVES_NETWORK=mainnet
 

docker/entrypoint.sh

@@ -13,7 +13,9 @@ JAVA_OPTS="-XX:+ExitOnOutOfMemoryError
   -Dwaves.rest-api.bind-address=0.0.0.0
   ${JAVA_OPTS}"
 
-echo "JAVA_OPTS=${JAVA_OPTS}" | tee -a ${WVLOG}/waves.log
+if [ "$WAVES_LOG_JAVA_OPTS" = "true" ] ; then
+  echo "JAVA_OPTS=${JAVA_OPTS}" | tee -a ${WVLOG}/waves.log
+fi
 
 if [ -n "$WAVES_WALLET_SEED" ] ; then
   JAVA_OPTS="-Dwaves.wallet.seed=${WAVES_WALLET_SEED} ${JAVA_OPTS}"

docker/private/waves.custom.conf

@@ -21,6 +21,7 @@ waves {
         reset-effective-balances-at-height: 1
         allow-leased-balance-transfer-until: 0
         block-version-3-after-height: 0
+        generation-period-length = 1000
         pre-activated-features = {
           1 = 0
           2 = 0

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

@@ -491,7 +491,8 @@ class Application(val actorSystem: ActorSystem, val settings: WavesSettings, con
           blockchainUpdater,
           routeTimeout
         ),
-        RewardApiRoute(blockchainUpdater)
+        RewardApiRoute(blockchainUpdater),
+        FinalityApiRoute(blockchainUpdater, settings.dbSettings.maxRollbackDepth, extensionContext.generatorsApi)
       )
 
       val httpService = CompositeHttpService(apiRoutes, settings.restAPISettings)

node/src/main/scala/com/wavesplatform/api/http/FinalityApiRoute.scala

@@ -0,0 +1,40 @@
+package com.wavesplatform.api.http
+
+import com.wavesplatform.api.common.CommonGeneratorsApi
+import com.wavesplatform.api.common.CommonGeneratorsApi.GeneratorEntry
+import com.wavesplatform.state.{Blockchain, GenerationPeriod, Height}
+import org.apache.pekko.http.scaladsl.server.Route
+import play.api.libs.json.*
+
+case class FinalityApiRoute(blockchain: Blockchain, maxRollback: Int, generatorsApi: CommonGeneratorsApi) extends ApiRoute {
+  import FinalityApiRoute.given
+
+  override def route: Route = pathPrefix("blockchain" / "finality") {
+    (get & pathEndOrSingleSlash) {
+      complete(finalityInfo)
+    }
+  }
+
+  private def finalityInfo: JsObject = {
+    val currentHeight = blockchain.height
+    val currentPeriod = blockchain.generationPeriodOf(Height(currentHeight))
+    Json.obj(
+      "height"                  -> currentHeight,
+      "finalizedHeight"         -> blockchain.finalizedHeightAtOrFallback(maxRollback, Height(currentHeight)),
+      "currentGenerationPeriod" -> currentPeriod,
+      "currentGenerators"       -> generatorsApi.generators(Height(currentHeight)),
+      "nextGenerationPeriod"    -> currentPeriod.map(_.next),
+      "nextGenerators"          -> currentPeriod.fold(Seq.empty)(p => generatorsApi.generators(p.next.start))
+    )
+  }
+}
+
+object FinalityApiRoute {
+  given Writes[GenerationPeriod] = (gp: GenerationPeriod) =>
+    Json.obj(
+      "start" -> gp.start,
+      "end"   -> gp.end
+    )
+
+  given Writes[GeneratorEntry] = Json.writes[GeneratorEntry]
+}

node/src/main/scala/com/wavesplatform/api/http/TransactionsApiRoute.scala

@@ -187,12 +187,12 @@ case class TransactionsApiRoute(
 
   def sign: Route = (pathPrefix("sign") & withAuth) {
     pathEndOrSingleSlash(jsonPost[JsObject] { jsv =>
-      mkTxFactory.parseRequestAndSign((jsv \ "sender").as[String], jsv)
+      mkTxFactory.parseRequestAndSign(None, jsv)
     }) ~ signWithSigner
   }
 
   def signWithSigner: Route = path(AddrSegment) { address =>
-    jsonPost[JsObject](mkTxFactory.parseRequestAndSign(address.toString, _))
+    jsonPost[JsObject](mkTxFactory.parseRequestAndSign(Some(address.toString), _))
   }
 
   def signedBroadcast: Route = path("broadcast") {

node/src/main/scala/com/wavesplatform/api/http/requests/package.scala

@@ -85,5 +85,5 @@ package object requests {
   implicit val byteStrFormat: Format[ByteStr] = com.wavesplatform.utils.byteStrFormat
 
   private[requests] def defaultVersion   = TxVersion.V1
-  private[requests] def defaultTimestamp = 0L
+  private[requests] def defaultTimestamp = System.currentTimeMillis()
 }

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

@@ -82,7 +82,7 @@ case class FunctionalitySettings(
     paymentsCheckHeight: Int = 0,
     unitsRegistryAddress: Option[String] = None,
     maxValidEndorsers: Int = 5,
-    generationPeriodLength: Int = 1001
+    generationPeriodLength: Int = 1000
 ) {
   val allowLeasedBalanceTransferUntilHeight: Int              = blockVersion3AfterHeight
   val allowTemporaryNegativeUntil: Long                       = lastTimeBasedForkParameter