From aa9aa2092c7de8851c54d98b32d3132bc3395614 Mon Sep 17 00:00:00 2001
From: ERussel <emkil.russel@gmail.com>
Date: Wed, 24 Apr 2024 13:09:51 +0200
Subject: [PATCH] fix unclaimed rewards

---
 .../StakingUnclaimedRewardsFacade.swift       | 71 +++++++++++--------
 1 file changed, 40 insertions(+), 31 deletions(-)

diff --git a/novawallet/Common/Services/PayoutRewardsService/UnclaimedRewards/StakingUnclaimedRewardsFacade.swift b/novawallet/Common/Services/PayoutRewardsService/UnclaimedRewards/StakingUnclaimedRewardsFacade.swift
index b4eb6fa482..1d3cb63a94 100644
--- a/novawallet/Common/Services/PayoutRewardsService/UnclaimedRewards/StakingUnclaimedRewardsFacade.swift
+++ b/novawallet/Common/Services/PayoutRewardsService/UnclaimedRewards/StakingUnclaimedRewardsFacade.swift
@@ -53,13 +53,44 @@ final class StakingUnclaimedRewardsFacade {
         codingFactoryClosure: @escaping () throws -> RuntimeCoderFactoryProtocol,
         connection: JSONRPCEngine
     ) -> CompoundOperationWrapper<[StakingUnclaimedReward]> {
-        StakingClaimedRewardsOperationFactory(
+        let legacyWrapper = createLedgerBasedWrapper(
+            for: validators,
+            codingFactoryClosure: codingFactoryClosure,
+            connection: connection
+        )
+
+        let claimedRewardsWrapper = StakingClaimedRewardsOperationFactory(
             requestFactory: requestFactory
         ).createWrapper(
             for: { validators },
             codingFactoryClosure: codingFactoryClosure,
             connection: connection
         )
+
+        let mergeOperation = ClosureOperation<[StakingUnclaimedReward]> {
+            let legacyResults = try legacyWrapper.targetOperation.extractNoCancellableResultData()
+            let pagedResults = try claimedRewardsWrapper.targetOperation.extractNoCancellableResultData()
+
+            let legacyUnclaimed: Set<ResolvedValidatorEra> = Set(
+                legacyResults.map { ResolvedValidatorEra(validator: $0.accountId, era: $0.era) }
+            )
+
+            return pagedResults.filter { unclaimedReward in
+                let validatorEra = ResolvedValidatorEra(
+                    validator: unclaimedReward.accountId,
+                    era: unclaimedReward.era
+                )
+
+                return legacyUnclaimed.contains(validatorEra)
+            }
+        }
+
+        mergeOperation.addDependency(claimedRewardsWrapper.targetOperation)
+        mergeOperation.addDependency(legacyWrapper.targetOperation)
+
+        return claimedRewardsWrapper
+            .insertingHead(operations: legacyWrapper.allOperations)
+            .insertingTail(operation: mergeOperation)
     }
 }
 
@@ -76,45 +107,23 @@ extension StakingUnclaimedRewardsFacade: StakingUnclaimedRewardsFacadeProtocol {
             let pagedEra = try exposurePagedEra()
             let validators = try validatorsClosure()
 
-            let stakingLedgerItems = validators.filter { validator in
-                guard let pagedEra = pagedEra else {
-                    return true
-                }
-
-                return validator.era < pagedEra
-            }
-
-            let claimedBasedItems = validators.filter { validator in
-                guard let pagedEra = pagedEra else {
-                    return false
-                }
-
-                return validator.era >= pagedEra
-            }
-
-            var wrappers: [CompoundOperationWrapper<[StakingUnclaimedReward]>] = []
-
-            if !stakingLedgerItems.isEmpty {
-                let wrapper = self.createLedgerBasedWrapper(
-                    for: stakingLedgerItems,
+            if pagedEra != nil {
+                let wrapper = self.createClaimedBasedWrapper(
+                    for: validators,
                     codingFactoryClosure: codingFactoryClosure,
                     connection: connection
                 )
 
-                wrappers.append(wrapper)
-            }
-
-            if !claimedBasedItems.isEmpty {
-                let wrapper = self.createClaimedBasedWrapper(
-                    for: claimedBasedItems,
+                return [wrapper]
+            } else {
+                let wrapper = self.createLedgerBasedWrapper(
+                    for: validators,
                     codingFactoryClosure: codingFactoryClosure,
                     connection: connection
                 )
 
-                wrappers.append(wrapper)
+                return [wrapper]
             }
-
-            return wrappers
         }.longrunOperation()
 
         let mergeOperation = ClosureOperation<[StakingUnclaimedReward]> {