Fix merging of ValidatorLicenses

Signed-off-by: Divam <[email protected]>

Author: dfordivam

daml/splice-dso-governance-test/daml/Splice/Scripts/TestOnboarding.daml

@@ -589,6 +589,157 @@ test_MergeValidatorLicense = do
   [(validatorLicenseSv2Cid, _)] <- queryFilter @ValidatorLicense dso (\license -> license.validator == sv2)
   submitMultiMustFail [sv1] [dso] $ exerciseCmd rulesCid (DsoRules_MergeValidatorLicense [validatorLicenseCid3, validatorLicenseSv2Cid] (Some sv1))
 
+  -- Test weight merging: min weight should be used
+  v2 <- allocateParty "v2"
+  validatorLicenseW1 <- submit dso $ createCmd ValidatorLicense with
+    validator = v2
+    sponsor = sv1
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 1
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some OperatorLicense
+
+  validatorLicenseW2 <- submit dso $ createCmd ValidatorLicense with
+    validator = v2
+    sponsor = sv2
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 3
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = Some 2.0
+    kind = Some OperatorLicense
+
+  validatorLicenseW3 <- submit dso $ createCmd ValidatorLicense with
+    validator = v2
+    sponsor = sv1
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 2
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = Some 1.5
+    kind = Some OperatorLicense
+
+  DsoRules_MergeValidatorLicenseResult mergedWeightLicense <- submitMulti [sv1] [dso] $ exerciseCmd rulesCid (DsoRules_MergeValidatorLicense [validatorLicenseW1, validatorLicenseW2, validatorLicenseW3] (Some sv1))
+  [(_, mergedLicense)] <- queryFilter @ValidatorLicense dso (\license -> license.validator == v2)
+  -- The merged license should have the minimum weight (0.5) and the highest lastReceivedFor (Round 3)
+  mergedLicense.weight === Some 1.5
+  mergedLicense.faucetState === Some FaucetState with
+    firstReceivedFor = Round 0
+    lastReceivedFor = Round 3
+    numCouponsMissed = 0
+
+  -- Test kind merging: Some OperatorLicense if any license has None or Some OperatorLicense
+  v3 <- allocateParty "v3"
+
+  -- Test case 1: mixing None and Some NonOperatorLicense -> should result in Some OperatorLicense
+  validatorLicenseK1 <- submit dso $ createCmd ValidatorLicense with
+    validator = v3
+    sponsor = sv1
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 1
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = None  -- None should be treated as OperatorLicense
+
+  validatorLicenseK2 <- submit dso $ createCmd ValidatorLicense with
+    validator = v3
+    sponsor = sv2
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 2
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some NonOperatorLicense
+
+  DsoRules_MergeValidatorLicenseResult mergedKind1 <- submitMulti [sv1] [dso] $ exerciseCmd rulesCid (DsoRules_MergeValidatorLicense [validatorLicenseK1, validatorLicenseK2] (Some sv1))
+  [(_, mergedLicense1)] <- queryFilter @ValidatorLicense dso (\license -> license.validator == v3)
+  -- Should be OperatorLicense because one license had None
+  mergedLicense1.kind === Some OperatorLicense
+
+  -- Test case 2: mixing Some OperatorLicense and Some NonOperatorLicense -> should result in Some OperatorLicense
+  v4 <- allocateParty "v4"
+  validatorLicenseK3 <- submit dso $ createCmd ValidatorLicense with
+    validator = v4
+    sponsor = sv1
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 1
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some OperatorLicense
+
+  validatorLicenseK4 <- submit dso $ createCmd ValidatorLicense with
+    validator = v4
+    sponsor = sv2
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 2
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some NonOperatorLicense
+
+  DsoRules_MergeValidatorLicenseResult mergedKind2 <- submitMulti [sv1] [dso] $ exerciseCmd rulesCid (DsoRules_MergeValidatorLicense [validatorLicenseK3, validatorLicenseK4] (Some sv1))
+  [(_, mergedLicense2)] <- queryFilter @ValidatorLicense dso (\license -> license.validator == v4)
+  -- Should be OperatorLicense to prevent downgrading
+  mergedLicense2.kind === Some OperatorLicense
+
+  -- Test case 3: all licenses are Some NonOperatorLicense -> should result in Some NonOperatorLicense
+  v5 <- allocateParty "v5"
+  validatorLicenseK5 <- submit dso $ createCmd ValidatorLicense with
+    validator = v5
+    sponsor = sv1
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 1
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some NonOperatorLicense
+
+  validatorLicenseK6 <- submit dso $ createCmd ValidatorLicense with
+    validator = v5
+    sponsor = sv2
+    dso
+    faucetState = Some FaucetState with
+      firstReceivedFor = Round 0
+      lastReceivedFor = Round 2
+      numCouponsMissed = 0
+    metadata = None
+    lastActiveAt = Some now
+    weight = None
+    kind = Some NonOperatorLicense
+
+  DsoRules_MergeValidatorLicenseResult mergedKind3 <- submitMulti [sv1] [dso] $ exerciseCmd rulesCid (DsoRules_MergeValidatorLicense [validatorLicenseK5, validatorLicenseK6] (Some sv1))
+  [(_, mergedLicense3)] <- queryFilter @ValidatorLicense dso (\license -> license.validator == v5)
+  -- Should be NonOperatorLicense since all licenses are NonOperatorLicense
+  mergedLicense3.kind === Some NonOperatorLicense
+
   pure()
 
 testBootstrapDevNetWithNonZeroRound : Script ()

daml/splice-dso-governance/daml/Splice/DsoRules.daml

@@ -9,9 +9,9 @@ import DA.Action (void, unless)
 import DA.Assert
 import DA.Either (partitionEithers)
 import DA.Exception
-import DA.Foldable (forA_, all)
+import DA.Foldable (forA_, all, minimum)
 import DA.List as List hiding (all)
-import DA.Optional (isNone, fromSome, fromOptional, isSome)
+import DA.Optional (isNone, fromSome, fromOptional, isSome, catOptionals)
 import qualified DA.Map as Map
 import qualified DA.Set as Set
 import qualified DA.Text as T
@@ -986,14 +986,16 @@ template DsoRules with
           kind = Some OperatorLicense
         return DsoRules_OnboardValidatorResult with ..
 
+    -- Grant ValidatorLicense to a party that is not an validator node operator
+    ---------------------------------------------------------------------------
+
     nonconsuming choice DsoRules_GrantValidatorLicense : DsoRules_GrantValidatorLicenseResult
       with
         sponsor : Party
         validator : Party
       controller sponsor
       do
         require "Sponsor is an SV" (sponsor `Map.member` svs)
-        -- create license for a validator that is not an operator
         now <- getTime
         validatorLicense <- create ValidatorLicense with
           dso
@@ -1007,7 +1009,10 @@ template DsoRules with
         return DsoRules_GrantValidatorLicenseResult with ..
 
     nonconsuming choice DsoRules_MergeValidatorLicense : DsoRules_MergeValidatorLicenseResult
-      -- ^ Note: removes the old duplicated licenses and creates a new one with the highest lastReceivedFor round
+      -- ^ Note: removes the old duplicated licenses and creates a new one with merged fields:
+      -- - lastReceivedFor: max value among all licenses
+      -- - weight: min value among all licenses
+      -- - kind: Some OperatorLicense if any license has None or Some OperatorLicense
       -- There should never be duplicates going forward.
       with
         validatorLicenseCids : [ContractId ValidatorLicense]
@@ -1017,13 +1022,30 @@ template DsoRules with
          require "Number of validatorLicense contracts to merge is >= 2" (length validatorLicenseCids >= 2)
          validatorLicenses <- forA validatorLicenseCids $ fetchAndArchive (ForDso this.dso)
          require "All validatorLicenses map to the same validator" ( length (dedup (map (.validator) validatorLicenses)) == 1)
-         -- We don't attempt to merge the fields in the validator licence since there is no good
-         -- way to do so and none of the fields other than lastReceivedFor round are crucial and for that
-         -- taking the max is the correct merge.
-         cid <- create $ maximumOn (\license ->
+
+         -- Merge the licenses:
+         -- 1. Use the max lastReceivedFor for faucetState (take the license with max lastReceivedFor as base)
+         -- 2. Use the min weight (treating None as 1.0)
+         -- 3. Use Some OperatorLicense for kind if any license has None or Some OperatorLicense
+         let baseLicense = maximumOn (\license ->
                      case license.faucetState of
                          None    -> Round 0
                          Some r  -> r.lastReceivedFor) validatorLicenses
+
+         -- Calculate merged weight: use minimum weight among all licenses, or None if all are None
+         let weights = catOptionals $ map (.weight) validatorLicenses
+         let mergedWeight = if null weights then None else Some (minimum weights)
+
+         -- Calculate merged kind: use OperatorLicense if any license has None or Some OperatorLicense
+         let hasOperatorLicense license =
+               isNone license.kind || license.kind == Some OperatorLicense
+         let mergedKind = if any hasOperatorLicense validatorLicenses
+                          then Some OperatorLicense
+                          else Some NonOperatorLicense
+
+         cid <- create baseLicense with
+           weight = mergedWeight
+           kind = mergedKind
          pure $ DsoRules_MergeValidatorLicenseResult cid
 
     -- SV onboarding