Removed supertagged (#4014)

Author: phearnot

benchmark/build.sbt

@@ -5,7 +5,7 @@ Jmh / version := "1.37"
 libraryDependencies ++= Seq(
   "org.scodec"             %% "scodec-core"         % "2.3.3",
   "org.eclipse.collections" % "eclipse-collections" % "13.0.0",
-  "commons-codec"           % "commons-codec"       % "1.19.0"
+  "commons-codec"           % "commons-codec"       % "1.20.0"
 ) ++ Dependencies.logDeps
 
 // https://github.com/ktoso/sbt-jmh#adding-to-your-project

benchmark/src/test/scala/com/wavesplatform/RollbackBenchmark.scala

@@ -8,7 +8,7 @@ import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.common.utils.EitherExt2.*
 import com.wavesplatform.database.{RDB, RocksDBWriter}
 import com.wavesplatform.protobuf.transaction.PBRecipients
-import com.wavesplatform.state.{Portfolio, StateSnapshot}
+import com.wavesplatform.state.{Height, Portfolio, StateSnapshot}
 import com.wavesplatform.transaction.Asset.IssuedAsset
 import com.wavesplatform.transaction.assets.IssueTransaction
 import com.wavesplatform.transaction.{GenesisTransaction, Proofs, TxDecimals, TxPositiveAmount}
@@ -108,7 +108,7 @@ object RollbackBenchmark extends ScorexLogging {
 
     log.info("Rolling back")
     val start = System.nanoTime()
-    rocksDBWriter.rollbackTo(1)
+    rocksDBWriter.rollbackTo(Height(1))
     val end = System.nanoTime()
     log.info(f"Rollback took ${(end - start) * 1e-6}%.3f ms")
     rocksDBWriter.close()

benchmark/src/test/scala/com/wavesplatform/state/RocksDBWriterBenchmark.scala

@@ -90,12 +90,12 @@ object RocksDBWriterBenchmark {
 
     val db = RocksDBWriter(rawDB, wavesSettings.blockchainSettings, wavesSettings.dbSettings, wavesSettings.enableLightMode)
 
-    def loadBlockInfoAt(height: Int): Option[(BlockMeta, Seq[(TxMeta, Transaction)])] =
+    def loadBlockInfoAt(height: Height): Option[(BlockMeta, Seq[(TxMeta, Transaction)])] =
       loadBlockMetaAt(height).map { meta =>
-        meta -> database.loadTransactions(Height(height), rawDB)
+        meta -> database.loadTransactions(height, rawDB)
       }
 
-    def loadBlockMetaAt(height: Int): Option[BlockMeta] = rawDB.db.get(Keys.blockMetaAt(Height(height))).flatMap(BlockMeta.fromPb)
+    def loadBlockMetaAt(height: Height): Option[BlockMeta] = rawDB.db.get(Keys.blockMetaAt(height)).flatMap(BlockMeta.fromPb)
 
     val cba = CommonBlocksApi(db, loadBlockMetaAt, loadBlockInfoAt)
 

build.sbt

@@ -168,7 +168,7 @@ lazy val `waves-node` = (project in file("."))
 
 inScope(Global)(
   Seq(
-    scalaVersion         := "3.7.3",
+    scalaVersion         := "3.7.4",
     organization         := "com.wavesplatform",
     organizationName     := "Waves Platform",
     organizationHomepage := Some(url("https://wavesplatform.com")),

grpc-server/src/main/scala/com/wavesplatform/api/grpc/AccountsApiGrpcImpl.scala

@@ -89,7 +89,7 @@ class AccountsApiGrpcImpl(commonApi: CommonAccountsApi)(implicit sc: Scheduler)
               ByteString.copyFrom(sender.bytes),
               Some(PBRecipients.create(recipient)),
               amount,
-              height
+              height.toInt
             )
           }
       responseObserver.completeWith(result)

grpc-server/src/main/scala/com/wavesplatform/api/grpc/AssetsApiGrpcImpl.scala

@@ -59,6 +59,6 @@ class AssetsApiGrpcImpl(assetsApi: CommonAssetsApi, accountsApi: CommonAccountsA
       },
       d.sponsorship,
       sequenceInBlock = d.sequenceInBlock,
-      issueHeight = d.issueHeight
+      issueHeight = d.issueHeight.toInt
     )
 }

grpc-server/src/main/scala/com/wavesplatform/api/grpc/BlocksApiGrpcImpl.scala

@@ -9,7 +9,7 @@ import com.wavesplatform.api.grpc.BlockRequest.Request
 import com.wavesplatform.api.http.ApiError.BlockDoesNotExist
 import com.wavesplatform.protobuf.*
 import com.wavesplatform.protobuf.block.PBBlock
-import com.wavesplatform.state.TxMeta
+import com.wavesplatform.state.{Height, TxMeta}
 import com.wavesplatform.transaction.Transaction
 import io.grpc.stub.StreamObserver
 import monix.execution.Scheduler
@@ -20,18 +20,18 @@ class BlocksApiGrpcImpl(commonApi: CommonBlocksApi)(implicit sc: Scheduler) exte
   import BlocksApiGrpcImpl.*
 
   override def getCurrentHeight(request: Empty): Future[Int] = {
-    Future.successful(commonApi.currentHeight)
+    Future.successful(commonApi.currentHeight.toInt)
   }
 
   override def getBlockRange(request: BlockRangeRequest, responseObserver: StreamObserver[BlockWithHeight]): Unit = responseObserver.interceptErrors {
     val stream =
       if (request.includeTransactions)
         commonApi
-          .blocksRange(request.fromHeight, request.toHeight)
+          .blocksRange(Height(request.fromHeight), Height(request.toHeight))
           .map(toBlockWithHeight)
       else
         commonApi
-          .metaRange(request.fromHeight, request.toHeight)
+          .metaRange(Height(request.fromHeight), Height(request.toHeight))
           .map(toBlockWithHeight)
 
     responseObserver.completeWith(request.filter match {
@@ -51,7 +51,7 @@ class BlocksApiGrpcImpl(commonApi: CommonBlocksApi)(implicit sc: Scheduler) exte
         else commonApi.meta(blockId.toByteStr).map(toBlockWithHeight)
 
       case Request.Height(height) =>
-        val actualHeight = if (height > 0) height else commonApi.currentHeight + height
+        val actualHeight = if (height > 0) Height(height) else commonApi.currentHeight + height
         if (request.includeTransactions)
           commonApi
             .blockAtHeight(actualHeight)

grpc-server/src/main/scala/com/wavesplatform/api/grpc/TransactionsApiGrpcImpl.scala

@@ -122,7 +122,7 @@ class TransactionsApiGrpcImpl(blockchain: Blockchain, commonApi: CommonTransacti
             commonApi.transactionById(txId.toByteStr).map { m =>
               val status = applicationStatusFromTxStatus(m.status)
 
-              TransactionStatus(txId, TransactionStatus.Status.CONFIRMED, m.height, status)
+              TransactionStatus(txId, TransactionStatus.Status.CONFIRMED, m.height.toInt, status)
             }
           }
           .getOrElse(TransactionStatus(txId, TransactionStatus.Status.NOT_EXISTS))
@@ -153,7 +153,7 @@ private object TransactionsApiGrpcImpl {
       case _                                     => None
     }
 
-    TransactionResponse(transactionId, meta.height, Some(meta.transaction.toPB), status, invokeScriptResult)
+    TransactionResponse(transactionId, meta.height.toInt, Some(meta.transaction.toPB), status, invokeScriptResult)
   }
 
   def applicationStatusFromTxStatus(status: TxMeta.Status): ApplicationStatus.Recognized =

grpc-server/src/main/scala/com/wavesplatform/events/BlockchainUpdates.scala

@@ -5,7 +5,7 @@ import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.events.api.grpc.protobuf.BlockchainUpdatesApiGrpc
 import com.wavesplatform.events.settings.BlockchainUpdatesSettings
 import com.wavesplatform.extensions.{Context, Extension}
-import com.wavesplatform.state.{Blockchain, StateSnapshot}
+import com.wavesplatform.state.{Blockchain, Height, StateSnapshot}
 import com.wavesplatform.utils.{Schedulers, ScorexLogging}
 import io.grpc.netty.NettyServerBuilder
 import io.grpc.protobuf.services.ProtoReflectionServiceV1
@@ -65,10 +65,10 @@ class BlockchainUpdates(private val context: Context) extends Extension with Sco
 
     if (extensionHeight > nodeHeight) {
       log.info(s"Rolling back from $extensionHeight to node height $nodeHeight")
-      repo.rollbackData(nodeHeight)
+      repo.rollbackData(Height(nodeHeight))
     }
 
-    val lastUpdateId = Try(ByteStr(repo.getBlockUpdate(nodeHeight).getUpdate.id.toByteArray)).toOption
+    val lastUpdateId = Try(ByteStr(repo.getBlockUpdate(Height(nodeHeight)).getUpdate.id.toByteArray)).toOption
     val lastBlockId  = context.blockchain.blockHeader(nodeHeight).map(_.id())
 
     if (lastUpdateId != lastBlockId)

grpc-server/src/main/scala/com/wavesplatform/events/Loader.scala

@@ -1,15 +1,15 @@
 package com.wavesplatform.events
 
-import com.google.common.primitives.Ints
 import com.wavesplatform.api.common.CommonBlocksApi
 import com.wavesplatform.api.grpc.*
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.common.utils.Base58
 import com.wavesplatform.database.{DBExt, DBResource}
-import com.wavesplatform.events.protobuf.BlockchainUpdated.Append.Body
 import com.wavesplatform.events.protobuf.BlockchainUpdated as PBBlockchainUpdated
+import com.wavesplatform.events.protobuf.BlockchainUpdated.Append.Body
 import com.wavesplatform.protobuf.*
 import com.wavesplatform.protobuf.block.PBBlock
+import com.wavesplatform.state.Height
 import com.wavesplatform.utils.ScorexLogging
 import monix.reactive.Observable
 import org.rocksdb.RocksDB
@@ -18,16 +18,16 @@ import scala.collection.mutable.ArrayBuffer
 import scala.util.{Failure, Success, Try}
 
 class Loader(db: RocksDB, blocksApi: CommonBlocksApi, target: Option[(Int, ByteStr)], streamId: String) extends ScorexLogging {
-  private def loadBatch(res: DBResource, fromHeight: Int): Try[Seq[PBBlockchainUpdated]] = Try {
-    res.fullIterator.seek(Ints.toByteArray(fromHeight))
+  private def loadBatch(res: DBResource, fromHeight: Height): Try[Seq[PBBlockchainUpdated]] = Try {
+    res.fullIterator.seek(fromHeight.toByteArray)
     val buffer = ArrayBuffer[PBBlockchainUpdated]()
 
-    while (res.fullIterator.isValid && buffer.size < 100 && target.forall { case (h, _) => fromHeight + buffer.size <= h }) {
+    while (res.fullIterator.isValid && buffer.size < 100 && target.forall { case (h, _) => fromHeight + buffer.size <= Height(h) }) {
       buffer.append(Loader.parseUpdate(res.fullIterator.value(), blocksApi, fromHeight + buffer.size))
       res.fullIterator.next()
     }
 
-    for ((h, id) <- target if h == fromHeight + buffer.size - 1; u <- buffer.lastOption) {
+    for ((h, id) <- target if h == fromHeight.toInt + buffer.size - 1; u <- buffer.lastOption) {
       require(
         u.id.toByteArray.sameElements(id.arr),
         s"Stored update ${Base58.encode(u.id.toByteArray)} at ${u.height} does not match target $id at $h"
@@ -37,7 +37,7 @@ class Loader(db: RocksDB, blocksApi: CommonBlocksApi, target: Option[(Int, ByteS
     buffer.toSeq
   }
 
-  private def streamFrom(fromHeight: Int): Observable[PBBlockchainUpdated] = db.resourceObservable.flatMap { res =>
+  private def streamFrom(fromHeight: Height): Observable[PBBlockchainUpdated] = db.resourceObservable.flatMap { res =>
     loadBatch(res, fromHeight) match {
       case Success(nextBatch) =>
         if (nextBatch.isEmpty) Observable.empty[PBBlockchainUpdated]
@@ -46,14 +46,14 @@ class Loader(db: RocksDB, blocksApi: CommonBlocksApi, target: Option[(Int, ByteS
     }
   }
 
-  def loadUpdates(fromHeight: Int): Observable[PBBlockchainUpdated] = {
+  def loadUpdates(fromHeight: Height): Observable[PBBlockchainUpdated] = {
     log.trace(s"[$streamId] Loading stored updates from $fromHeight up to ${target.fold("the most recent one") { case (h, id) => s"$id at $h" }}")
     streamFrom(fromHeight)
   }
 }
 
 object Loader {
-  def parseUpdate(bs: Array[Byte], blocksApi: CommonBlocksApi, height: Int): PBBlockchainUpdated =
+  def parseUpdate(bs: Array[Byte], blocksApi: CommonBlocksApi, height: Height): PBBlockchainUpdated =
     PBBlockchainUpdated
       .parseFrom(bs)
       .update(
@@ -68,7 +68,7 @@ object Loader {
         )
       )
 
-  def loadUpdate(res: DBResource, blocksApi: CommonBlocksApi, height: Int): PBBlockchainUpdated =
+  def loadUpdate(res: DBResource, blocksApi: CommonBlocksApi, height: Height): PBBlockchainUpdated =
     parseUpdate(res.get(Repo.keyForHeight(height)), blocksApi, height)
 
 }