Merge branch 'network-gap-fix' into 'main'

fix in rewarding for network being down

See merge request flarenetwork/ftso/ftso-scaling!162

Author: adg-flare

libs/fsp-rewards/src/DataManagerForRewarding.ts

@@ -759,11 +759,12 @@ export class DataManagerForRewarding extends DataManager {
         throw new Error(`FastUpdateFeeds is undefined for voting round ${votingRoundId}`);
       }
 
-      if ((fastUpdateFeeds as any) === "CONTRACT_CHANGE") {
+      if ((fastUpdateFeeds as any) === "MISSING_FAST_UPDATE_FEEDS") {
         result.push(undefined);
-        this.logger.error(`WARN: FastUpdateFeeds contract change for voting round ${votingRoundId}`);
+        this.logger.error(`WARN: FastUpdateFeeds missing for voting round ${votingRoundId}`);
         continue;
       }
+
       const value: FastUpdatesDataForVotingRound = {
         votingRoundId,
         feedValues: fastUpdateFeeds.feeds,

libs/fsp-rewards/src/IndexerClientForRewarding.ts

@@ -221,6 +221,15 @@ export class IndexerClientForRewarding extends IndexerClient {
 
     const data: FastUpdateFeeds[] = [];
     let processed = -1;
+    // The batch is fully devoid of FastUpdateFeeds events
+    if (result.length === 0) {
+      this.logger.error(`Missing FastUpdateFeeds events: ${startVotingRoundId} to ${endVotingRoundId}`);
+
+      for (let i = startVotingRoundId; i <= endVotingRoundId; i++) {
+        data.push("MISSING_FAST_UPDATE_FEEDS" as any);
+      }
+      processed = endVotingRoundId;
+    }
     for (let i = 0; i < result.length; i++) {
       const event = FastUpdateFeeds.fromRawEvent(result[i]);
       // queryEvents returns blockchain chronologically ordered events
@@ -229,28 +238,40 @@ export class IndexerClientForRewarding extends IndexerClient {
           data.push(event);
           processed = event.votingRoundId;
         } else {
-          // On Coston one event is missing hence special handling
-          if (network == "coston" && processed + 1 == COSTON_FAST_UPDATER_SWITCH_VOTING_ROUND_ID) {
-            while (processed + 1 < event.votingRoundId) {
-              this.logger.error(`Missing FastUpdateFeeds event for Coston: ${processed + 1}`);
-              data.push("CONTRACT_CHANGE" as any);
-              processed++;
-            }
-            data.push(event);
+          // Gaps in events
+          let start = -1;
+          // no first voting round event
+          if (processed === -1) {
+            processed = startVotingRoundId - 1;
+          }
+          // remember the start position for logging
+          if (processed + 1 < event.votingRoundId) {
+            start = processed + 1;
+          }
+          // jump over missing events
+          while (processed + 1 < event.votingRoundId) {
+            data.push("MISSING_FAST_UPDATE_FEEDS" as any);
             processed++;
-            continue;
           }
-          throw new Error(
-            `FastUpdateFeeds events are not continuous from ${startVotingRoundId} to ${endVotingRoundId}: expected ${processed + 1
-            }, got ${event.votingRoundId}`
-          );
+          // one error log for the whole gap
+          if (start !== -1) {
+            this.logger.error(
+              `Missing FastUpdateFeeds events (gap): ${start} to ${event.votingRoundId - 1}`
+            );
+          }
+          data.push(event);
+          processed++;
+          continue;
         }
       }
     }
     if (processed !== endVotingRoundId) {
-      throw new Error(
-        `Cannot get all FastUpdateFeeds events from ${startVotingRoundId} to ${endVotingRoundId}: last processed ${processed}`
-      );
+      // process the gap at the end of the range
+      this.logger.error(`Missing FastUpdateFeeds events (end gap): ${processed + 1} to ${endVotingRoundId}`);
+      while (processed !== endVotingRoundId) {
+        data.push("MISSING_FAST_UPDATE_FEEDS" as any);
+        processed++;
+      }
     }
     return {
       status,
@@ -419,11 +440,11 @@ export class IndexerClientForRewarding extends IndexerClient {
     // strictly containing in the range
     const endTime = EPOCH_SETTINGS().votingEpochStartSec(endVotingRoundId + 1) - 1;
     const eventName = FDCInflationRewardsOffered.eventName;
-    const status = await this.ensureEventRange(startTime, endTime);    
+    const status = await this.ensureEventRange(startTime, endTime);
     if (status !== BlockAssuranceResult.OK) {
       return { status };
     }
-    const result = await this.queryEvents(CONTRACTS.FdcHub, eventName, startTime, endTime);    
+    const result = await this.queryEvents(CONTRACTS.FdcHub, eventName, startTime, endTime);
     const data = result.map(event => FDCInflationRewardsOffered.fromRawEvent(event));
     return {
       status,

libs/fsp-rewards/src/reward-calculation/reward-calculation.ts

@@ -241,10 +241,10 @@ export async function partialRewardClaimsForVotingRound(
       }
     }
   }
-  const network = process.env.NETWORK;
-  const isContractChange = network == "coston" && votingRoundId == 779191;
+  const isMissingFastUpdateFeeds = data.fastUpdatesData === undefined;
 
-  if (useFastUpdatesData && isContractChange) {
+  if (useFastUpdatesData && isMissingFastUpdateFeeds) {
+    logger.error(`WARN: Missing FastUpdateFeeds event for ${votingRoundId}`);
     const fuFeedOffers = deserializeGranulatedPartialOfferMapForFastUpdates(
       rewardEpochId,
       votingRoundId,
@@ -261,15 +261,15 @@ export async function partialRewardClaimsForVotingRound(
           // feedId: offer.feedId,  // should be undefined
           protocolTag: "" + FTSO2_FAST_UPDATES_PROTOCOL_ID,
           rewardTypeTag: RewardTypePrefix.FULL_OFFER_CLAIM_BACK,
-          rewardDetailTag: FastUpdatesRewardClaimType.CONTRACT_CHANGE,
+          rewardDetailTag: FastUpdatesRewardClaimType.MISSING_FAST_UPDATE_FEEDS,
         });
       }
     }
     if (merge) {
       allRewardClaims = RewardClaim.merge(allRewardClaims);
     }
   }
-  if (useFastUpdatesData && !isContractChange) {
+  if (useFastUpdatesData && !isMissingFastUpdateFeeds) {
     const fuFeedOffers = deserializeGranulatedPartialOfferMapForFastUpdates(
       rewardEpochId,
       votingRoundId,

libs/fsp-rewards/src/reward-calculation/reward-fast-updates.ts

@@ -15,7 +15,7 @@ export enum FastUpdatesRewardClaimType {
   MISSED_BAND = "MISSING_BAND",
   FEE = "FEE",
   PARTICIPATION = "PARTICIPATION",
-  CONTRACT_CHANGE = "CONTRACT_CHANGE",
+  MISSING_FAST_UPDATE_FEEDS = "MISSING_FAST_UPDATE_FEEDS",
 }
 
 /**

scripts/rewards/README.md

@@ -244,7 +244,7 @@ When finalizing the following [reward detail tags](../../libs/fsp-rewards/src/re
 - `MISSED_BAND` - burn claim for total voting round rewards, when the benchmark fast update price misses the prescribed band around the FTSO scaling price for specific voting round. 
 - `FEE` - fee part of the reward claim of a data provider.
 - `PARTICIPATION` - community reward for delegators earned by a data provider.
-- `CONTRACT_CHANGE` - special case, happening only when changing FastUpdater smart contract if a version of it is not available, so system is temporarily unusable, hence the rewards for specific voting round(s) get burned. 
+- `MISSING_FAST_UPDATE_FEEDS` - special case, when network is down and no FastUpdateFeeds events are available.
 
 ## Reward calculation and data