Merge pull request #9687 from vegaprotocol/add-and-cache-referral-stats

feat: cache and forward referral rewards multiplier and factor multplier

CHANGELOG.md

@@ -35,6 +35,7 @@
 - [8857](https://github.com/vegaprotocol/vega/issues/8857) - Add a step for getting the balance of the liquidity provider liquidity fee account
 - [8847](https://github.com/vegaprotocol/vega/issues/8847) - Implement internal time trigger data source.
 - [8895](https://github.com/vegaprotocol/vega/issues/8895) - Allow to set runtime parameters in the SQL Store connection structure
+- [9678](https://github.com/vegaprotocol/vega/issues/9678) - Cache and forward referral rewards multiplier and factor multiplier 
 - [8779](https://github.com/vegaprotocol/vega/issues/8779) - Query all details of liquidity providers via an API.
 - [8924](https://github.com/vegaprotocol/vega/issues/8924) - Refactor slightly to remove need to deep clone `proto` types
 - [8782](https://github.com/vegaprotocol/vega/issues/8782) - List all active liquidity providers for a market via API.

core/events/referral_set.go

@@ -55,9 +55,12 @@ func (t ReferralSetStatsUpdated) Unwrap() *types.ReferralSetStats {
 	volume, _ := num.UintFromString(t.e.ReferralSetRunningNotionalTakerVolume, 10)
 	stats := map[types.PartyID]*types.RefereeStats{}
 	rewardFactor, _ := num.DecimalFromString(t.e.RewardFactor)
+	rewardsMultiplier, _ := num.DecimalFromString(t.e.RewardsMultiplier)
+	rewardsFactorMultiplier, _ := num.DecimalFromString(t.e.RewardsFactorMultiplier)
 
 	for _, stat := range t.e.RefereesStats {
 		discountFactor, _ := num.DecimalFromString(stat.DiscountFactor)
+
 		stats[types.PartyID(stat.PartyId)] = &types.RefereeStats{
 			DiscountFactor: discountFactor,
 		}
@@ -69,6 +72,8 @@ func (t ReferralSetStatsUpdated) Unwrap() *types.ReferralSetStats {
 		ReferralSetRunningVolume: volume,
 		RefereesStats:            stats,
 		RewardFactor:             rewardFactor,
+		RewardsMultiplier:        rewardsMultiplier,
+		RewardsFactorMultiplier:  rewardsFactorMultiplier,
 	}
 }
 
@@ -107,6 +112,8 @@ func NewReferralSetStatsUpdatedEvent(ctx context.Context, update *types.Referral
 			ReferralSetRunningNotionalTakerVolume: update.ReferralSetRunningVolume.String(),
 			RefereesStats:                         refereesStats,
 			RewardFactor:                          update.RewardFactor.String(),
+			RewardsMultiplier:                     update.RewardsMultiplier.String(),
+			RewardsFactorMultiplier:               update.RewardsFactorMultiplier.String(),
 		},
 	}
 }

core/referral/engine.go

@@ -145,7 +145,9 @@ func (e *Engine) CreateReferralSet(ctx context.Context, party types.PartyID, det
 			JoinedAt:       now,
 			StartedAtEpoch: e.currentEpoch,
 		},
-		CurrentRewardFactor: num.DecimalZero(),
+		CurrentRewardFactor:            num.DecimalZero(),
+		CurrentRewardsMultiplier:       num.DecimalZero(),
+		CurrentRewardsFactorMultiplier: num.DecimalZero(),
 	}
 
 	e.sets[deterministicSetID] = &newSet
@@ -260,44 +262,21 @@ func (e *Engine) RewardsFactorForParty(party types.PartyID) num.Decimal {
 }
 
 func (e *Engine) RewardsFactorMultiplierAppliedForParty(party types.PartyID) num.Decimal {
-	return num.MinD(
-		e.RewardsFactorForParty(party).Mul(e.RewardsMultiplierForParty(party)),
-		e.rewardProportionUpdate,
-	)
-}
-
-func (e *Engine) RewardsMultiplierForParty(party types.PartyID) num.Decimal {
-	if e.programHasEnded {
+	setID, ok := e.referees[party]
+	if !ok {
 		return num.DecimalZero()
 	}
 
-	setID, isReferee := e.referees[party]
-	if !isReferee {
-		// This party is not eligible to referral program rewards.
-		return num.DecimalZero()
-	}
+	return e.sets[setID].CurrentRewardsFactorMultiplier
+}
 
-	if e.isSetEligible(setID) != nil {
+func (e *Engine) RewardsMultiplierForParty(party types.PartyID) num.Decimal {
+	setID, ok := e.referees[party]
+	if !ok {
 		return num.DecimalZero()
 	}
 
-	balance, _ := e.staking.GetAvailableBalance(
-		string(e.sets[setID].Referrer.PartyID),
-	)
-
-	multiplier := num.DecimalOne()
-	for _, v := range e.currentProgram.StakingTiers {
-		if balance.LTE(v.MinimumStakedTokens) {
-			break
-		}
-		multiplier = v.ReferralRewardMultiplier
-	}
-
-	return multiplier
-}
-
-func (e *Engine) VolumeDiscountFactorForParty(party types.PartyID) num.Decimal {
-	return num.DecimalZero()
+	return e.sets[setID].CurrentRewardsMultiplier
 }
 
 func (e *Engine) OnReferralProgramMaxReferralRewardProportionUpdate(_ context.Context, value num.Decimal) error {
@@ -331,6 +310,33 @@ func (e *Engine) OnEpochRestore(_ context.Context, ep types.Epoch) {
 	}
 }
 
+func (e *Engine) calculateRewardsFactorMultiplierForParty(multiplierForParty, rewardsFactorForParty num.Decimal) num.Decimal {
+	return num.MinD(
+		rewardsFactorForParty.Mul(multiplierForParty),
+		e.rewardProportionUpdate,
+	)
+}
+
+func (e *Engine) calculateMultiplierForParty(setID types.ReferralSetID) num.Decimal {
+	if e.isSetEligible(setID) != nil {
+		return num.DecimalZero()
+	}
+
+	balance, _ := e.staking.GetAvailableBalance(
+		string(e.sets[setID].Referrer.PartyID),
+	)
+
+	multiplier := num.DecimalOne()
+	for _, v := range e.currentProgram.StakingTiers {
+		if balance.LTE(v.MinimumStakedTokens) {
+			break
+		}
+		multiplier = v.ReferralRewardMultiplier
+	}
+
+	return multiplier
+}
+
 func (e *Engine) applyProgramUpdate(ctx context.Context, startEpochTime time.Time) {
 	if e.newProgram != nil {
 		if e.currentProgram != nil {
@@ -420,7 +426,9 @@ func (e *Engine) loadReferralSetsFromSnapshot(setsProto *snapshotpb.ReferralSets
 				JoinedAt:       time.Unix(0, setProto.Referrer.JoinedAt),
 				StartedAtEpoch: setProto.Referrer.StartedAtEpoch,
 			},
-			CurrentRewardFactor: num.MustDecimalFromString(setProto.CurrentRewardFactor),
+			CurrentRewardFactor:            num.MustDecimalFromString(setProto.CurrentRewardFactor),
+			CurrentRewardsMultiplier:       num.MustDecimalFromString(setProto.CurrentRewardsMultiplier),
+			CurrentRewardsFactorMultiplier: num.MustDecimalFromString(setProto.CurrentRewardsFactorMultiplier),
 		}
 
 		e.referrers[types.PartyID(setProto.Referrer.PartyId)] = setID
@@ -510,7 +518,14 @@ func (e *Engine) computeFactorsByReferee(ctx context.Context, epoch uint64, take
 			}
 		}
 
+		rewardsMultiplier := e.calculateMultiplierForParty(setID)
+		set.RewardsMultiplier = rewardsMultiplier
+		set.RewardsFactorMultiplier = e.calculateRewardsFactorMultiplierForParty(rewardsMultiplier, set.RewardFactor)
+
 		e.sets[setID].CurrentRewardFactor = set.RewardFactor
+		e.sets[setID].CurrentRewardsMultiplier = rewardsMultiplier
+		e.sets[setID].CurrentRewardsFactorMultiplier = set.RewardsFactorMultiplier
+
 		allStats[setID] = set
 	}
 

core/referral/snapshot.go

@@ -123,7 +123,9 @@ func (e *SnapshottedEngine) serialiseReferralSets() ([]byte, error) {
 				JoinedAt:       set.Referrer.JoinedAt.UnixNano(),
 				StartedAtEpoch: set.Referrer.StartedAtEpoch,
 			},
-			CurrentRewardFactor: set.CurrentRewardFactor.String(),
+			CurrentRewardFactor:            set.CurrentRewardFactor.String(),
+			CurrentRewardsMultiplier:       set.CurrentRewardsMultiplier.String(),
+			CurrentRewardsFactorMultiplier: set.CurrentRewardsFactorMultiplier.String(),
 		}
 
 		for _, r := range set.Referees {

core/referral/snapshot_test.go

@@ -136,6 +136,7 @@ func TestTakingAndRestoringSnapshotSucceeds(t *testing.T) {
 		te.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee7)).Return(num.UintFromUint64(100)).Times(1)
 		te.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee8)).Return(num.UintFromUint64(100)).Times(1)
 		te.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee9)).Return(num.UintFromUint64(100)).Times(1)
+		te.staking.EXPECT().GetAvailableBalance(gomock.Any()).AnyTimes().Return(num.NewUint(100), nil)
 
 		gomock.InOrder(
 			expectReferralSetStatsUpdatedEvent(t, te, 4),
@@ -198,6 +199,7 @@ func TestTakingAndRestoringSnapshotSucceeds(t *testing.T) {
 	te2.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee7)).Return(num.UintFromUint64(100)).Times(1)
 	te2.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee8)).Return(num.UintFromUint64(100)).Times(1)
 	te2.marketActivityTracker.EXPECT().NotionalTakerVolumeForParty(string(referee9)).Return(num.UintFromUint64(100)).Times(1)
+	te2.staking.EXPECT().GetAvailableBalance(gomock.Any()).AnyTimes().Return(num.NewUint(100), nil)
 	expectReferralSetStatsUpdatedEvent(t, te2, 4)
 	// This triggers the state restoration from the local snapshot.
 	require.NoError(t, snapshotEngine2.Start(ctx))

core/types/referral_set.go

@@ -17,7 +17,9 @@ type ReferralSet struct {
 	Referrer *Membership
 	Referees []*Membership
 
-	CurrentRewardFactor num.Decimal
+	CurrentRewardFactor            num.Decimal
+	CurrentRewardsMultiplier       num.Decimal
+	CurrentRewardsFactorMultiplier num.Decimal
 }
 
 type ReferralSetStats struct {
@@ -26,6 +28,8 @@ type ReferralSetStats struct {
 	ReferralSetRunningVolume *num.Uint
 	RefereesStats            map[PartyID]*RefereeStats
 	RewardFactor             num.Decimal
+	RewardsMultiplier        num.Decimal
+	RewardsFactorMultiplier  num.Decimal
 }
 
 type RefereeStats struct {

datanode/entities/referral_set_stats.go

@@ -16,6 +16,8 @@ type (
 		RefereesStats                         []*eventspb.RefereeStats
 		VegaTime                              time.Time
 		RewardFactor                          string
+		RewardsMultiplier                     string
+		RewardsFactorMultiplier               string
 	}
 
 	FlattenReferralSetStats struct {
@@ -26,6 +28,8 @@ type (
 		DiscountFactor                        string
 		EpochNotionalTakerVolume              string
 		RewardFactor                          string
+		RewardsMultiplier                     string
+		RewardsFactorMultiplier               string
 	}
 
 	ReferralSetStatsCursor struct {
@@ -70,6 +74,8 @@ func (s FlattenReferralSetStats) ToProto() *v2.ReferralSetStats {
 		DiscountFactor:                        s.DiscountFactor,
 		RewardFactor:                          s.RewardFactor,
 		EpochNotionalTakerVolume:              s.EpochNotionalTakerVolume,
+		RewardsMultiplier:                     s.RewardsMultiplier,
+		RewardsFactorMultiplier:               s.RewardsFactorMultiplier,
 	}
 }
 
@@ -93,6 +99,8 @@ func ReferralSetStatsFromProto(proto *eventspb.ReferralSetStatsUpdated, vegaTime
 		RefereesStats:                         proto.RefereesStats,
 		VegaTime:                              vegaTime,
 		RewardFactor:                          proto.RewardFactor,
+		RewardsMultiplier:                     proto.RewardsMultiplier,
+		RewardsFactorMultiplier:               proto.RewardsFactorMultiplier,
 	}, nil
 }