[ci] Added a test for zeroed balance values in bft scan connection.

Also added release notes.

Signed-off-by: Raymond Roestenburg <[email protected]>

Author: ray-roestenburg-da

apps/scan/src/main/scala/org/lfdecentralizedtrust/splice/scan/admin/api/client/SingleScanConnection.scala

@@ -99,6 +99,8 @@ class SingleScanConnection private[client] (
     with ScanConnection
     with BackfillingScanConnection
     with HasUrl {
+  import ScanRoundAggregatesDecoder.*
+
   def url = config.adminApi.url
 
   // cached DSO reference. Never changes.
@@ -392,64 +394,6 @@ class SingleScanConnection private[client] (
     }
   }
 
-  private def decodeRoundTotal(
-      rt: org.lfdecentralizedtrust.splice.http.v0.definitions.RoundTotals
-  ): Either[String, ScanAggregator.RoundTotals] = {
-    (for {
-      closedRoundEffectiveAt <- CantonTimestamp.fromInstant(rt.closedRoundEffectiveAt.toInstant)
-      appRewards <- Codec.decode(Codec.BigDecimal)(rt.appRewards)
-      validatorRewards <- Codec.decode(Codec.BigDecimal)(rt.validatorRewards)
-      cumulativeAppRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeAppRewards)
-      cumulativeValidatorRewards <- Codec
-        .decode(Codec.BigDecimal)(rt.cumulativeValidatorRewards)
-    } yield {
-      // changeToInitialAmountAsOfRoundZero, changeToHoldingFeesRate, cumulativeChangeToInitialAmountAsOfRoundZero,
-      // cumulativeChangeToHoldingFeesRate and totalAmuletBalance are intentionally left out
-      // since these do not match up anymore because amulet expires are attributed to the closed round at a later stage
-      // in scan_txlog_store, at a time that can easily differ between SVs.
-      ScanAggregator.RoundTotals(
-        closedRound = rt.closedRound,
-        closedRoundEffectiveAt = closedRoundEffectiveAt,
-        appRewards = appRewards,
-        validatorRewards = validatorRewards,
-        cumulativeAppRewards = cumulativeAppRewards,
-        cumulativeValidatorRewards = cumulativeValidatorRewards,
-      )
-    })
-  }
-
-  private def decodeRoundPartyTotals(
-      rt: org.lfdecentralizedtrust.splice.http.v0.definitions.RoundPartyTotals
-  ): Either[String, ScanAggregator.RoundPartyTotals] = {
-    (for {
-      appRewards <- Codec.decode(Codec.BigDecimal)(rt.appRewards)
-      validatorRewards <- Codec.decode(Codec.BigDecimal)(rt.validatorRewards)
-      trafficPurchasedCcSpent <- Codec.decode(Codec.BigDecimal)(rt.trafficPurchasedCcSpent)
-      cumulativeAppRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeAppRewards)
-      cumulativeValidatorRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeValidatorRewards)
-      cumulativeTrafficPurchasedCcSpent <- Codec
-        .decode(Codec.BigDecimal)(rt.cumulativeTrafficPurchasedCcSpent)
-    } yield {
-      // cumulativeChangeToInitialAmountAsOfRoundZero and cumulativeChangeToHoldingFeesRate are intentionally left out
-      // since these do not match up anymore because amulet expires are attributed to the closed round at a later stage
-      // in scan_txlog_store, at a time that can easily differ between SVs.
-      ScanAggregator.RoundPartyTotals(
-        closedRound = rt.closedRound,
-        party = rt.party,
-        appRewards = appRewards,
-        validatorRewards = validatorRewards,
-        trafficPurchased = rt.trafficPurchased,
-        trafficPurchasedCcSpent = trafficPurchasedCcSpent,
-        trafficNumPurchases = rt.trafficNumPurchases,
-        cumulativeAppRewards = cumulativeAppRewards,
-        cumulativeValidatorRewards = cumulativeValidatorRewards,
-        cumulativeTrafficPurchased = rt.cumulativeTrafficPurchased,
-        cumulativeTrafficPurchasedCcSpent = cumulativeTrafficPurchasedCcSpent,
-        cumulativeTrafficNumPurchases = rt.cumulativeTrafficNumPurchases,
-      )
-    })
-  }
-
   override def getMigrationSchedule()(implicit
       ec: ExecutionContext,
       tc: TraceContext,
@@ -866,3 +810,63 @@ class CachedScanConnection private[client] (
     )
   )
 }
+
+object ScanRoundAggregatesDecoder {
+  def decodeRoundTotal(
+      rt: org.lfdecentralizedtrust.splice.http.v0.definitions.RoundTotals
+  ): Either[String, ScanAggregator.RoundTotals] = {
+    (for {
+      closedRoundEffectiveAt <- CantonTimestamp.fromInstant(rt.closedRoundEffectiveAt.toInstant)
+      appRewards <- Codec.decode(Codec.BigDecimal)(rt.appRewards)
+      validatorRewards <- Codec.decode(Codec.BigDecimal)(rt.validatorRewards)
+      cumulativeAppRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeAppRewards)
+      cumulativeValidatorRewards <- Codec
+        .decode(Codec.BigDecimal)(rt.cumulativeValidatorRewards)
+    } yield {
+      // changeToInitialAmountAsOfRoundZero, changeToHoldingFeesRate, cumulativeChangeToInitialAmountAsOfRoundZero,
+      // cumulativeChangeToHoldingFeesRate and totalAmuletBalance are intentionally left out
+      // since these do not match up anymore because amulet expires are attributed to the closed round at a later stage
+      // in scan_txlog_store, at a time that can easily differ between SVs.
+      ScanAggregator.RoundTotals(
+        closedRound = rt.closedRound,
+        closedRoundEffectiveAt = closedRoundEffectiveAt,
+        appRewards = appRewards,
+        validatorRewards = validatorRewards,
+        cumulativeAppRewards = cumulativeAppRewards,
+        cumulativeValidatorRewards = cumulativeValidatorRewards,
+      )
+    })
+  }
+
+  def decodeRoundPartyTotals(
+      rt: org.lfdecentralizedtrust.splice.http.v0.definitions.RoundPartyTotals
+  ): Either[String, ScanAggregator.RoundPartyTotals] = {
+    (for {
+      appRewards <- Codec.decode(Codec.BigDecimal)(rt.appRewards)
+      validatorRewards <- Codec.decode(Codec.BigDecimal)(rt.validatorRewards)
+      trafficPurchasedCcSpent <- Codec.decode(Codec.BigDecimal)(rt.trafficPurchasedCcSpent)
+      cumulativeAppRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeAppRewards)
+      cumulativeValidatorRewards <- Codec.decode(Codec.BigDecimal)(rt.cumulativeValidatorRewards)
+      cumulativeTrafficPurchasedCcSpent <- Codec
+        .decode(Codec.BigDecimal)(rt.cumulativeTrafficPurchasedCcSpent)
+    } yield {
+      // cumulativeChangeToInitialAmountAsOfRoundZero and cumulativeChangeToHoldingFeesRate are intentionally left out
+      // since these do not match up anymore because amulet expires are attributed to the closed round at a later stage
+      // in scan_txlog_store, at a time that can easily differ between SVs.
+      ScanAggregator.RoundPartyTotals(
+        closedRound = rt.closedRound,
+        party = rt.party,
+        appRewards = appRewards,
+        validatorRewards = validatorRewards,
+        trafficPurchased = rt.trafficPurchased,
+        trafficPurchasedCcSpent = trafficPurchasedCcSpent,
+        trafficNumPurchases = rt.trafficNumPurchases,
+        cumulativeAppRewards = cumulativeAppRewards,
+        cumulativeValidatorRewards = cumulativeValidatorRewards,
+        cumulativeTrafficPurchased = rt.cumulativeTrafficPurchased,
+        cumulativeTrafficPurchasedCcSpent = cumulativeTrafficPurchasedCcSpent,
+        cumulativeTrafficNumPurchases = rt.cumulativeTrafficNumPurchases,
+      )
+    })
+  }
+}

apps/scan/src/test/scala/org/lfdecentralizedtrust/splice/scan/admin/api/client/BftScanConnectionTest.scala

@@ -29,7 +29,11 @@ import org.lfdecentralizedtrust.splice.environment.{
   RetryProvider,
   SpliceLedgerClient,
 }
-import org.lfdecentralizedtrust.splice.http.v0.definitions.ErrorResponse
+import org.lfdecentralizedtrust.splice.http.v0.definitions.{
+  ErrorResponse,
+  RoundPartyTotals as HttpRoundPartyTotals,
+  RoundTotals as HttpRoundTotals,
+}
 import org.lfdecentralizedtrust.splice.scan.admin.api.client.BftScanConnection.Bft
 import org.lfdecentralizedtrust.splice.scan.admin.api.client.commands.HttpScanAppClient.{
   DomainScans,
@@ -40,6 +44,7 @@ import org.lfdecentralizedtrust.splice.store.HistoryBackfilling.SourceMigrationI
 import org.lfdecentralizedtrust.splice.store.MultiDomainAcsStore.ContractState
 import org.lfdecentralizedtrust.splice.store.UpdateHistory.UpdateHistoryResponse
 import org.lfdecentralizedtrust.splice.util.{
+  Codec,
   Contract,
   ContractWithState,
   DomainRecordTimeRange,
@@ -54,6 +59,7 @@ import org.slf4j.event.Level
 import java.time.{Duration, Instant}
 import java.util.concurrent.atomic.AtomicInteger
 import scala.concurrent.{ExecutionContext, Future}
+import scala.util.Random
 
 // mock verification triggers this
 @SuppressWarnings(Array("com.digitalasset.canton.DiscardedFuture"))
@@ -922,6 +928,126 @@ class BftScanConnectionTest
       result shouldBe Some(roundAggregate)
     }
 
+    "get BFT round aggregates from scans that report having the round aggregate ignoring balance fields" in {
+      val round = 0L
+      def randomValue = BigDecimal(Random.nextInt(50) + 1)
+      def mkRoundTotals() = RoundTotals(
+        closedRound = round,
+        closedRoundEffectiveAt = CantonTimestamp.MinValue,
+        appRewards = BigDecimal(100),
+        validatorRewards = BigDecimal(150),
+        changeToInitialAmountAsOfRoundZero = randomValue,
+        changeToHoldingFeesRate = randomValue,
+        cumulativeAppRewards = BigDecimal(1100),
+        cumulativeValidatorRewards = BigDecimal(1150),
+        cumulativeChangeToInitialAmountAsOfRoundZero = randomValue,
+        cumulativeChangeToHoldingFeesRate = randomValue,
+        totalAmuletBalance = randomValue,
+      )
+      def encodeRoundTotals(rt: RoundTotals) = {
+        HttpRoundTotals(
+          closedRound = rt.closedRound,
+          closedRoundEffectiveAt = Codec.OffsetDateTime.instance.encode(rt.closedRoundEffectiveAt),
+          appRewards = Codec.encode(rt.appRewards),
+          validatorRewards = Codec.encode(rt.validatorRewards),
+          changeToInitialAmountAsOfRoundZero = Codec.encode(rt.changeToInitialAmountAsOfRoundZero),
+          changeToHoldingFeesRate = Codec.encode(rt.changeToHoldingFeesRate),
+          cumulativeAppRewards = Codec.encode(rt.cumulativeAppRewards),
+          cumulativeValidatorRewards = Codec.encode(rt.cumulativeValidatorRewards),
+          cumulativeChangeToInitialAmountAsOfRoundZero =
+            Codec.encode(rt.cumulativeChangeToInitialAmountAsOfRoundZero),
+          cumulativeChangeToHoldingFeesRate = Codec.encode(rt.cumulativeChangeToHoldingFeesRate),
+          totalAmuletBalance = Codec.encode(rt.totalAmuletBalance),
+        )
+      }
+      def encodeRoundPartyTotals(rpt: RoundPartyTotals) = {
+        HttpRoundPartyTotals(
+          closedRound = rpt.closedRound,
+          party = rpt.party,
+          appRewards = Codec.encode(rpt.appRewards),
+          validatorRewards = Codec.encode(rpt.validatorRewards),
+          trafficPurchased = rpt.trafficPurchased,
+          trafficPurchasedCcSpent = Codec.encode(rpt.trafficPurchasedCcSpent),
+          trafficNumPurchases = rpt.trafficNumPurchases,
+          cumulativeAppRewards = Codec.encode(rpt.cumulativeAppRewards),
+          cumulativeValidatorRewards = Codec.encode(rpt.cumulativeValidatorRewards),
+          cumulativeChangeToInitialAmountAsOfRoundZero =
+            Codec.encode(rpt.cumulativeChangeToInitialAmountAsOfRoundZero),
+          cumulativeChangeToHoldingFeesRate = Codec.encode(rpt.cumulativeChangeToHoldingFeesRate),
+          cumulativeTrafficPurchased = rpt.cumulativeTrafficPurchased,
+          cumulativeTrafficPurchasedCcSpent = Codec.encode(rpt.cumulativeTrafficPurchasedCcSpent),
+          cumulativeTrafficNumPurchases = rpt.cumulativeTrafficNumPurchases,
+        )
+      }
+      def mkRoundPartyTotals() = RoundPartyTotals(
+        closedRound = round,
+        party = "party-id",
+        appRewards = BigDecimal(10),
+        validatorRewards = BigDecimal(20),
+        trafficPurchased = 10L,
+        trafficPurchasedCcSpent = BigDecimal(30),
+        trafficNumPurchases = 30L,
+        cumulativeAppRewards = BigDecimal(40),
+        cumulativeValidatorRewards = BigDecimal(50),
+        cumulativeChangeToInitialAmountAsOfRoundZero = randomValue,
+        cumulativeChangeToHoldingFeesRate = randomValue,
+        cumulativeTrafficPurchased = 50L,
+        cumulativeTrafficPurchasedCcSpent = BigDecimal(70),
+        cumulativeTrafficNumPurchases = 70L,
+      )
+      def mkRoundAggregateUsingDecoder() = RoundAggregate(
+        ScanRoundAggregatesDecoder.decodeRoundTotal(encodeRoundTotals(mkRoundTotals())).value,
+        Vector(
+          ScanRoundAggregatesDecoder
+            .decodeRoundPartyTotals(encodeRoundPartyTotals(mkRoundPartyTotals()))
+            .value
+        ),
+      )
+      def mkRoundAggregateWithoutDecoder() = RoundAggregate(
+        mkRoundTotals(),
+        Vector(mkRoundPartyTotals()),
+      )
+      val roundAggregateZeroBalanceValues = mkRoundAggregateWithoutDecoder().copy(
+        roundTotals = mkRoundAggregateWithoutDecoder().roundTotals.copy(
+          changeToInitialAmountAsOfRoundZero = zero,
+          changeToHoldingFeesRate = zero,
+          cumulativeChangeToInitialAmountAsOfRoundZero = zero,
+          cumulativeChangeToHoldingFeesRate = zero,
+          totalAmuletBalance = zero,
+        ),
+        roundPartyTotals = mkRoundAggregateWithoutDecoder().roundPartyTotals.map(
+          _.copy(
+            cumulativeChangeToInitialAmountAsOfRoundZero = zero,
+            cumulativeChangeToHoldingFeesRate = zero,
+          )
+        ),
+      )
+
+      def getConnections(roundAggregateResponse: () => RoundAggregate) = {
+        val connections = getMockedConnections(n = 10)
+        connections.foreach { mock =>
+          when(mock.getAggregatedRounds())
+            .thenReturn(Future.successful(Some(RoundRange(round, round))))
+          when(mock.getRoundAggregate(round))
+            .thenReturn(Future.successful(Some(roundAggregateResponse())))
+        }
+        connections
+      }
+
+      val bft = getBft(getConnections(() => mkRoundAggregateUsingDecoder()))
+      val con =
+        new ScanAggregatesConnection(bft, retryProvider, retryProvider.loggerFactory)
+      val result = con.getRoundAggregate(round).futureValue
+      result shouldBe Some(roundAggregateZeroBalanceValues)
+
+      // not using the decoder should fail on the randomized balance values.
+      val bftFail = getBft(getConnections(() => mkRoundAggregateWithoutDecoder()))
+      val conFail =
+        new ScanAggregatesConnection(bftFail, retryProvider, retryProvider.loggerFactory)
+      val resultFail = conFail.getRoundAggregate(round).failed.futureValue
+      resultFail shouldBe an[BftScanConnection.ConsensusNotReached]
+    }
+
     "Not get round aggregates from scans that report having the round aggregate if too many fail" in {
       val connections = getMockedConnections(n = 10)
       connections.zipWithIndex.foreach { case (mock, index) =>

docs/src/release_notes.rst

@@ -24,6 +24,13 @@ Upcoming
 
   - Fix bug that caused validators to fail on restoring participant users without rights during a synchronizer migration.
 
+- Scan
+
+  - The round-based aggregates for balance values (changes to holding fees and initial amounts since round zero)
+    have diverged between scans because of how amulets expire in the ``scan_txlog_store``.
+    The balance values recorded in the round aggregates are effectively not used anymore, and are now set to zero to avoid consensus problems when an SV reads aggregates
+    from the rest of the network.
+
 0.5.1
 -----