Store block delay on chain contract

Author: phearnot

consensus-client-it/src/test/scala/units/BaseBlockValidationSuite.scala

@@ -66,7 +66,7 @@ trait BaseBlockValidationSuite extends BaseDockerTestSuite {
         if (elParentBlock.height - 1 <= EthereumConstants.GenesisBlockHeight) Right(-1L)
         else ec1.engineApi.getLastWithdrawalIndex(elParentBlock.parentHash)
     }).explicitGet()
-    Withdrawal(elWithdrawalIndexBefore + 1, elParentBlock.minerRewardL2Address, chainContractOptions.miningReward)
+    Withdrawal(elWithdrawalIndexBefore + 1, elParentBlock.minerRewardL2Address, chainContractOptions.miningReward.newValue)
   }
 
   protected final def mkSimulatedBlock(

consensus-client-it/src/test/scala/units/BaseDockerTestSuite.scala

@@ -94,13 +94,7 @@ trait BaseDockerTestSuite
     step("Setup chain contract")
     val genesisBlock = ec1.engineApi.getBlockByNumber(BlockNumber.Number(0)).explicitGet().getOrElse(fail("No EL genesis block"))
     waves1.api.broadcastAndWait(
-      ChainContract.setup(
-        genesisBlock = genesisBlock,
-        elMinerReward = rewardAmount.amount.longValue(),
-        daoAddress = None,
-        daoReward = 0,
-        invoker = chainContractAccount
-      )
+      ChainContract.setup(genesisBlock, rewardAmount.amount.longValue(), None, 0, 2, invoker = chainContractAccount)
     )
     log.info(s"Native token id: ${chainContract.nativeTokenId}")
 

contracts/waves/src/main.ride

@@ -1082,7 +1082,7 @@ func enableTokenTransfers(standardBridgeAddress: String, wavesERC20AddressHex: S
 
 # genesisBlockHashHex without 0x
 @Callable(i)
-func setup(genesisBlockHashHex: String, minerRewardInGwei: Int, daoAddress: String, daoReward: Int) = {
+func setup(genesisBlockHashHex: String, minerRewardInGwei: Int, daoAddress: String, daoReward: Int, blockDelayInSeconds: Int) = {
   if (isContractSetup()) then throw("The contract has been already set up")
   else if (i.originCaller != this) then throw("Only owner of chain contract can do this")
   else if (minerRewardInGwei < 0) then throw("The miner reward must be nonnegative")
@@ -1122,7 +1122,8 @@ func setup(genesisBlockHashHex: String, minerRewardInGwei: Int, daoAddress: Stri
       StringEntry(finalizedBlockKey, genesisBlockHashHex),
       issue,
       StringEntry(tokenIdKey, tokenId.toBase58String()),
-      StringEntry(elNativeBridgeAddressKey, "0x0000000000000000000000000000000000006a7e")
+      StringEntry(elNativeBridgeAddressKey, "0x0000000000000000000000000000000000006a7e"),
+      IntegerEntry("blockDelay", blockDelayInSeconds)
     ] ++ daoEntries
   }
 }

src/main/scala/units/ClientConfig.scala

@@ -14,7 +14,6 @@ case class ClientConfig(
     executionClientAddress: String,
     apiRequestRetries: Int,
     apiRequestRetryWaitTime: FiniteDuration,
-    blockDelay: FiniteDuration,
     firstBlockMinDelay: FiniteDuration,
     blockSyncRequestTimeout: FiniteDuration,
     network: NetworkSettings,

src/main/scala/units/ELUpdater.scala

@@ -12,10 +12,10 @@ import com.wavesplatform.network.ChannelGroupExt
 import com.wavesplatform.state.diffs.FeeValidation.{FeeConstants, FeeUnit, ScriptExtraFee}
 import com.wavesplatform.state.diffs.TransactionDiffer.TransactionValidationError
 import com.wavesplatform.state.{Blockchain, BooleanDataEntry}
+import com.wavesplatform.transaction.*
 import com.wavesplatform.transaction.TxValidationError.InvokeRejectError
 import com.wavesplatform.transaction.smart.InvokeScriptTransaction
 import com.wavesplatform.transaction.smart.script.trace.TracedResult
-import com.wavesplatform.transaction.*
 import com.wavesplatform.utils.{Time, UnsupportedFeature, forceStopApplication}
 import com.wavesplatform.wallet.Wallet
 import io.netty.channel.Channel
@@ -189,7 +189,7 @@ class ELUpdater(
     val startC2ETransferIndex  = lastC2ETransferIndex + 1
 
     val rewardWithdrawal = prevEpochMinerRewardAddress
-      .map(Withdrawal(startElWithdrawalIndex, _, chainContractOptions.miningReward))
+      .map(Withdrawal(startElWithdrawalIndex, _, chainContractOptions.miningReward.valueAtEpoch(epochInfo.number)))
       .toVector
 
     val strictC2ETransfersActivated = epochInfo.number >= chainContractClient.getStrictC2ETransfersActivationEpoch
@@ -301,7 +301,7 @@ class ELUpdater(
           lastEcBlock <- engineApiClient.getLastExecutionBlock()
           willSimulateBlock = lastEcBlock.hash != parentBlock.hash
           currentUnixTs     = time.correctedTime() / 1000
-          nextBlockUnixTs = (parentBlock.timestamp + config.blockDelay.toSeconds).max(
+          nextBlockUnixTs = (parentBlock.timestamp + prevState.options.blockDelayInSeconds.valueAtEpoch(epochInfo.number)).max(
             currentUnixTs +
               // We don't collect transactions for simulated payload, thus we don't need to wait for firstBlockMinDelay
               (if (willSimulateBlock) 0 else config.firstBlockMinDelay.toSeconds)
@@ -390,8 +390,9 @@ class ELUpdater(
             getAndApplyPayloadResult match {
               case Left(err) => logger.error(s"Failed to forge block at epoch ${epochInfo.number}: ${err.message}")
               case Right(networkBlock) =>
-                val ecBlock         = networkBlock.toEcBlock
-                val nextBlockUnixTs = (ecBlock.timestamp + config.blockDelay.toSeconds).max(time.correctedTime() / 1000)
+                val ecBlock = networkBlock.toEcBlock
+                val nextBlockUnixTs =
+                  (ecBlock.timestamp + chainContractOptions.blockDelayInSeconds.valueAtEpoch(epochInfo.number)).max(time.correctedTime() / 1000)
                 val nextMiningDataE = updateHeadAndStartBuildingPayload(
                   epochInfo,
                   ecBlock,
@@ -1004,28 +1005,23 @@ class ELUpdater(
     }
 
   // Of a current epoch miner
-  private def validateBlockSignature(block: NetworkL2Block, epochInfo: Option[EpochInfo]): JobResult[Unit] = {
-    epochInfo match {
-      case Some(epochMeta) =>
-        for {
-          _ <- Either.raiseUnless(block.minerRewardL2Address == epochMeta.rewardAddress) {
-            ClientError(s"block miner ${block.minerRewardL2Address} doesn't equal to ${epochMeta.rewardAddress}")
-          }
-          signature <- Either.fromOption(block.signature, ClientError(s"signature not found"))
-          publicKey <- Either.fromOption(
-            chainContractClient.getMinerPublicKey(block.minerRewardL2Address),
-            ClientError(s"public key for block miner ${block.minerRewardL2Address} not found")
-          )
-          _ <- Either.raiseUnless(crypto.verify(signature, Json.toBytes(block.payload), publicKey, checkWeakPk = true)) {
-            ClientError(s"invalid signature")
-          }
-        } yield ()
-      case _ => Either.unit
-    }
-  }
+  private def validateBlockSignature(block: NetworkL2Block, epochInfo: EpochInfo): JobResult[Unit] =
+    for {
+      _ <- Either.raiseUnless(block.minerRewardL2Address == epochInfo.rewardAddress) {
+        ClientError(s"block miner ${block.minerRewardL2Address} doesn't equal to ${epochInfo.rewardAddress}")
+      }
+      signature <- Either.fromOption(block.signature, ClientError(s"signature not found"))
+      publicKey <- Either.fromOption(
+        chainContractClient.getMinerPublicKey(block.minerRewardL2Address),
+        ClientError(s"public key for block miner ${block.minerRewardL2Address} not found")
+      )
+      _ <- Either.raiseUnless(crypto.verify(signature, Json.toBytes(block.payload), publicKey, checkWeakPk = true)) {
+        ClientError(s"invalid signature")
+      }
+    } yield ()
 
-  private def validateTimestamp(newNetworkBlock: NetworkL2Block, parentEcBlock: EcBlock): JobResult[Unit] = {
-    val minAppendTs = parentEcBlock.timestamp + config.blockDelay.toSeconds
+  private def validateTimestamp(newNetworkBlock: NetworkL2Block, parentEcBlock: EcBlock, epoch: Int): JobResult[Unit] = {
+    val minAppendTs = parentEcBlock.timestamp + chainContractClient.getOptions.blockDelayInSeconds.valueAtEpoch(epoch)
     Either.raiseUnless(newNetworkBlock.timestamp >= minAppendTs) {
       ClientError(
         s"timestamp (${newNetworkBlock.timestamp}) of appended block must be greater or equal $minAppendTs, " +
@@ -1034,11 +1030,6 @@ class ELUpdater(
     }
   }
 
-  private def preValidateBlock(networkBlock: NetworkL2Block, parentBlock: EcBlock, epochInfo: Option[EpochInfo]): JobResult[Unit] = for {
-    _ <- validateTimestamp(networkBlock, parentBlock)
-    _ <- validateBlockSignature(networkBlock, epochInfo)
-  } yield ()
-
   private def getAltChainReferenceBlock(nodeChainInfo: ChainInfo, lastContractBlock: ContractBlock): JobResult[ContractBlock] = {
     if (nodeChainInfo.isMain) {
       for {
@@ -1104,9 +1095,8 @@ class ELUpdater(
             processInvalidBlock(contractBlock, prevState, Some(nodeChainInfo))
         }
       case contractBlock =>
-        // We should check block signature based on epochInfo if block is not at contract yet
-        val epochInfo = Option.when(contractBlock.isEmpty)(prevState.epochInfo)
-        applyBlock(networkBlock, parentBlock, epochInfo) match {
+        (if (contractBlock.isEmpty) validateBlockSignature(networkBlock, prevState.epochInfo) else ().asRight[ClientError])
+          .flatMap(_ => applyBlock(networkBlock, parentBlock, prevState.epochInfo)) match {
           case Right(_) =>
             logger.debug(s"Block ${networkBlock.hash} successfully applied")
             broadcastAndConfirmBlock(networkBlock, ch, prevState, nodeChainInfo, returnToMainChainInfo)
@@ -1577,13 +1567,13 @@ class ELUpdater(
   ): JobResult[Working[ChainStatus]] = {
     logger.trace(s"Trying to apply and do a full validation of block ${networkBlock.hash}")
     for {
-      _ <- applyBlock(networkBlock, parentBlock, epochInfo = None) // epochInfo is empty, because we don't need to validate a block signature
+      _            <- applyBlock(networkBlock, parentBlock, prevState.epochInfo)
       updatedState <- validateAppliedBlock(contractBlock, networkBlock.toEcBlock, prevState)
     } yield updatedState
   }
 
-  private def applyBlock(networkBlock: NetworkL2Block, parentBlock: EcBlock, epochInfo: Option[EpochInfo]): JobResult[Unit] = for {
-    _ <- preValidateBlock(networkBlock, parentBlock, epochInfo)
+  private def applyBlock(networkBlock: NetworkL2Block, parentBlock: EcBlock, epochInfo: EpochInfo): JobResult[Unit] = for {
+    _ <- validateTimestamp(networkBlock, parentBlock, epochInfo.number)
     _ <- engineApiClient.newPayload(networkBlock.payload)
   } yield ()
 
@@ -1611,7 +1601,9 @@ class ELUpdater(
         _ <- validateE2CTransfers(contractBlock, ecBlockLogs)
         _ <- validateAssetRegistryUpdate(ecBlockLogs, contractBlock, parentContractBlock, prevState.options)
         _ <- validateRandao(ecBlock, contractBlock.epoch)
-        miningReward = getMinerRewardAddress(contractBlock, parentContractBlock).map(MiningReward(_, prevState.options.miningReward))
+        miningReward = getMinerRewardAddress(contractBlock, parentContractBlock).map(
+          MiningReward(_, prevState.options.miningReward.valueAtEpoch(contractBlock.epoch))
+        )
         updatedLastElWithdrawalIndex <- validateC2E(
           contractBlock,
           ecBlock,

src/main/scala/units/client/contract/ChainContractClient.scala

@@ -212,17 +212,34 @@ trait ChainContractClient {
       .orElse(getBinaryData(s"miner${rewardAddress.hexNoPrefix}PK"))
       .map(PublicKey(_))
 
-  def getOptions: ChainContractOptions = ChainContractOptions(
-    miningReward = getLongData("minerReward")
-      .map(Gwei.ofRawGwei)
-      .getOrElse(throw new IllegalStateException("minerReward is empty on contract")),
-    elNativeBridgeAddress = getStringData("elBridgeAddress")
-      .map(EthAddress.unsafeFrom)
-      .getOrElse(throw new IllegalStateException("elBridgeAddress is empty on contract")),
-    elStandardBridgeAddress = getStringData("elStandardBridgeAddress")
-      .map(EthAddress.unsafeFrom),
-    assetTransfersActivationEpoch = getAssetTransfersActivationEpoch
-  )
+  def getOptions: ChainContractOptions = {
+    val minerReward = extractData("minerReward") match {
+      case Some(IntegerDataEntry(value = reward)) => ValueAtEpoch(Gwei.ofRawGwei(0), Gwei.ofRawGwei(reward), 1)
+      case Some(StringDataEntry(value = rewards)) =>
+        val Array(oldReward, newReward, changeEpoch) = rewards.split(Sep)
+        ValueAtEpoch(Gwei.ofRawGwei(oldReward.toLong), Gwei.ofRawGwei(newReward.toLong), changeEpoch.toInt)
+      case _ => throw new IllegalStateException("minerReward is empty on contract")
+    }
+    
+    val blockDelay = extractData("blockDelay") match {
+      case Some(IntegerDataEntry(value = delay)) => ValueAtEpoch(0, BigInt(delay).bigInteger.intValueExact(), 1)
+      case Some(StringDataEntry(value = delays)) =>
+        val Array(oldDelay, newDelay, changeEpoch) = delays.split(Sep)
+        ValueAtEpoch(oldDelay.toInt, newDelay.toInt, changeEpoch.toInt)
+      case _ => throw new IllegalStateException("blockDelay is empty on contract")
+    }
+    
+    ChainContractOptions(
+      minerReward,
+      getStringData("elBridgeAddress")
+        .map(EthAddress.unsafeFrom)
+        .getOrElse(throw new IllegalStateException("elBridgeAddress is empty on contract")),
+      getStringData("elStandardBridgeAddress")
+        .map(EthAddress.unsafeFrom),
+      getAssetTransfersActivationEpoch,
+      blockDelay
+    )
+  }
 
   private def getAssetTransfersActivationEpoch: Long = getLongData("assetTransfersActivationEpoch").getOrElse(Long.MaxValue)
 

src/main/scala/units/client/contract/ChainContractOptions.scala

@@ -5,14 +5,12 @@ import units.BlockHash
 import units.client.contract.ContractFunction.*
 import units.eth.{EthAddress, Gwei}
 
-/** @note
-  *   Make sure you have an activation gap: a new feature should not be activated suddenly during nearest blocks.
-  */
 case class ChainContractOptions(
-    miningReward: Gwei,
+    miningReward: ValueAtEpoch[Gwei],
     elNativeBridgeAddress: EthAddress,
     elStandardBridgeAddress: Option[EthAddress],
-    assetTransfersActivationEpoch: Long
+    assetTransfersActivationEpoch: Long,
+    blockDelayInSeconds: ValueAtEpoch[Int]
 ) {
   def bridgeAddresses(epoch: Int): List[EthAddress] = {
     val before = List(elNativeBridgeAddress)
@@ -35,3 +33,7 @@ case class ChainContractOptions(
 
   private def versionOf(epoch: Int): Int = if (epoch < assetTransfersActivationEpoch) 1 else 2
 }
+
+case class ValueAtEpoch[A](oldValue: A, newValue: A, changeAtEpoch: Int) {
+  def valueAtEpoch(epoch: Int): A = if epoch < changeAtEpoch then oldValue else newValue
+}

src/main/scala/units/eth/Gwei.scala

@@ -5,21 +5,14 @@ import play.api.libs.json.Format
 
 import java.math.BigInteger
 
-class Gwei private (val amount: BigInteger) {
-  def toHex: String = Numeric.toHexStringWithPrefix(amount)
-
-  override def hashCode(): Int = amount.hashCode()
-  override def equals(that: Any): Boolean = that match {
-    case that: Gwei => this.amount.compareTo(that.amount) == 0
-    case _          => false
-  }
-  override def toString: String = s"${amount.toString} Gwei"
-}
+opaque type Gwei = BigInteger
 
 object Gwei {
-  implicit val gweiFormat: Format[Gwei] = implicitly[Format[String]].bimap(ofRawGwei, _.toHex)
+  implicit val gweiFormat: Format[Gwei] = implicitly[Format[String]].bimap(ofRawGwei, Numeric.toHexStringWithPrefix)
+
+  extension (g: Gwei) def amount: BigInteger = g
 
   def ofRawGwei(x: Long): Gwei       = ofRawGwei(BigInteger.valueOf(x))
-  def ofRawGwei(x: BigInteger): Gwei = new Gwei(x)
+  def ofRawGwei(x: BigInteger): Gwei = x
   def ofRawGwei(hex: String): Gwei   = Gwei.ofRawGwei(Numeric.toBigInt(hex))
 }

src/test/scala/units/BaseTestSuite.scala

@@ -23,6 +23,7 @@ import units.util.HexBytesConverter
 
 import java.nio.charset.StandardCharsets
 import java.util.concurrent.ThreadLocalRandom
+import scala.concurrent.duration.DurationInt
 
 trait BaseTestSuite
     extends AnyFreeSpec
@@ -49,7 +50,8 @@ trait BaseTestSuite
           d.ecGenesisBlock,
           ElMinerDefaultReward.amount.longValue(),
           defaultSettings.daoRewardAccount.map(_.toAddress),
-          defaultSettings.daoRewardAmount
+          defaultSettings.daoRewardAmount,
+          defaultSettings.blockDelayInSeconds
         ),
         if (settings.registerWwavesToken)
           d.ChainContract.enableTokenTransfersWithWaves(
@@ -82,14 +84,15 @@ trait BaseTestSuite
 
       try {
         d = new ExtensionDomain(
-          rdb = new RDB(rdb.db, rdb.txMetaHandle, rdb.txHandle, rdb.txSnapshotHandle, rdb.apiHandle, Seq.empty),
-          blockchainUpdater = bcu,
-          rocksDBWriter = blockchain,
-          settings = settings.wavesSettings,
-          chainRegistryAccount = chainRegistryAccount,
-          nativeBridgeAddress = NativeBridgeAddress,
-          standardBridgeAddress = StandardBridgeAddress,
-          elMinerDefaultReward = ElMinerDefaultReward
+          new RDB(rdb.db, rdb.txMetaHandle, rdb.txHandle, rdb.txSnapshotHandle, rdb.apiHandle, Seq.empty),
+          bcu,
+          blockchain,
+          settings.wavesSettings,
+          chainRegistryAccount,
+          NativeBridgeAddress,
+          StandardBridgeAddress,
+          ElMinerDefaultReward,
+          defaultSettings.blockDelayInSeconds.seconds
         )
 
         d.wallet.generateNewAccounts(2) // Enough for now

src/test/scala/units/ClientConfigTestSuite.scala

@@ -60,7 +60,6 @@ class ClientConfigTestSuite extends FlatSpec {
          |    api-request-retries = 2
          |    api-request-retry-wait-time = 2s
          |
-         |    block-delay = 6s
          |    first-block-min-delay = 1s
          |    block-sync-request-timeout = 500ms
          |
@@ -82,7 +81,6 @@ class ClientConfigTestSuite extends FlatSpec {
     clientConfig.executionClientAddress shouldBe "http://ec-1:8551"
     clientConfig.apiRequestRetries shouldBe 2
     clientConfig.apiRequestRetryWaitTime shouldBe 2.seconds
-    clientConfig.blockDelay shouldBe 6.seconds
     clientConfig.firstBlockMinDelay shouldBe 1.second
     clientConfig.blockSyncRequestTimeout shouldBe 500.millis
     clientConfig.miningEnable shouldBe true
@@ -124,7 +122,6 @@ class ClientConfigTestSuite extends FlatSpec {
     clientConfig.executionClientAddress shouldBe "http://ec-1:8551"
     clientConfig.apiRequestRetries shouldBe 2
     clientConfig.apiRequestRetryWaitTime shouldBe 2.seconds
-    clientConfig.blockDelay shouldBe 6.seconds
     clientConfig.blockSyncRequestTimeout shouldBe 500.millis
     clientConfig.miningEnable shouldBe true
     clientConfig.privateKeys shouldBe Seq.empty