NODE-2632 Delayed Light Node block structure

grpc-server/src/test/scala/com/wavesplatform/api/grpc/test/AccountsApiGrpcSpec.scala

@@ -3,15 +3,7 @@ package com.wavesplatform.api.grpc.test
 import com.google.protobuf.ByteString
 import com.wavesplatform.TestValues
 import com.wavesplatform.account.{Address, KeyPair}
-import com.wavesplatform.api.grpc.{
-  AccountRequest,
-  AccountsApiGrpcImpl,
-  BalanceResponse,
-  BalancesRequest,
-  DataEntryResponse,
-  DataRequest,
-  LeaseResponse
-}
+import com.wavesplatform.api.grpc.{AccountRequest, AccountsApiGrpcImpl, BalanceResponse, BalancesRequest, DataEntryResponse, DataRequest, LeaseResponse}
 import com.wavesplatform.block.Block
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.crypto.DigestLength
@@ -27,6 +19,7 @@ import com.wavesplatform.transaction.TxHelpers
 import com.wavesplatform.utils.DiffMatchers
 import monix.execution.Scheduler.Implicits.global
 import org.scalatest.{Assertion, BeforeAndAfterAll}
+import com.wavesplatform.test.DomainPresets.*
 
 import scala.concurrent.Await
 import scala.concurrent.duration.{DurationInt, FiniteDuration}
@@ -194,7 +187,7 @@ class AccountsApiGrpcSpec extends FreeSpec with BeforeAndAfterAll with DiffMatch
 
     val sender          = TxHelpers.signer(1)
     val challengedMiner = TxHelpers.signer(2)
-    withDomain(DomainPresets.TransactionStateSnapshot, balances = AddrWithBalance.enoughBalances(sender)) { d =>
+    withDomain(TransactionStateSnapshot.configure(_.copy(lightNodeBlockFieldsAbsenceInterval = 0)), balances = AddrWithBalance.enoughBalances(sender)) { d =>
       val grpcApi = getGrpcApi(d)
 
       val challengingMiner = d.wallet.generateNewAccount().get

grpc-server/src/test/scala/com/wavesplatform/api/grpc/test/BlocksApiGrpcSpec.scala

@@ -253,7 +253,7 @@ class BlocksApiGrpcSpec extends FreeSpec with BeforeAndAfterAll with DiffMatcher
 
   "NODE-922. GetBlock should return correct data for challenging block" in {
     val sender = TxHelpers.signer(1)
-    withDomain(DomainPresets.TransactionStateSnapshot, balances = AddrWithBalance.enoughBalances(sender, defaultSigner)) { d =>
+    withDomain(TransactionStateSnapshot.configure(_.copy(lightNodeBlockFieldsAbsenceInterval = 0)), balances = AddrWithBalance.enoughBalances(sender, defaultSigner)) { d =>
       val grpcApi          = getGrpcApi(d)
       val challengingMiner = d.wallet.generateNewAccount().get
 
@@ -304,7 +304,7 @@ class BlocksApiGrpcSpec extends FreeSpec with BeforeAndAfterAll with DiffMatcher
 
   "NODE-922. GetBlockRange should return correct data for challenging block" in {
     val sender = TxHelpers.signer(1)
-    withDomain(DomainPresets.TransactionStateSnapshot, balances = AddrWithBalance.enoughBalances(sender, defaultSigner)) { d =>
+    withDomain(TransactionStateSnapshot.configure(_.copy(lightNodeBlockFieldsAbsenceInterval = 0)), balances = AddrWithBalance.enoughBalances(sender, defaultSigner)) { d =>
       val grpcApi          = getGrpcApi(d)
       val challengingMiner = d.wallet.generateNewAccount().get
 

grpc-server/src/test/scala/com/wavesplatform/api/grpc/test/TransactionsApiGrpcSpec.scala

@@ -13,6 +13,7 @@ import com.wavesplatform.history.Domain
 import com.wavesplatform.protobuf.transaction.{PBTransactions, Recipient}
 import com.wavesplatform.state.TxMeta
 import com.wavesplatform.test.*
+import com.wavesplatform.test.DomainPresets.*
 import com.wavesplatform.transaction.Asset.Waves
 import com.wavesplatform.transaction.{TxHelpers, TxVersion}
 import com.wavesplatform.transaction.assets.exchange.{ExchangeTransaction, Order, OrderType}
@@ -142,7 +143,7 @@ class TransactionsApiGrpcSpec extends FreeSpec with BeforeAndAfterAll with DiffM
     val challengedMiner = TxHelpers.signer(2)
     val resender        = TxHelpers.signer(3)
     val recipient       = TxHelpers.signer(4)
-    withDomain(DomainPresets.TransactionStateSnapshot, balances = AddrWithBalance.enoughBalances(sender)) { d =>
+    withDomain(TransactionStateSnapshot.configure(_.copy(lightNodeBlockFieldsAbsenceInterval = 0)), balances = AddrWithBalance.enoughBalances(sender)) { d =>
       val grpcApi          = getGrpcApi(d)
       val challengingMiner = d.wallet.generateNewAccount().get
 

grpc-server/src/test/scala/com/wavesplatform/events/BlockchainUpdatesSpec.scala

@@ -812,7 +812,7 @@ class BlockchainUpdatesSpec extends FreeSpec with WithBUDomain with ScalaFutures
       val sender          = TxHelpers.signer(3)
       val recipient       = TxHelpers.signer(4)
 
-      withDomainAndRepo(settings = DomainPresets.TransactionStateSnapshot) { case (d, repo) =>
+      withDomainAndRepo(settings = TransactionStateSnapshot.configure(_.copy(lightNodeBlockFieldsAbsenceInterval = 0))) { case (d, repo) =>
         val challengingMiner = d.wallet.generateNewAccount().get
 
         val initSenderBalance      = 100000.waves

node-it/src/test/scala/com/wavesplatform/it/sync/BlockChallengeSuite.scala → node-it/src/test/scala/com/wavesplatform/it/sync/lightnode/BlockChallengeSuite.scala

@@ -1,24 +1,24 @@
-package com.wavesplatform.it.sync
+package com.wavesplatform.it.sync.lightnode
 
 import com.typesafe.config.Config
 import com.wavesplatform.account.KeyPair
 import com.wavesplatform.block.Block
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.common.utils.EitherExt2
 import com.wavesplatform.consensus.FairPoSCalculator
-import com.wavesplatform.{TestValues, crypto}
 import com.wavesplatform.features.BlockchainFeatures
-import com.wavesplatform.it.api.Block as ApiBlock
-import com.wavesplatform.it.{BaseFunSuite, Node, NodeConfigs, TransferSending}
 import com.wavesplatform.it.api.AsyncNetworkApi.NodeAsyncNetworkApi
+import com.wavesplatform.it.api.Block as ApiBlock
 import com.wavesplatform.it.api.SyncHttpApi.*
+import com.wavesplatform.it.{BaseFunSuite, Node, NodeConfigs, TransferSending}
 import com.wavesplatform.lang.directives.values.V8
 import com.wavesplatform.lang.v1.compiler.TestCompiler
 import com.wavesplatform.network.RawBytes
 import com.wavesplatform.transaction.Asset.Waves
 import com.wavesplatform.transaction.assets.exchange.OrderType
 import com.wavesplatform.transaction.transfer.MassTransferTransaction.ParsedTransfer
 import com.wavesplatform.transaction.{Transaction, TxHelpers, TxNonNegativeAmount}
+import com.wavesplatform.{TestValues, crypto}
 
 import scala.concurrent.Await
 import scala.concurrent.duration.*
@@ -36,6 +36,7 @@ class BlockChallengeSuite extends BaseFunSuite with TransferSending {
           BlockchainFeatures.LightNode.id.toInt -> 0
         )
       )
+      .overrideBase(_.raw("waves.blockchain.custom.functionality.light-node-block-fields-absence-interval = 0"))
       .withDefault(1)
       .withSpecial(1, _.lightNode)
       .withSpecial(2, _.nonMiner)

node-it/src/test/scala/com/wavesplatform/it/sync/LightNodeBroadcastSuite.scala → node-it/src/test/scala/com/wavesplatform/it/sync/lightnode/LightNodeBroadcastSuite.scala

@@ -1,10 +1,10 @@
-package com.wavesplatform.it.sync
+package com.wavesplatform.it.sync.lightnode
 
 import com.google.common.primitives.Ints
 import com.typesafe.config.Config
 import com.wavesplatform.account.{Address, PublicKey}
-import com.wavesplatform.it.{BaseFunSuite, NodeConfigs, TransferSending}
 import com.wavesplatform.it.api.SyncHttpApi.*
+import com.wavesplatform.it.{BaseFunSuite, NodeConfigs, TransferSending}
 
 class LightNodeBroadcastSuite extends BaseFunSuite with TransferSending {
   override def nodeConfigs: Seq[Config] =

node-it/src/test/scala/com/wavesplatform/it/sync/LightNodeRollbackSuite.scala → node-it/src/test/scala/com/wavesplatform/it/sync/lightnode/LightNodeRollbackSuite.scala

@@ -1,10 +1,10 @@
-package com.wavesplatform.it.sync
+package com.wavesplatform.it.sync.lightnode
 
 import com.google.common.primitives.Ints
 import com.typesafe.config.Config
 import com.wavesplatform.account.{Address, PublicKey}
-import com.wavesplatform.it.{BaseFunSuite, NodeConfigs, TransferSending}
 import com.wavesplatform.it.api.SyncHttpApi.*
+import com.wavesplatform.it.{BaseFunSuite, NodeConfigs, TransferSending}
 
 class LightNodeRollbackSuite extends BaseFunSuite with TransferSending {
   override def nodeConfigs: Seq[Config] =

node/src/main/resources/custom-defaults.conf

@@ -21,6 +21,10 @@ functionality {
   lease-expiration = 1000000
   min-block-time = 15s
   delay-delta = 8
+
+  # Fill new block header fields (state hash and challenged header)
+  # only specified number of blocks after the Light Node blockchain feature activation
+  light-node-block-fields-absence-interval = 1000
 }
 
 # Block rewards settings

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

@@ -128,9 +128,9 @@ case class BlocksApiRoute(settings: RestAPISettings, commonApi: CommonBlocksApi,
       val predictedHeight = (lowerBound + offset).max(lowerBound).min(upperBound)
 
       val timestamp      = timestampOf(predictedHeight)
-      val rightTimestmap = timestampOf(predictedHeight + 1, Long.MaxValue)
+      val rightTimestamp = timestampOf(predictedHeight + 1, Long.MaxValue)
       val leftHit        = timestamp <= target
-      val rightHit       = rightTimestmap <= target
+      val rightHit       = rightTimestamp <= target
 
       val (newLower, newUpper) = {
         if (!leftHit) (lowerBound, (predictedHeight - 1).max(lowerBound))

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

@@ -1,14 +1,13 @@
 package com.wavesplatform
 
-import java.lang.reflect.Constructor
-
 import com.wavesplatform.account.{PrivateKey, PublicKey}
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.lang.ValidationError
 import com.wavesplatform.transaction.TxValidationError.GenericError
 import com.wavesplatform.utils.*
 import org.whispersystems.curve25519.OpportunisticCurve25519Provider
 
+import java.lang.reflect.Constructor
 import scala.util.Try
 
 package object crypto {

node/src/main/scala/com/wavesplatform/mining/BlockChallenger.scala

@@ -46,7 +46,8 @@ class BlockChallengerImpl(
     settings: WavesSettings,
     timeService: Time,
     pos: PoSSelector,
-    appendBlock: Block => Task[Either[ValidationError, BlockApplyResult]]
+    appendBlock: Block => Task[Either[ValidationError, BlockApplyResult]],
+    timeDrift: Long = MaxTimeDrift
 ) extends BlockChallenger
     with ScorexLogging {
 
@@ -179,8 +180,6 @@ class BlockChallengerImpl(
           blockchainUpdater.parentHeader(prevBlockHeader, 2).map(_.timestamp),
           blockTime
         )
-
-      initialBlockSnapshot <- BlockDiffer.createInitialBlockSnapshot(blockchainUpdater, challengedBlock.header.reference, acc.toAddress)
       blockWithoutChallengeAndStateHash <- Block.buildAndSign(
         challengedBlock.header.version,
         blockTime,
@@ -204,6 +203,7 @@ class BlockChallengerImpl(
         blockchainUpdater.computeNextReward,
         None
       )
+      initialBlockSnapshot <- BlockDiffer.createInitialBlockSnapshot(blockchainUpdater, challengedBlock.header.reference, acc.toAddress)
       stateHash <- TxStateSnapshotHashBuilder
         .computeStateHash(
           txs,
@@ -227,26 +227,28 @@ class BlockChallengerImpl(
           acc,
           blockFeatures(blockchainUpdater, settings),
           blockRewardVote(settings),
-          Some(stateHash),
-          Some(
-            ChallengedHeader(
-              challengedBlock.header.timestamp,
-              challengedBlock.header.baseTarget,
-              challengedBlock.header.generationSignature,
-              challengedBlock.header.featureVotes,
-              challengedBlock.header.generator,
-              challengedBlock.header.rewardVote,
-              challengedStateHash,
-              challengedSignature
+          if (blockchainWithNewBlock.supportsLightNodeBlockFields()) Some(stateHash) else None,
+          if (blockchainWithNewBlock.supportsLightNodeBlockFields())
+            Some(
+              ChallengedHeader(
+                challengedBlock.header.timestamp,
+                challengedBlock.header.baseTarget,
+                challengedBlock.header.generationSignature,
+                challengedBlock.header.featureVotes,
+                challengedBlock.header.generator,
+                challengedBlock.header.rewardVote,
+                challengedStateHash,
+                challengedSignature
+              )
             )
-          )
+          else None
         )
     } yield {
       log.debug(s"Forged challenging block $challengingBlock")
       challengingBlock
     }
   }.flatMap {
-    case res @ Right(block) => waitForTimeAlign(block.header.timestamp).map(_ => res)
+    case res @ Right(block) => waitForTimeAlign(block.header.timestamp, timeDrift).map(_ => res)
     case err @ Left(_)      => Task(err)
   }
 
@@ -262,10 +264,10 @@ class BlockChallengerImpl(
   private def blockRewardVote(settings: WavesSettings): Long =
     settings.rewardsSettings.desired.getOrElse(-1L)
 
-  private def waitForTimeAlign(blockTime: Long): Task[Unit] =
+  private def waitForTimeAlign(blockTime: Long, timeDrift: Long): Task[Unit] =
     Task {
       val currentTime = timeService.correctedTime()
-      blockTime - currentTime - MaxTimeDrift
+      blockTime - currentTime - timeDrift
     }.flatMap { timeDiff =>
       if (timeDiff > 0) {
         Task.sleep(timeDiff.millis)

node/src/main/scala/com/wavesplatform/mining/Miner.scala

@@ -1,6 +1,5 @@
 package com.wavesplatform.mining
 
-import java.time.LocalTime
 import cats.syntax.either.*
 import com.wavesplatform.account.{Address, KeyPair, PKKeyPair}
 import com.wavesplatform.block.Block.*
@@ -18,11 +17,11 @@ import com.wavesplatform.state.*
 import com.wavesplatform.state.BlockchainUpdaterImpl.BlockApplyResult.{Applied, Ignored}
 import com.wavesplatform.state.appender.BlockAppender
 import com.wavesplatform.state.diffs.BlockDiffer
-import com.wavesplatform.transaction.TxValidationError.BlockFromFuture
 import com.wavesplatform.transaction.*
+import com.wavesplatform.transaction.TxValidationError.BlockFromFuture
 import com.wavesplatform.utils.{ScorexLogging, Time}
-import com.wavesplatform.utx.UtxPool.PackStrategy
 import com.wavesplatform.utx.UtxPool
+import com.wavesplatform.utx.UtxPool.PackStrategy
 import com.wavesplatform.wallet.Wallet
 import io.netty.channel.group.ChannelGroup
 import kamon.Kamon
@@ -31,6 +30,7 @@ import monix.execution.cancelables.{CompositeCancelable, SerialCancelable}
 import monix.execution.schedulers.SchedulerService
 import monix.reactive.Observable
 
+import java.time.LocalTime
 import scala.concurrent.duration.*
 
 trait Miner {
@@ -60,7 +60,8 @@ class MinerImpl(
     pos: PoSSelector,
     val minerScheduler: SchedulerService,
     val appenderScheduler: SchedulerService,
-    transactionAdded: Observable[Unit]
+    transactionAdded: Observable[Unit],
+    maxTimeDrift: Long = appender.MaxTimeDrift
 ) extends Miner
     with MinerDebugInfo
     with ScorexLogging {
@@ -184,11 +185,11 @@ class MinerImpl(
         currentTime - 1.minute.toMillis
       )
       _ <- Either.cond(
-        blockTime <= currentTime + appender.MaxTimeDrift,
+        blockTime <= currentTime + maxTimeDrift,
         log.debug(
           s"Forging with ${account.toAddress}, balance $balance, prev block $reference at $height with target ${lastBlockHeader.baseTarget}"
         ),
-        s"Block time $blockTime is from the future: current time is $currentTime, MaxTimeDrift = ${appender.MaxTimeDrift}"
+        s"Block time $blockTime is from the future: current time is $currentTime, MaxTimeDrift = $maxTimeDrift"
       )
       consensusData <- consensusData(height, account, lastBlockHeader, blockTime)
       prevStateHash =
@@ -207,7 +208,7 @@ class MinerImpl(
           account,
           blockFeatures(version),
           blockRewardVote(version),
-          stateHash,
+          if (blockchainUpdater.supportsLightNodeBlockFields(height + 1)) stateHash else None,
           None
         )
         .leftMap(_.err)

node/src/main/scala/com/wavesplatform/mining/microblocks/MicroBlockMinerImpl.scala

@@ -171,7 +171,7 @@ class MicroBlockMinerImpl(
             signer = account,
             featureVotes = accumulatedBlock.header.featureVotes,
             rewardVote = accumulatedBlock.header.rewardVote,
-            stateHash = stateHash,
+            stateHash = if (blockchainUpdater.supportsLightNodeBlockFields()) stateHash else None,
             challengedHeader = None
           )
           .leftMap(BlockBuildError)

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

@@ -76,7 +76,8 @@ case class FunctionalitySettings(
     ethInvokePaymentsCheckHeight: Int = 0,
     daoAddress: Option[String] = None,
     xtnBuybackAddress: Option[String] = None,
-    xtnBuybackRewardPeriod: Int = Int.MaxValue
+    xtnBuybackRewardPeriod: Int = Int.MaxValue,
+    lightNodeBlockFieldsAbsenceInterval: Int = 1000
 ) {
   val allowLeasedBalanceTransferUntilHeight: Int              = blockVersion3AfterHeight
   val allowTemporaryNegativeUntil: Long                       = lastTimeBasedForkParameter

node/src/main/scala/com/wavesplatform/state/Blockchain.scala

@@ -5,6 +5,7 @@ import com.wavesplatform.block.Block.*
 import com.wavesplatform.block.{Block, BlockHeader, SignedBlockHeader}
 import com.wavesplatform.common.state.ByteStr
 import com.wavesplatform.consensus.GeneratingBalanceProvider
+import com.wavesplatform.features.BlockchainFeatures.LightNode
 import com.wavesplatform.features.{BlockchainFeature, BlockchainFeatureStatus, BlockchainFeatures}
 import com.wavesplatform.lang.ValidationError
 import com.wavesplatform.lang.script.ContractScript
@@ -221,5 +222,8 @@ object Blockchain {
 
     def hasBannedEffectiveBalance(address: Address, height: Int = blockchain.height): Boolean =
       blockchain.effectiveBalanceBanHeights(address).contains(height)
+
+    def supportsLightNodeBlockFields(height: Int = blockchain.height): Boolean =
+      blockchain.featureActivationHeight(LightNode.id).exists(height >= _ + blockchain.settings.functionalitySettings.lightNodeBlockFieldsAbsenceInterval)
   }
 }