fix: move actual business logic into pool rewards calculation class

Author: fabianbormann

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

@@ -1,5 +1,13 @@
 package org.cardanofoundation.rewards.calculation;
 
+import org.cardanofoundation.rewards.data.provider.DataProvider;
+import org.cardanofoundation.rewards.entity.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.cardanofoundation.rewards.constants.RewardConstants.TOTAL_LOVELACE;
+
 public class PoolRewardCalculation {
 
     /*
@@ -103,4 +111,130 @@ public static double calculateMemberReward(double poolReward, double margin, dou
                                                double relativeMemberStake, double relativeStakeOfPool) {
         return Math.floor((poolReward - poolCost) * (1 - margin) * relativeMemberStake / relativeStakeOfPool);
     }
+
+    public static PoolRewardCalculationResult calculatePoolRewardInEpoch(String poolId, int epoch, DataProvider dataProvider) {
+        // Step 1: Get Pool information of current epoch
+        // Example: https://api.koios.rest/api/v0/pool_history?_pool_bech32=pool1z5uqdk7dzdxaae5633fqfcu2eqzy3a3rgtuvy087fdld7yws0xt&_epoch_no=210
+        PoolRewardCalculationResult poolRewardCalculationResult = PoolRewardCalculationResult.builder()
+                .epoch(epoch)
+                .poolId(poolId)
+                .poolReward(0.0)
+                .build();
+
+        PoolHistory poolHistoryCurrentEpoch = dataProvider.getPoolHistory(poolId, epoch);
+        if(poolHistoryCurrentEpoch == null) {
+            return poolRewardCalculationResult;
+        }
+
+        double poolStake = poolHistoryCurrentEpoch.getActiveStake();
+        double poolFees = poolHistoryCurrentEpoch.getPoolFees();
+        double poolMargin = poolHistoryCurrentEpoch.getMargin();
+        double poolFixedCost = poolHistoryCurrentEpoch.getFixedCost();
+        int blocksPoolHasMinted = poolHistoryCurrentEpoch.getBlockCount();
+
+        poolRewardCalculationResult.setPoolFee(poolFees);
+        poolRewardCalculationResult.setPoolMargin(poolMargin);
+        poolRewardCalculationResult.setPoolCost(poolFixedCost);
+
+        if (blocksPoolHasMinted == 0) {
+            return poolRewardCalculationResult;
+        }
+
+        // Step 2: Get Epoch information of current epoch
+        // Source: https://api.koios.rest/api/v0/epoch_info?_epoch_no=211
+        Epoch epochInfo = dataProvider.getEpochInfo(epoch);
+
+        double activeStakeInEpoch = 0;
+        if (epochInfo.getActiveStake() != null) {
+            activeStakeInEpoch = epochInfo.getActiveStake();
+        }
+
+        // The Shelley era and the ada pot system started on mainnet in epoch 208.
+        // Fee and treasury values are 0 for epoch 208.
+        double totalFeesForCurrentEpoch = 0.0;
+        if (epoch > 209) {
+            totalFeesForCurrentEpoch = epochInfo.getFees();
+        }
+
+        int totalBlocksInEpoch = epochInfo.getBlockCount();
+
+        if (epoch > 212 && epoch < 255) {
+            totalBlocksInEpoch = epochInfo.getNonOBFTBlockCount();
+        }
+
+        // Get the ada reserves for the next epoch because it was already updated yet
+        AdaPots adaPotsForNextEpoch = dataProvider.getAdaPotsForEpoch(epoch + 1);
+        double reserves = adaPotsForNextEpoch.getReserves();
+
+        // Step 3: Get total ada in circulation
+        double adaInCirculation = TOTAL_LOVELACE - reserves;
+
+        // Step 4: Get protocol parameters for current epoch
+        ProtocolParameters protocolParameters = dataProvider.getProtocolParametersForEpoch(epoch);
+        double decentralizationParameter = protocolParameters.getDecentralisation();
+        int optimalPoolCount = protocolParameters.getOptimalPoolCount();
+        double influenceParam = protocolParameters.getPoolOwnerInfluence();
+        double monetaryExpandRate = protocolParameters.getMonetaryExpandRate();
+        double treasuryGrowRate = protocolParameters.getTreasuryGrowRate();
+
+        // Step 5: Calculate apparent pool performance
+        double apparentPoolPerformance =
+                PoolRewardCalculation.calculateApparentPoolPerformance(poolStake, activeStakeInEpoch,
+                        blocksPoolHasMinted, totalBlocksInEpoch, decentralizationParameter);
+        poolRewardCalculationResult.setApparentPoolPerformance(apparentPoolPerformance);
+        // Step 6: Calculate total available reward for pools (total reward pot after treasury cut)
+        // -----
+        double totalRewardPot = TreasuryCalculation.calculateTotalRewardPotWithEta(
+                monetaryExpandRate, totalBlocksInEpoch, decentralizationParameter, reserves, totalFeesForCurrentEpoch);
+
+        double stakePoolRewardsPot = totalRewardPot - Math.floor(totalRewardPot * treasuryGrowRate);
+        poolRewardCalculationResult.setStakePoolRewardsPot(stakePoolRewardsPot);
+        // shelley-delegation.pdf 5.5.3
+        //      "[...]the relative stake of the pool owner(s) (the amount of ada
+        //      pledged during pool registration)"
+
+        // Step 7: Get the latest pool update before this epoch and extract the pledge
+        double poolPledge = dataProvider.getPoolPledgeInEpoch(poolId, epoch);
+
+        PoolOwnerHistory poolOwnersHistoryInEpoch = dataProvider.getHistoryOfPoolOwnersInEpoch(poolId, epoch);
+        double totalActiveStakeOfOwners = poolOwnersHistoryInEpoch.getActiveStake();
+
+        if (totalActiveStakeOfOwners < poolPledge) {
+            return poolRewardCalculationResult;
+        }
+
+        double relativeStakeOfPoolOwner = poolPledge / adaInCirculation;
+        double relativePoolStake = poolStake / adaInCirculation;
+
+        // Step 8: Calculate optimal pool reward
+        double optimalPoolReward =
+                PoolRewardCalculation.calculateOptimalPoolReward(
+                        stakePoolRewardsPot,
+                        optimalPoolCount,
+                        influenceParam,
+                        relativePoolStake,
+                        relativeStakeOfPoolOwner);
+        poolRewardCalculationResult.setOptimalPoolReward(optimalPoolReward);
+
+        // Step 9: Calculate pool reward as optimal pool reward * apparent pool performance
+        double poolReward = PoolRewardCalculation.calculatePoolReward(optimalPoolReward, apparentPoolPerformance);
+        poolRewardCalculationResult.setPoolReward(poolReward);
+
+        // Step 10: Calculate pool operator reward
+        double poolOperatorReward = PoolRewardCalculation.calculateLeaderReward(poolReward, poolMargin, poolFixedCost,
+                totalActiveStakeOfOwners / adaInCirculation, relativePoolStake);
+        poolRewardCalculationResult.setOperatorReward(poolOperatorReward);
+        // Step 11: Calculate pool member reward
+        List<Reward> memberRewards = new ArrayList<>();
+        for (Delegator delegator : poolHistoryCurrentEpoch.getDelegators()) {
+            double memberReward = PoolRewardCalculation.calculateMemberReward(poolReward, poolMargin,
+                    poolFixedCost, delegator.getActiveStake() / adaInCirculation, relativePoolStake);
+            memberRewards.add(Reward.builder()
+                    .amount(memberReward)
+                    .stakeAddress(delegator.getStakeAddress())
+                    .build());
+        }
+        poolRewardCalculationResult.setMemberRewards(memberRewards);
+        return poolRewardCalculationResult;
+    }
 }

src/main/java/org/cardanofoundation/rewards/data/fetcher/KoiosDataFetcher.java

@@ -5,9 +5,13 @@
 import org.cardanofoundation.rewards.entity.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import rest.koios.client.backend.api.base.exception.ApiException;
+import rest.koios.client.backend.api.pool.model.PoolDelegatorHistory;
+import rest.koios.client.backend.factory.options.Options;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 import static org.cardanofoundation.rewards.enums.DataType.*;
@@ -206,10 +210,10 @@ private void fetchPoolHistoryByEpoch(String poolId, int epoch, boolean override)
 
     @Override
     public void fetch(int epoch, boolean override) {
-        fetchAdaPots(epoch, override);
+        /*fetchAdaPots(epoch, override);
         fetchEpochInfo(epoch, override);
         fetchProtocolParameters(epoch, override);
-        fetchAccountUpdates(epoch, override);
+        fetchAccountUpdates(epoch, override);*/
 
         List<String> poolIds = List.of(
             "pool1xxhs2zw5xa4g54d5p62j46nlqzwp8jklqvuv2agjlapwjx9qkg9",
@@ -223,9 +227,9 @@ public void fetch(int epoch, boolean override) {
         );
 
         for (String poolId : poolIds) {
-            fetchPoolPledgeInEpoch(poolId, epoch, override);
+            //fetchPoolPledgeInEpoch(poolId, epoch, override);
             fetchPoolHistoryByEpoch(poolId, epoch, override);
-            fetchPoolOwnersStakeInEpoch(poolId, epoch, override);
+            //fetchPoolOwnersStakeInEpoch(poolId, epoch, override);
         }
     }
 }

src/main/java/org/cardanofoundation/rewards/data/provider/DataProvider.java

@@ -21,4 +21,5 @@ public interface DataProvider {
     public List<PoolDeregistration> getRetiredPoolsInEpoch(int epoch);
 
     public List<AccountUpdate> getAccountUpdatesUntilEpoch(List<String> stakeAddresses, int epoch);
+
 }

src/main/java/org/cardanofoundation/rewards/data/provider/KoiosDataProvider.java

@@ -13,6 +13,7 @@
 import rest.koios.client.backend.api.epoch.model.EpochInfo;
 import rest.koios.client.backend.api.epoch.model.EpochParams;
 import rest.koios.client.backend.api.network.model.Totals;
+import rest.koios.client.backend.api.pool.model.PoolDelegatorHistory;
 import rest.koios.client.backend.api.pool.model.PoolUpdate;
 import rest.koios.client.backend.factory.BackendFactory;
 import rest.koios.client.backend.factory.BackendService;
@@ -103,7 +104,13 @@ public PoolHistory getPoolHistory(String poolId, int epoch) {
             e.printStackTrace();
         }
 
-        return PoolHistoryMapper.fromKoiosPoolHistory(poolHistory);
+        PoolHistory history = PoolHistoryMapper.fromKoiosPoolHistory(poolHistory);
+
+        if (history == null) return null;
+
+        List<Delegator> poolMemberInEpoch = getPoolMemberInEpoch(poolId, epoch);
+        history.setDelegators(poolMemberInEpoch);
+        return history;
     }
 
     @Override
@@ -217,4 +224,21 @@ public List<org.cardanofoundation.rewards.entity.AccountUpdate> getAccountUpdate
 
         return accountUpdates;
     }
+
+    private List<Delegator> getPoolMemberInEpoch(String poolId, int epoch) {
+        List<Delegator> delegators = new ArrayList<>();
+        try {
+            List<PoolDelegatorHistory> poolDelegatorsHistory = koiosBackendService
+                    .getPoolService().getPoolDelegatorsHistory(poolId, epoch, Options.EMPTY).getValue();
+            for (PoolDelegatorHistory poolDelegator : poolDelegatorsHistory) {
+                delegators.add(Delegator.builder()
+                        .activeStake(Double.valueOf(poolDelegator.getAmount()))
+                        .stakeAddress(poolDelegator.getStakeAddress())
+                        .build());
+            }
+        } catch (ApiException e) {
+            e.printStackTrace();
+        }
+        return delegators;
+    }
 }

src/main/java/org/cardanofoundation/rewards/entity/Delegator.java

@@ -0,0 +1,13 @@
+package org.cardanofoundation.rewards.entity;
+
+import lombok.*;
+
+@Getter
+@Setter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Delegator {
+    String stakeAddress;
+    Double activeStake;
+}

src/main/java/org/cardanofoundation/rewards/entity/PoolCalculationResult.java

@@ -2,6 +2,8 @@
 
 import lombok.*;
 
+import java.util.List;
+
 @Getter
 @Setter
 @Builder
@@ -13,6 +15,7 @@ public class PoolHistory {
     private Double poolFees;
     private Double margin;
     private Double fixedCost;
+    private List<Delegator> delegators;
     private int blockCount;
     private int epoch;
 }

src/main/java/org/cardanofoundation/rewards/entity/PoolHistory.java

@@ -0,0 +1,24 @@
+package org.cardanofoundation.rewards.entity;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Builder
+@Getter
+@Setter
+public class PoolRewardCalculationResult {
+    int epoch;
+    String poolId;
+    Double stakePoolRewardsPot;
+    List<Reward> memberRewards;
+    Double operatorReward;
+    Double optimalPoolReward;
+    Double poolReward;
+    Double apparentPoolPerformance;
+    Double poolFee;
+    Double poolMargin;
+    Double poolCost;
+}

src/main/java/org/cardanofoundation/rewards/entity/PoolRewardCalculationResult.java

@@ -0,0 +1,13 @@
+package org.cardanofoundation.rewards.entity;
+
+import lombok.*;
+
+@Getter
+@Setter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Reward {
+    private double amount;
+    private String stakeAddress;
+}