Add super block difficulty calculation (#3277)

Author: rmoreliovlabs

rskj-core/src/main/java/co/rsk/RskContext.java

@@ -180,6 +180,7 @@ public class RskContext implements NodeContext, NodeBootstrapper {
     private Genesis genesis;
     private CompositeEthereumListener compositeEthereumListener;
     private DifficultyCalculator difficultyCalculator;
+    private SuperDifficultyCalculator superDifficultyCalculator;
     private ForkDetectionDataCalculator forkDetectionDataCalculator;
     private ProofOfWorkRule proofOfWorkRule;
     private ForkDetectionDataRule forkDetectionDataRule;
@@ -494,7 +495,8 @@ public synchronized BlockExecutor getBlockExecutor() {
                     getReceiptStore(),
                     getRepositoryLocator(),
                     getTransactionExecutorFactory(),
-                    getRskSystemProperties()
+                    getRskSystemProperties(),
+                    getSuperDifficultyCalculator()
             );
         }
 
@@ -1125,7 +1127,7 @@ public synchronized BlockValidationRule getBlockValidationRule() {
                     rskSystemProperties.getNetworkConstants(),
                     rskSystemProperties.getBitcoinjNetworkConstants()
             );
-            final SuperBlockRule superBlockRule = new SuperBlockRule(rskSystemProperties.getActivationConfig(), getBlockStore(), getReceiptStore());
+            final SuperBlockRule superBlockRule = new SuperBlockRule(rskSystemProperties.getActivationConfig(), getBlockStore(), getReceiptStore(), getSuperDifficultyCalculator());
             blockValidationRule = new BlockCompositeRule(
                     new TxsMinGasPriceRule(),
                     new BlockTxsMaxGasPriceRule(rskSystemProperties.getActivationConfig()),
@@ -1813,7 +1815,7 @@ private BlockValidator getBlockHeaderValidator() {
                     rskSystemProperties.getNetworkConstants(),
                     rskSystemProperties.getBitcoinjNetworkConstants()
             );
-            final SuperBlockRule superBlockRule = new SuperBlockRule(rskSystemProperties.getActivationConfig(), getBlockStore(), getReceiptStore());
+            final SuperBlockRule superBlockRule = new SuperBlockRule(rskSystemProperties.getActivationConfig(), getBlockStore(), getReceiptStore(), getSuperDifficultyCalculator());
 
             final BlockHeaderValidationRule blockHeaderValidationRule = new BlockHeaderCompositeRule(
                     getProofOfWorkRule(),
@@ -1920,6 +1922,17 @@ private DifficultyCalculator getDifficultyCalculator() {
         return difficultyCalculator;
     }
 
+    private SuperDifficultyCalculator getSuperDifficultyCalculator() {
+        if (superDifficultyCalculator == null) {
+            RskSystemProperties rskSystemProperties = getRskSystemProperties();
+            superDifficultyCalculator = new SuperDifficultyCalculator(
+                    rskSystemProperties.getNetworkConstants()
+            );
+        }
+
+        return superDifficultyCalculator;
+    }
+
     private BlockToMineBuilder getBlockToMineBuilder() {
         if (blockToMineBuilder == null) {
             blockToMineBuilder = new BlockToMineBuilder(

rskj-core/src/main/java/co/rsk/core/SuperDifficultyCalculator.java

@@ -0,0 +1,93 @@
+/*
+ * This file is part of RskJ
+ * Copyright (C) 2017 RSK Labs Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package co.rsk.core;
+
+import org.ethereum.config.Constants;
+import org.ethereum.core.Block;
+
+import java.math.BigInteger;
+
+public class SuperDifficultyCalculator {
+    private final Constants constants;
+
+    public SuperDifficultyCalculator(Constants constants) {
+        this.constants = constants;
+    }
+
+    public BlockDifficulty calcSuperDifficulty(Block block, Block superParentBlock) {
+        final var shouldUpdateDifficulty = block.getNumber() % constants.getSuperBlockRetargetingInterval().longValue() == 0;
+
+        if (shouldUpdateDifficulty) {
+            return getSuperBlockDifficulty(block, superParentBlock);
+        }
+
+        return superParentBlock.getSuperBlockFields().getSuperDifficulty();
+    }
+
+    private BlockDifficulty getSuperBlockDifficulty(Block curBlock, Block retargetingBlock) {
+        var currentTimestamp = curBlock.getTimestamp() - retargetingBlock.getTimestamp();
+
+        if (currentTimestamp <= 0) {
+            currentTimestamp = 1;
+        }
+
+        final var correctionFactor = constants.getSuperBlockExpectedRetargetIntervalInSeconds()
+                .divide(BigInteger.valueOf(currentTimestamp));
+
+        final var multipliedCorrectionFactor = correctionFactor.shiftLeft(constants.getSuperBlockDifficultyCorrectionFactorShift());
+
+        return calcSuperDifficultyWithTimeStamps(
+                retargetingBlock.getSuperBlockFields().getSuperDifficulty(),
+                multipliedCorrectionFactor,
+                constants.getSuperBlockDifficultyMinCorrectionFactor(),
+                constants.getSuperBlockDifficultyMaxCorrectionFactor(),
+                constants.getSuperBlockDifficultyCorrectionFactorShift());
+    }
+
+    private static BlockDifficulty calcSuperDifficultyWithTimeStamps(
+            BlockDifficulty oldDifficulty,
+            BigInteger correctionFactor,
+            BigInteger superBlockDifficultyMinCorrectionFactor,
+            BigInteger superBlockDifficultyMaxCorrectionFactor,
+            Integer superBlockDifficultyCorrectionFactorShift) {
+
+        var correctionFactorToUse = BigInteger.ZERO;
+
+        if (correctionFactor.compareTo(superBlockDifficultyMinCorrectionFactor) < 0) {
+            correctionFactorToUse = superBlockDifficultyMinCorrectionFactor;
+        } else if (correctionFactor.compareTo(superBlockDifficultyMaxCorrectionFactor) > 0) {
+            correctionFactorToUse = superBlockDifficultyMaxCorrectionFactor;
+        } else {
+            correctionFactorToUse = correctionFactor.shiftRight(superBlockDifficultyCorrectionFactorShift);
+        }
+
+        return computeSuperBlockDifficulty(oldDifficulty, correctionFactorToUse);
+    }
+
+    private static BlockDifficulty computeSuperBlockDifficulty(
+            BlockDifficulty oldDifficulty,
+            BigInteger correctionFactor
+    ) {
+        var newSuperDifficulty = oldDifficulty
+                .multiply(correctionFactor)
+                .asBigInteger();
+
+        return new BlockDifficulty(newSuperDifficulty);
+    }
+}

rskj-core/src/main/java/co/rsk/core/bc/BlockExecutor.java

@@ -19,8 +19,10 @@
 package co.rsk.core.bc;
 
 import co.rsk.config.RskSystemProperties;
+import co.rsk.core.BlockDifficulty;
 import co.rsk.core.Coin;
 import co.rsk.core.RskAddress;
+import co.rsk.core.SuperDifficultyCalculator;
 import co.rsk.core.TransactionExecutorFactory;
 import co.rsk.core.TransactionListExecutor;
 import co.rsk.core.types.bytes.Bytes;
@@ -30,7 +32,6 @@
 import co.rsk.metrics.profilers.MetricKind;
 import co.rsk.metrics.profilers.Profiler;
 import co.rsk.metrics.profilers.ProfilerFactory;
-import co.rsk.util.Trio;
 import com.google.common.annotations.VisibleForTesting;
 import org.ethereum.config.Constants;
 import org.ethereum.config.blockchain.upgrades.ActivationConfig;
@@ -78,6 +79,7 @@ public class BlockExecutor {
 
     private final Map<Keccak256, ProgramResult> transactionResults = new ConcurrentHashMap<>();
     private final long minSequentialSetGasLimit;
+    private final SuperDifficultyCalculator superDifficultyCalculator;
 
     private boolean registerProgramResults;
 
@@ -93,7 +95,8 @@ public BlockExecutor(BlockStore blockStore,
                          ReceiptStore receiptStore,
                          RepositoryLocator repositoryLocator,
                          TransactionExecutorFactory transactionExecutorFactory,
-                         RskSystemProperties systemProperties) {
+                         RskSystemProperties systemProperties,
+                         SuperDifficultyCalculator superDifficultyCalculator) {
         this.activationConfig = systemProperties.getActivationConfig();
 
         this.blockStore = blockStore;
@@ -103,6 +106,7 @@ public BlockExecutor(BlockStore blockStore,
         this.remascEnabled = systemProperties.isRemascEnabled();
         this.concurrentContractsDisallowed = Collections.unmodifiableSet(new HashSet<>(systemProperties.concurrentContractsDisallowed()));
         this.minSequentialSetGasLimit = systemProperties.getNetworkConstants().getMinSequentialSetGasLimit();
+        this.superDifficultyCalculator = superDifficultyCalculator;
 
         int numOfParallelList = Constants.getTransactionExecutionThreads();
         this.execServices = new ExecutorService[numOfParallelList];
@@ -187,12 +191,20 @@ private void fill(Block block, BlockResult result) {
         header.setTxExecutionSublistsEdges(result.getTxEdges());
 
         if (activationConfig.isActive(RSKIP481, block.getNumber())) {
-            final var superParentAndBridgeEvent =
-                    FamilyUtils.findSuperParentAndUnclesAndBridgeEvent(blockStore, receiptStore, block, result.getTransactionReceipts());
+            final var superParentAndBridgeEvent = FamilyUtils.findSuperParentAndBridgeEvent(
+                    blockStore,
+                    receiptStore,
+                    block,
+                    result.getTransactionReceipts());
+
+            var superDifficulty = superParentAndBridgeEvent.superParent() == null ?
+                    BlockDifficulty.ONE :
+                    superDifficultyCalculator.calcSuperDifficulty(block, superParentAndBridgeEvent.superParent());
 
             SuperBlockFields superBlockFields = makeSuperBlockFields(
                     superParentAndBridgeEvent.superParent(),
-                    superParentAndBridgeEvent.superBridgeEvent()
+                    superParentAndBridgeEvent.superBridgeEvent(),
+                    superDifficulty
             );
             block.setSuperChainFields(superBlockFields);
         }
@@ -201,14 +213,15 @@ private void fill(Block block, BlockResult result) {
         profiler.stop(metric);
     }
 
-    private static SuperBlockFields makeSuperBlockFields(Block superParent, SuperBridgeEvent event) {
+    private static SuperBlockFields makeSuperBlockFields(Block superParent, SuperBridgeEvent event, BlockDifficulty superDifficulty) {
         Bytes superParentHash = superParent == null ? null : Bytes.of(superParent.getHash().getBytes());
         long superParentBlockNumber = superParent == null ? 0 : superParent.getSuperBlockFields().getBlockNumber() + 1;
 
         return new SuperBlockFields(
                 superParentHash,
                 superParentBlockNumber,
-                event
+                event,
+                superDifficulty
         );
     }
 

rskj-core/src/main/java/co/rsk/core/bc/FamilyUtils.java

@@ -19,7 +19,6 @@
 package co.rsk.core.bc;
 
 import co.rsk.crypto.Keccak256;
-import co.rsk.util.Trio;
 import org.apache.commons.lang3.tuple.Pair;
 import org.ethereum.core.Block;
 import org.ethereum.core.BlockHeader;
@@ -175,7 +174,7 @@ public static Set<Keccak256> getFamily(BlockStore store, long blockNumber, Kecca
         return family;
     }
 
-    public static FindSuperParentAndBridgeEventResponse findSuperParentAndUnclesAndBridgeEvent(
+    public static FindSuperParentAndBridgeEventResponse findSuperParentAndBridgeEvent(
             BlockStore blockStore,
             ReceiptStore receiptStore,
             Block block,

rskj-core/src/main/java/co/rsk/core/bc/SuperBlockFields.java

@@ -18,6 +18,7 @@
 
 package co.rsk.core.bc;
 
+import co.rsk.core.BlockDifficulty;
 import co.rsk.core.types.bytes.BytesSlice;
 import co.rsk.crypto.Keccak256;
 import org.ethereum.crypto.HashUtil;
@@ -32,11 +33,14 @@ public class SuperBlockFields {
     private final BytesSlice parentHash;
     private final long blockNumber;
     private final SuperBridgeEvent bridgeEvent;
+    private BlockDifficulty superDifficulty;
 
-    public SuperBlockFields(@Nullable BytesSlice parentHash, long blockNumber, @Nullable SuperBridgeEvent bridgeEvent) {
+    public SuperBlockFields(@Nullable BytesSlice parentHash, long blockNumber,
+                            @Nullable SuperBridgeEvent bridgeEvent, BlockDifficulty superDifficulty) {
         this.parentHash = parentHash;
         this.blockNumber = blockNumber;
         this.bridgeEvent = bridgeEvent;
+        this.superDifficulty = superDifficulty;
     }
 
     public BytesSlice getParentHash() {
@@ -51,11 +55,20 @@ public SuperBridgeEvent getBridgeEvent() {
         return bridgeEvent;
     }
 
+    public BlockDifficulty getSuperDifficulty() {
+        return superDifficulty;
+    }
+
+    public void setSuperDifficulty(BlockDifficulty superDifficulty) {
+        this.superDifficulty = superDifficulty;
+    }
+
     public byte[] getEncoded() {
         return RLP.encodeList(
                 RLP.encodeElement(parentHash != null ? parentHash.copyArray() : null),
                 RLP.encodeBigInteger(BigInteger.valueOf(blockNumber)),
-                RLP.encodeElement(bridgeEvent != null ? bridgeEvent.getEncoded() : null)
+                RLP.encodeElement(bridgeEvent != null ? bridgeEvent.getEncoded() : null),
+                RLP.encodeElement(superDifficulty != null ? superDifficulty.getBytes() : null)
         );
     }
 
@@ -64,7 +77,8 @@ public Keccak256 getHash() {
         byte[] encoded = RLP.encodeList(
                 RLP.encodeElement(parentHash != null ? parentHash.copyArray() : null),
                 RLP.encodeBigInteger(BigInteger.valueOf(blockNumber)),
-                RLP.encodeElement(bridgeEvent != null ? bridgeEvent.getEncoded() : null)
+                RLP.encodeElement(bridgeEvent != null ? bridgeEvent.getEncoded() : null),
+                RLP.encodeElement(superDifficulty != null ? superDifficulty.getBytes() : null)
         );
 
         return new Keccak256(HashUtil.keccak256(encoded));