fix: ajust plot and report feature according to the latest changes

Author: fabianbormann

report/treasury_calculation_result.js

@@ -27,10 +27,21 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
                                                                   final List<String> poolsThatProducedBlocksInEpoch,
                                                                   final List<PoolHistory> poolHistories,
                                                                   final HashSet<String> lateDeregisteredAccounts,
-                                                                  final HashSet<String> accountsRegisteredInThePast,
+                                                                  final HashSet<String> registeredAccountsSinceLastEpoch,
+                                                                  final HashSet<String> registeredAccountsUntilNow,
                                                                   final HashSet<String> sharedPoolRewardAddressesWithoutReward) {
         final EpochCalculationResult epochCalculationResult = EpochCalculationResult.builder().epoch(epoch).build();
 
+        if (epoch < 209) {
+            epochCalculationResult.setReserves(MAINNET_SHELLEY_INITIAL_RESERVES);
+            epochCalculationResult.setTreasury(MAINNET_SHELLEY_INITIAL_TREASURY);
+            epochCalculationResult.setTotalDistributedRewards(BigInteger.ZERO);
+            epochCalculationResult.setTotalRewardsPot(BigInteger.ZERO);
+            epochCalculationResult.setTotalPoolRewardsPot(BigInteger.ZERO);
+            epochCalculationResult.setTotalAdaInCirculation(MAINNET_SHELLEY_INITIAL_UTXO);
+            return epochCalculationResult;
+        }
+
         double treasuryGrowthRate = 0.2;
         double monetaryExpandRate = 0.003;
         double decentralizationParameter = 1;
@@ -67,25 +78,41 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
         final BigInteger stakePoolRewardsPot = rewardPot.subtract(treasuryCut);
 
         // The sum of all the refunds attached to unregistered reward accounts are added to the
-        // treasury (see: Pool Reap Transition, p.53, figure 40, shely-ledger.pdf)
+        // treasury (see: Pool Reap Transition, p.53, figure 40, shelley-ledger.pdf)
         if (retiredPools.size() > 0) {
             List<String> rewardAddressesOfRetiredPools = retiredPools.stream().map(PoolDeregistration::getRewardAddress).toList();
             List<String> deregisteredOwnerAccounts = deregisteredAccounts.stream()
                     .filter(rewardAddressesOfRetiredPools::contains).toList();
             List<String> lateDeregisteredOwnerAccounts = lateDeregisteredAccounts.stream()
                     .filter(rewardAddressesOfRetiredPools::contains).toList();
+            List<String> ownerAccountsRegisteredInThePast = registeredAccountsUntilNow.stream()
+                    .filter(rewardAddressesOfRetiredPools::contains).toList();
 
-            if (deregisteredOwnerAccounts.size() > 0 || lateDeregisteredOwnerAccounts.size() > 0) {
-                treasuryForCurrentEpoch = treasuryForCurrentEpoch.add(POOL_DEPOSIT_IN_LOVELACE);
+            /* Check if the reward address of the retired pool has been unregistered before
+               or if the reward address has been unregistered after the randomness stabilization window
+               or if the reward address has not been registered at all */
+            for (PoolDeregistration retiredPool : retiredPools) {
+                String rewardAddress = retiredPool.getRewardAddress();
+                if (deregisteredOwnerAccounts.contains(rewardAddress) ||
+                        lateDeregisteredOwnerAccounts.contains(rewardAddress) ||
+                        !ownerAccountsRegisteredInThePast.contains(rewardAddress)) {
+                    // If the reward address has been unregistered, the deposit is added to the treasury
+                    treasuryForCurrentEpoch = treasuryForCurrentEpoch.add(POOL_DEPOSIT_IN_LOVELACE);
+                }
             }
         }
         // Check if there was a MIR Certificate in the previous epoch
         BigInteger treasuryWithdrawals = BigInteger.ZERO;
+        BigInteger calculatedReserve = subtract(reserveInPreviousEpoch, subtract(rewardPot, totalFeesForCurrentEpoch));
+
         for (MirCertificate mirCertificate : mirCertificates) {
             if (mirCertificate.getPot() == MirPot.TREASURY) {
                 treasuryWithdrawals = treasuryWithdrawals.add(mirCertificate.getTotalRewards());
+            } else if (mirCertificate.getPot() == MirPot.RESERVES) {
+                calculatedReserve = calculatedReserve.subtract(mirCertificate.getTotalRewards());
             }
         }
+
         treasuryForCurrentEpoch = treasuryForCurrentEpoch.subtract(treasuryWithdrawals);
 
         BigInteger totalDistributedRewards = BigInteger.ZERO;
@@ -95,7 +122,7 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
 
         int i = 1;
         for (String poolId : poolsThatProducedBlocksInEpoch) {
-            log.info("[" + i + " / " + poolsThatProducedBlocksInEpoch.size() + "] Processing pool: " + poolId);
+            log.debug("[" + i + " / " + poolsThatProducedBlocksInEpoch.size() + "] Processing pool: " + poolId);
             PoolHistory poolHistory = poolHistories.stream().filter(history -> history.getPoolId().equals(poolId)).findFirst().orElse(null);
 
             PoolRewardCalculationResult poolRewardCalculationResult = PoolRewardCalculationResult
@@ -132,7 +159,7 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
                         blocksInEpoch, protocolParameters,
                         adaInCirculation, activeStakeInEpoch, stakePoolRewardsPot,
                         poolHistory.getOwnerActiveStake(), poolHistory.getOwners(),
-                        delegatorAccountDeregistrations, ignoreLeaderReward, lateDeregisteredDelegators, accountsRegisteredInThePast);
+                        delegatorAccountDeregistrations, ignoreLeaderReward, lateDeregisteredDelegators, registeredAccountsSinceLastEpoch);
             }
 
             totalDistributedRewards = add(totalDistributedRewards, poolRewardCalculationResult.getDistributedPoolReward());
@@ -141,7 +168,6 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
             i++;
         }
 
-        BigInteger calculatedReserve = subtract(reserveInPreviousEpoch, subtract(rewardPot, totalFeesForCurrentEpoch));
         BigInteger undistributedRewards = subtract(stakePoolRewardsPot, totalDistributedRewards);
         calculatedReserve = add(calculatedReserve, undistributedRewards);
         calculatedReserve = subtract(calculatedReserve, unspendableEarnedRewards);
@@ -157,9 +183,17 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
             calculatedReserve = calculatedReserve.add(MAINNET_BOOTSTRAP_ADDRESS_AMOUNT);
         }
 
-        log.info("Unspendable earned rewards: " + lovelaceToAda(unspendableEarnedRewards.intValue()) + " ADA");
+        log.debug("Unspendable earned rewards: " + lovelaceToAda(unspendableEarnedRewards.intValue()) + " ADA");
         treasuryForCurrentEpoch = add(treasuryForCurrentEpoch, unspendableEarnedRewards);
 
+        TreasuryCalculationResult treasuryCalculationResult = TreasuryCalculationResult.builder()
+                .epoch(epoch)
+                .treasury(treasuryForCurrentEpoch)
+                .totalRewardPot(rewardPot)
+                .treasuryWithdrawals(treasuryWithdrawals)
+                .unspendableEarnedRewards(unspendableEarnedRewards)
+                .build();
+
         epochCalculationResult.setTotalDistributedRewards(totalDistributedRewards);
         epochCalculationResult.setTotalRewardsPot(rewardPot);
         epochCalculationResult.setReserves(calculatedReserve);
@@ -168,6 +202,7 @@ public static EpochCalculationResult calculateEpochRewardPots(final int epoch, f
         epochCalculationResult.setTotalPoolRewardsPot(stakePoolRewardsPot);
         epochCalculationResult.setTotalAdaInCirculation(adaInCirculation);
         epochCalculationResult.setTotalUndistributedRewards(undistributedRewards);
+        epochCalculationResult.setTreasuryCalculationResult(treasuryCalculationResult);
 
         return epochCalculationResult;
     }

src/main/java/org/cardanofoundation/rewards/calculation/EpochCalculation.java

@@ -6,6 +6,7 @@
 import java.math.BigInteger;
 import java.util.*;
 
+import static org.cardanofoundation.rewards.calculation.constants.RewardConstants.MAINNET_VASIL_HARDFORK_EPOCH;
 import static org.cardanofoundation.rewards.calculation.util.BigNumberUtils.*;
 import static org.cardanofoundation.rewards.calculation.util.BigNumberUtils.divide;
 
@@ -131,14 +132,28 @@ public static PoolRewardCalculationResult calculatePoolRewardInEpoch(final Strin
                                                                          final HashSet<String> deregisteredAccounts, final boolean ignoreLeaderReward,
                                                                          final HashSet<String> lateDeregisteredAccounts,
                                                                          final HashSet<String> accountsRegisteredInThePast) {
+        final int earnedEpoch = poolHistoryCurrentEpoch.getEpoch();
         final PoolRewardCalculationResult poolRewardCalculationResult = PoolRewardCalculationResult.builder()
-                .epoch(poolHistoryCurrentEpoch.getEpoch())
+                .epoch(earnedEpoch)
                 .poolId(poolId)
                 .poolReward(BigInteger.ZERO)
                 .distributedPoolReward(BigInteger.ZERO)
                 .unspendableEarnedRewards(BigInteger.ZERO)
                 .build();
 
+        /*
+            babbage-ledger.pdf | 6 Forgo Reward Calculation Prefilter | p. 14
+
+            The reward calculation no longer filters out the unregistered stake credentials when creating
+            a reward update. As in the Shelley era, though, they are still filtered on the epoch boundary
+            when the reward update is applied
+
+        if (spendableEpoch >= MAINNET_VASIL_HARDFORK_EPOCH) {
+            lateDeregisteredAccounts.addAll(deregisteredAccounts);
+            deregisteredAccounts.clear();
+        }
+        */
+
         final BigInteger poolStake = poolHistoryCurrentEpoch.getActiveStake();
         final BigInteger poolPledge = poolHistoryCurrentEpoch.getPledge();
         final double poolMargin = poolHistoryCurrentEpoch.getMargin();
@@ -196,20 +211,20 @@ public static PoolRewardCalculationResult calculatePoolRewardInEpoch(final Strin
         String rewardAddress = poolRewardCalculationResult.getRewardAddress();
 
         if (!accountsRegisteredInThePast.contains(rewardAddress)) {
-            log.info(poolRewardCalculationResult.getRewardAddress() + " has never been registered. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
+            log.debug(poolRewardCalculationResult.getRewardAddress() + " has never been registered. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
             poolOperatorReward = BigInteger.ZERO;
         } else if (deregisteredAccounts.contains(rewardAddress)) {
-            log.info(poolRewardCalculationResult.getRewardAddress() + " has been deregistered. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
+            log.debug(poolRewardCalculationResult.getRewardAddress() + " has been deregistered. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
             poolOperatorReward = BigInteger.ZERO;
         } else if (lateDeregisteredAccounts.contains(rewardAddress)) {
-            log.info("[unregRU]: " + poolRewardCalculationResult.getRewardAddress() + " has been deregistered lately. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
+            log.debug("[unregRU]: " + poolRewardCalculationResult.getRewardAddress() + " has been deregistered lately. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
             unspendableEarnedRewards = poolOperatorReward;
             poolOperatorReward = BigInteger.ZERO;
         }
 
         if (ignoreLeaderReward) {
             poolOperatorReward = BigInteger.ZERO;
-            log.info("[reward address of multiple pools] Pool " + poolId + " has been ignored. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
+            log.debug("[reward address of multiple pools] Pool " + poolId + " has been ignored. Operator would have received " + poolOperatorReward + " but will not receive any rewards.");
         }
 
         // Step 11: Calculate pool member reward
@@ -226,10 +241,10 @@ public static PoolRewardCalculationResult calculatePoolRewardInEpoch(final Strin
                     poolFixedCost, divide(delegator.getActiveStake(), adaInCirculation), relativePoolStake);
 
             if (deregisteredAccounts.contains(stakeAddress)) {
-                log.info("Delegator " + stakeAddress + " has been deregistered. Delegator would have received " + memberReward + " but will not receive any rewards.");
+                log.debug("Delegator " + stakeAddress + " has been deregistered. Delegator would have received " + memberReward + " but will not receive any rewards.");
                 memberReward = BigInteger.ZERO;
             } else if (lateDeregisteredAccounts.contains(stakeAddress)) {
-                log.info("[unregRU]: " + stakeAddress + " has been deregistered lately. Delegator would have received " + memberReward + " but will not receive any rewards.");
+                log.debug("[unregRU]: " + stakeAddress + " has been deregistered lately. Delegator would have received " + memberReward + " but will not receive any rewards.");
                 unspendableEarnedRewards = unspendableEarnedRewards.add(memberReward);
                 memberReward = BigInteger.ZERO;
             }

src/main/java/org/cardanofoundation/rewards/calculation/PoolRewardsCalculation.java

@@ -3,7 +3,9 @@
 import org.cardanofoundation.rewards.calculation.domain.*;
 import org.cardanofoundation.rewards.calculation.enums.AccountUpdateAction;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.math.MathContext;
 import java.util.List;
 
 import static org.cardanofoundation.rewards.calculation.constants.RewardConstants.EXPECTED_SLOT_PER_EPOCH;
@@ -20,7 +22,7 @@ public class TreasuryCalculation {
    */
   public static BigInteger calculateTotalRewardPotWithEta(double monetaryExpandRate, int totalBlocksInEpochByPools,
                                                           double decentralizationParameter, BigInteger reserve, BigInteger fee) {
-    double eta = calculateEta(totalBlocksInEpochByPools, decentralizationParameter);
+    BigDecimal eta = calculateEta(totalBlocksInEpochByPools, decentralizationParameter);
     return multiplyAndFloor(reserve, monetaryExpandRate, eta).add(fee);
   }
 
@@ -33,25 +35,27 @@ public static BigInteger calculateTotalRewardPotWithEta(double monetaryExpandRat
   *
   * See: https://github.com/input-output-hk/cardano-ledger/commit/c4f10d286faadcec9e4437411bce9c6c3b6e51c2
   */
-  private static double calculateEta(int totalBlocksInEpochByPools, double decentralizationParameter) {
+  private static BigDecimal calculateEta(int totalBlocksInEpochByPools, double decentralizationParameter) {
     // shelley-delegation.pdf 5.4.3
 
     if (decentralizationParameter >= 0.8) {
-      return 1.0;
+      return BigDecimal.ONE;
     }
 
     // The number of expected blocks will be the number of slots per epoch times the active slots coefficient
-    double activeSlotsCoeff = 0.05; // See: Non-Updatable Parameters: https://cips.cardano.org/cips/cip9/
+    BigDecimal activeSlotsCoeff = new BigDecimal("0.05"); // See: Non-Updatable Parameters: https://cips.cardano.org/cips/cip9/
 
     // decentralizationParameter is the proportion of blocks that are expected to be produced by stake pools
     // instead of the OBFT (Ouroboros Byzantine Fault Tolerance) nodes. It was introduced close before the Shelley era:
     // https://github.com/input-output-hk/cardano-ledger/commit/c4f10d286faadcec9e4437411bce9c6c3b6e51c2
-    double expectedBlocksInNonOBFTSlots = EXPECTED_SLOT_PER_EPOCH * activeSlotsCoeff * (1 - decentralizationParameter);
+    BigDecimal expectedBlocksInNonOBFTSlots = new BigDecimal(EXPECTED_SLOT_PER_EPOCH )
+            .multiply(activeSlotsCoeff).multiply (new BigDecimal(1 - decentralizationParameter));
 
     // eta is the ratio between the number of blocks that have been produced during the epoch, and
     // the expectation value of blocks that should have been produced during the epoch under
     // ideal conditions.
-    return Math.min(1, totalBlocksInEpochByPools / expectedBlocksInNonOBFTSlots);
+    MathContext mathContext = new MathContext(32);
+    return new BigDecimal(totalBlocksInEpochByPools).divide(expectedBlocksInNonOBFTSlots, mathContext).min(BigDecimal.ONE);
   }
 
   /*

src/main/java/org/cardanofoundation/rewards/calculation/TreasuryCalculation.java

@@ -7,8 +7,13 @@ public class RewardConstants {
   public static final BigInteger POOL_DEPOSIT_IN_LOVELACE = BigInteger.valueOf(500000000);
   // https://developers.cardano.org/docs/operate-a-stake-pool/introduction-to-cardano/#slots-and-epochs
   public static final int EXPECTED_SLOT_PER_EPOCH = 432000;
+  public static final BigInteger MAINNET_SHELLEY_INITIAL_RESERVES = new BigInteger("13888022852926644");
+  public static final BigInteger MAINNET_SHELLEY_INITIAL_TREASURY = new BigInteger("0");
+  public static final BigInteger MAINNET_SHELLEY_INITIAL_UTXO = TOTAL_LOVELACE.subtract(MAINNET_SHELLEY_INITIAL_RESERVES);
   public static final int GENESIS_CONFIG_SECURITY_PARAMETER = 2160;
+  public static final int MAINNET_SHELLEY_START_EPOCH = 208;
   public static final int MAINNET_ALLEGRA_HARDFORK_EPOCH = 236;
+  public static final int MAINNET_VASIL_HARDFORK_EPOCH = 350;
   public static final BigInteger MAINNET_BOOTSTRAP_ADDRESS_AMOUNT = new BigInteger("318200635000000");
   public static final double ACTIVE_SLOT_COEFFICIENT = 0.05;
   public static final long RANDOMNESS_STABILISATION_WINDOW = Math.round(

src/main/java/org/cardanofoundation/rewards/calculation/constants/RewardConstants.java

@@ -14,4 +14,5 @@ public class TreasuryCalculationResult {
     BigInteger treasury;
     BigInteger totalRewardPot;
     BigInteger treasuryWithdrawals;
+    BigInteger unspendableEarnedRewards;
 }

src/main/java/org/cardanofoundation/rewards/calculation/domain/TreasuryCalculationResult.java

@@ -11,6 +11,11 @@ public static BigInteger add(BigInteger a, BigInteger b) {
         return a.add(b);
     }
 
+    public static BigInteger multiplyAndFloor(BigInteger a, double b, BigDecimal c) {
+        return new BigDecimal(a).multiply(BigDecimal.valueOf(b).multiply(c))
+                .round(new MathContext(0, RoundingMode.FLOOR)).toBigInteger();
+    }
+
     public static BigInteger multiplyAndFloor(BigInteger a, double b, double c) {
         return new BigDecimal(a).multiply(BigDecimal.valueOf(b).multiply(BigDecimal.valueOf(c)))
                 .round(new MathContext(0, RoundingMode.FLOOR)).toBigInteger();