Bumped dependencies

.github/workflows/push-default-branch.yml

@@ -11,6 +11,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '11'
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
       - uses: scalacenter/sbt-dependency-submission@v3
         with:
           configs-ignore: test compile-internal provided
@@ -33,5 +39,5 @@ jobs:
           SONATYPE_USERNAME: ${{ secrets.OSSRH_USERNAME }}
           PGP_PASSPHRASE: ${{ secrets.OSSRH_GPG_PASSPHRASE }}
         run: |
-          version=$(echo ${{ github.ref }} | awk -F '[-.]' '{print $2"."$3}')-SNAPSHOT
+          version=$(awk -F '[".]' '{print $3"."$4"."$5+1}' version.sbt)-SNAPSHOT
           sbt -Dproject.version=$version --mem 4096 --batch publishSigned

build.sbt

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

lang/jvm/src/main/scala/com/wavesplatform/lang/FileCompiler.scala

@@ -1,10 +1,10 @@
 package com.wavesplatform.lang
 
-import com.google.common.base.Charsets
 import com.google.common.io
 import com.wavesplatform.lang.v1.estimator.v3.ScriptEstimatorV3
 
 import java.io.File
+import java.nio.charset.StandardCharsets
 
 object FileCompiler extends App {
   private val estimator = ScriptEstimatorV3.latest
@@ -19,12 +19,12 @@ object FileCompiler extends App {
           pathname.isFile && pathname.getAbsoluteFile != scriptFile
         })
         .map { f =>
-          f.getName -> io.Files.asCharSource(f, Charsets.UTF_8).read()
+          f.getName -> io.Files.asCharSource(f, StandardCharsets.UTF_8).read()
         }
         .toMap
 
       API
-        .compile(io.Files.asCharSource(scriptFile, Charsets.UTF_8).read(), estimator, libraries = imports)
+        .compile(io.Files.asCharSource(scriptFile, StandardCharsets.UTF_8).read(), estimator, libraries = imports)
         .fold(
           error => throw new RuntimeException(s"$error while compiling $path"),
           _ => println(s"successfully compiled $path")

lang/shared/src/main/scala/com/wavesplatform/lang/v1/evaluator/ctx/impl/CryptoContext.scala

@@ -4,6 +4,7 @@ import cats.implicits.*
 import cats.{Id, Monad}
 import com.wavesplatform.common.merkle.Merkle.createRoot
 import com.wavesplatform.common.state.ByteStr
+import com.wavesplatform.lang.*
 import com.wavesplatform.lang.directives.values.*
 import com.wavesplatform.lang.v1.compiler.Terms.*
 import com.wavesplatform.lang.v1.compiler.Types.*
@@ -14,7 +15,6 @@ import com.wavesplatform.lang.v1.evaluator.FunctionIds.*
 import com.wavesplatform.lang.v1.evaluator.ctx.impl.crypto.RSA.DigestAlgorithm
 import com.wavesplatform.lang.v1.evaluator.ctx.{BaseFunction, EvaluationContext, NativeFunction}
 import com.wavesplatform.lang.v1.{BaseGlobal, CTX}
-import com.wavesplatform.lang.*
 
 import scala.collection.mutable
 import scala.util.Try
@@ -50,7 +50,7 @@ object CryptoContext {
       }
     )
 
-  private val ctxCache = mutable.AnyRefMap.empty[(BaseGlobal, StdLibVersion), CTX[NoContext]]
+  private val ctxCache = mutable.HashMap.empty[(BaseGlobal, StdLibVersion), CTX[NoContext]]
 
   private def buildNew(global: BaseGlobal, version: StdLibVersion): CTX[NoContext] = {
     def functionFamily(
@@ -373,8 +373,7 @@ object CryptoContext {
         case xs @ ARR(proof) :: CONST_BYTESTR(value) :: CONST_LONG(index) :: Nil =>
           val sizeCheckedProofs = proof.collect { case bs @ CONST_BYTESTR(v) if v.size == 32 => bs }
           if (value.size == 32 && proof.length <= 16 && sizeCheckedProofs.size == proof.size) {
-            Try(createRoot(value.arr, Math.toIntExact(index), sizeCheckedProofs.reverse.map(_.bs.arr)))
-              .toEither
+            Try(createRoot(value.arr, Math.toIntExact(index), sizeCheckedProofs.reverse.map(_.bs.arr))).toEither
               .leftMap(e => ThrownError(if (e.getMessage != null) e.getMessage else "error"))
               .flatMap(r => CONST_BYTESTR(ByteStr(r)))
           } else {

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

@@ -1,26 +1,25 @@
 package com.wavesplatform
 
-import java.io.{FileOutputStream, PrintWriter}
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
-
-import scala.collection.mutable
-import scala.concurrent.duration.Duration
-import scala.util.Try
-
 import com.wavesplatform.account.Address
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.lang.ValidationError
 import com.wavesplatform.metrics.Metrics
-import com.wavesplatform.transaction.{AuthorizedTransaction, Transaction, TxValidationError}
 import com.wavesplatform.transaction.smart.InvokeScriptTransaction
+import com.wavesplatform.transaction.{AuthorizedTransaction, Transaction, TxValidationError}
 import com.wavesplatform.utils.ScorexLogging
 import org.influxdb.dto.Point
 
+import java.io.{FileOutputStream, PrintWriter}
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import scala.collection.mutable
+import scala.concurrent.duration.Duration
+import scala.util.Try
+
 private class ResponsivenessLogs(csvPrefix: String, metricName: String) extends ScorexLogging {
   import ResponsivenessLogs.TxEvent
 
-  //noinspection ScalaStyle
+  // noinspection ScalaStyle
   private[this] case class MetricSnapshot(point: Point.Builder = null, nano: Long = System.nanoTime(), millis: Long = System.currentTimeMillis())
 
   private[this] case class TxState(
@@ -32,7 +31,7 @@ private class ResponsivenessLogs(csvPrefix: String, metricName: String) extends
       miningAttempt: Int,
       height: Int
   )
-  private[this] val stateMap = mutable.AnyRefMap.empty[ByteStr, TxState]
+  private[this] val stateMap = mutable.HashMap.empty[ByteStr, TxState]
 
   def writeEvent(
       height: Int,
@@ -76,48 +75,46 @@ private class ResponsivenessLogs(csvPrefix: String, metricName: String) extends
           .addField("height", height)
 
         if (eventType == TxEvent.Mined) {
-          stateMap.get(tx.id()).foreach {
-            case TxState(received, lastReceived, firstMined, _, _, attempt, _) =>
-              val delta     = toMillis(nowNanos - received)
-              val lastDelta = toMillis(nowNanos - lastReceived)
-              log.trace(s"Neutrino mining time for ${tx.id()} (attempt #$attempt): $delta ms ($lastDelta from last recv)")
-
-              val snapshot = MetricSnapshot(basePoint.addField("time-to-mine", delta).addField("time-to-last-mine", lastDelta), nowNanos)
-              stateMap(tx.id()) = TxState(
-                received,
-                lastReceived,
-                firstMined.orElse(Some(snapshot)),
-                Some(snapshot),
-                None,
-                attempt,
-                height
-              )
+          stateMap.get(tx.id()).foreach { case TxState(received, lastReceived, firstMined, _, _, attempt, _) =>
+            val delta     = toMillis(nowNanos - received)
+            val lastDelta = toMillis(nowNanos - lastReceived)
+            log.trace(s"Neutrino mining time for ${tx.id()} (attempt #$attempt): $delta ms ($lastDelta from last recv)")
+
+            val snapshot = MetricSnapshot(basePoint.addField("time-to-mine", delta).addField("time-to-last-mine", lastDelta), nowNanos)
+            stateMap(tx.id()) = TxState(
+              received,
+              lastReceived,
+              firstMined.orElse(Some(snapshot)),
+              Some(snapshot),
+              None,
+              attempt,
+              height
+            )
           }
         } else if (eventType == TxEvent.Expired || (eventType == TxEvent.Invalidated && !isAlreadyInTheState)) {
-          stateMap.get(tx.id()).foreach {
-            case st @ TxState(received, lastReceived, firstMined, _, _, _, _) =>
-              val delta     = toMillis(nowNanos - received)
-              val lastDelta = toMillis(nowNanos - lastReceived)
-              log.trace(s"Neutrino fail time for ${tx.id()}: $delta ms")
-
-              val baseFailedPoint = basePoint
-                .tag("reason", reasonClass)
-                .addField("time-to-fail", delta)
-                .addField("time-to-last-fail", lastDelta)
-
-              val failedPoint = firstMined match {
-                case Some(ms) =>
-                  val ffDelta    = toMillis(nowNanos - ms.nano)
-                  val firstDelta = toMillis(ms.nano - received)
-                  baseFailedPoint
-                    .addField("time-to-first-mine", firstDelta)
-                    .addField("time-to-finish-after-first-mining", ffDelta)
-
-                case None =>
-                  baseFailedPoint
-              }
-
-              stateMap(tx.id()) = st.copy(failed = Some(MetricSnapshot(failedPoint)))
+          stateMap.get(tx.id()).foreach { case st @ TxState(received, lastReceived, firstMined, _, _, _, _) =>
+            val delta     = toMillis(nowNanos - received)
+            val lastDelta = toMillis(nowNanos - lastReceived)
+            log.trace(s"Neutrino fail time for ${tx.id()}: $delta ms")
+
+            val baseFailedPoint = basePoint
+              .tag("reason", reasonClass)
+              .addField("time-to-fail", delta)
+              .addField("time-to-last-fail", lastDelta)
+
+            val failedPoint = firstMined match {
+              case Some(ms) =>
+                val ffDelta    = toMillis(nowNanos - ms.nano)
+                val firstDelta = toMillis(ms.nano - received)
+                baseFailedPoint
+                  .addField("time-to-first-mine", firstDelta)
+                  .addField("time-to-finish-after-first-mining", ffDelta)
+
+              case None =>
+                baseFailedPoint
+            }
+
+            stateMap(tx.id()) = st.copy(failed = Some(MetricSnapshot(failedPoint)))
           }
         }
 

node/src/main/scala/com/wavesplatform/api/common/CommonAccountsApi.scala

@@ -1,6 +1,5 @@
 package com.wavesplatform.api.common
 
-import com.google.common.base.Charsets
 import com.google.common.collect.AbstractIterator
 import com.wavesplatform.account.{Address, Alias}
 import com.wavesplatform.api.common.AddressPortfolio.{assetBalanceIterator, nftIterator}
@@ -15,6 +14,7 @@ import monix.eval.Task
 import monix.reactive.Observable
 import org.rocksdb.RocksIterator
 
+import java.nio.charset.StandardCharsets
 import java.util.regex.Pattern
 import scala.annotation.tailrec
 import scala.jdk.CollectionConverters.*
@@ -178,7 +178,7 @@ object CommonAccountsApi {
               endOfData()
             }
           } else {
-            val dataKey = new String(iter.key().drop(prefix.length), Charsets.UTF_8)
+            val dataKey = new String(iter.key().drop(prefix.length), StandardCharsets.UTF_8)
             if (matches(dataKey)) {
               nextDbEntry = Option(iter.value()).map { arr =>
                 Keys.data(addressId, dataKey).parse(arr).entry

node/src/main/scala/com/wavesplatform/database/RocksDBWriter.scala

@@ -843,7 +843,7 @@ class RocksDBWriter(
   }
 
   private def batchCleanupAssetBalances(fromInclusive: Height, toExclusive: Height, rw: RW): Unit = {
-    val lastUpdateAt = mutable.AnyRefMap.empty[(AddressId, IssuedAsset), Height]
+    val lastUpdateAt = mutable.HashMap.empty[(AddressId, IssuedAsset), Height]
 
     val updateAt     = new ArrayBuffer[(AddressId, IssuedAsset, Height)]() // First height of update in this range
     val updateAtKeys = new ArrayBuffer[Key[BalanceNode]]()
@@ -890,7 +890,7 @@ class RocksDBWriter(
 
   private def batchCleanupAccountData(fromInclusive: Height, toExclusive: Height, rw: RW): Unit = {
     val changedDataAddresses = mutable.Set.empty[AddressId]
-    val lastUpdateAt         = mutable.AnyRefMap.empty[(AddressId, String), Height]
+    val lastUpdateAt         = mutable.HashMap.empty[(AddressId, String), Height]
 
     val updateAt     = new ArrayBuffer[(AddressId, String, Height)]() // First height of update in this range
     val updateAtKeys = new ArrayBuffer[Key[DataNode]]()

node/src/main/scala/com/wavesplatform/database/package.scala

@@ -1,6 +1,5 @@
 package com.wavesplatform
 
-import com.google.common.base.Charsets.UTF_8
 import com.google.common.collect.{Interners, Maps}
 import com.google.common.io.ByteStreams.{newDataInput, newDataOutput}
 import com.google.common.io.{ByteArrayDataInput, ByteArrayDataOutput}
@@ -32,6 +31,7 @@ import sun.nio.ch.Util
 import supertagged.TaggedType
 
 import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
 import java.util.Map as JMap
 import scala.annotation.tailrec
 import scala.collection.mutable.ArrayBuffer
@@ -97,7 +97,7 @@ package object database {
 
     while (i < data.length) {
       val len = ((data(i) << 8) | (data(i + 1) & 0xff)).toShort // Optimization
-      s += new String(data, i + 2, len, UTF_8)
+      s += new String(data, i + 2, len, StandardCharsets.UTF_8)
       i += (2 + len)
     }
     s.result()

node/src/main/scala/com/wavesplatform/network/Handshake.scala

@@ -1,10 +1,10 @@
 package com.wavesplatform.network
 
-import java.net.{InetAddress, InetSocketAddress}
-
-import com.google.common.base.Charsets
+import com.wavesplatform.utils.*
 import io.netty.buffer.ByteBuf
-import com.wavesplatform.utils._
+
+import java.net.{InetAddress, InetSocketAddress}
+import java.nio.charset.StandardCharsets
 
 case class Handshake(
     applicationName: String,
@@ -57,14 +57,14 @@ object Handshake {
     if (appNameSize < 0 || appNameSize > Byte.MaxValue) {
       throw new InvalidHandshakeException(s"An invalid application name's size: $appNameSize")
     }
-    val appName    = in.readSlice(appNameSize).toString(Charsets.UTF_8)
+    val appName    = in.readSlice(appNameSize).toString(StandardCharsets.UTF_8)
     val appVersion = (in.readInt(), in.readInt(), in.readInt())
 
     val nodeNameSize = in.readByte()
     if (nodeNameSize < 0 || nodeNameSize > Byte.MaxValue) {
       throw new InvalidHandshakeException(s"An invalid node name's size: $nodeNameSize")
     }
-    val nodeName = in.readSlice(nodeNameSize).toString(Charsets.UTF_8)
+    val nodeName = in.readSlice(nodeNameSize).toString(StandardCharsets.UTF_8)
 
     val nonce = in.readLong()
 

node/src/main/scala/com/wavesplatform/utils/package.scala

@@ -1,13 +1,13 @@
 package com.wavesplatform
 
-import com.google.common.base.Charsets
 import com.google.common.primitives.UnsignedBytes
 import com.google.protobuf.ByteString
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.common.utils.{Base58, Base64}
 import com.wavesplatform.lang.v1.compiler.Terms.*
 import play.api.libs.json.*
 
+import java.nio.charset.StandardCharsets
 import java.security.SecureRandom
 import scala.annotation.tailrec
 
@@ -80,7 +80,7 @@ package object utils {
   }
 
   implicit class StringBytes(val s: String) extends AnyVal {
-    def utf8Bytes: Array[Byte]   = s.getBytes(Charsets.UTF_8)
+    def utf8Bytes: Array[Byte]   = s.getBytes(StandardCharsets.UTF_8)
     def toByteString: ByteString = ByteString.copyFromUtf8(s)
   }
 
@@ -98,5 +98,5 @@ package object utils {
       case FAIL(reason) => Json.obj("error" -> ApiError.ScriptExecutionError.Id, "error" -> reason)
     }
 
-    implicit val byteStrOrdering: Ordering[ByteStr] = (x, y) => UnsignedBytes.lexicographicalComparator().compare(x.arr, y.arr)
+  implicit val byteStrOrdering: Ordering[ByteStr] = (x, y) => UnsignedBytes.lexicographicalComparator().compare(x.arr, y.arr)
 }