fix x/stats GetStakedAmount and rename to GetStakedBaseTokens (backport #3238) (#3239)

mergify[bot] · tqin7 · web-flow · commit e40fc8cb53b9 · 2025-10-30T19:33:52.000-04:00
Co-authored-by: Tian &lt;tian@dydx.exchange&gt;
diff --git a/indexer/packages/v4-protos/src/codegen/dydxprotocol/stats/stats.ts b/indexer/packages/v4-protos/src/codegen/dydxprotocol/stats/stats.ts
@@ -153,23 +153,23 @@ export interface UserStatsSDKType {
 
   affiliate_30d_referred_volume_quote_quantums: Long;
 }
-/** CachedStakeAmount stores the last calculated total staked amount for address */
+/** CachedStakedBaseTokens stores the last calculated total staked base tokens */
 
-export interface CachedStakeAmount {
-  /** Last calculated total staked amount by the delegator (in coin amount). */
-  stakedAmount: Uint8Array;
+export interface CachedStakedBaseTokens {
+  /** Last calculated total staked base tokens by the delegator. */
+  stakedBaseTokens: Uint8Array;
   /**
    * Block time at which the calculation is cached (in Unix Epoch seconds)
    * Rounded down to nearest second.
    */
 
   cachedAt: Long;
 }
-/** CachedStakeAmount stores the last calculated total staked amount for address */
+/** CachedStakedBaseTokens stores the last calculated total staked base tokens */
 
-export interface CachedStakeAmountSDKType {
-  /** Last calculated total staked amount by the delegator (in coin amount). */
-  staked_amount: Uint8Array;
+export interface CachedStakedBaseTokensSDKType {
+  /** Last calculated total staked base tokens by the delegator. */
+  staked_base_tokens: Uint8Array;
   /**
    * Block time at which the calculation is cached (in Unix Epoch seconds)
    * Rounded down to nearest second.
@@ -573,17 +573,17 @@ export const UserStats = {
 
 };
 
-function createBaseCachedStakeAmount(): CachedStakeAmount {
+function createBaseCachedStakedBaseTokens(): CachedStakedBaseTokens {
   return {
-    stakedAmount: new Uint8Array(),
+    stakedBaseTokens: new Uint8Array(),
     cachedAt: Long.ZERO
   };
 }
 
-export const CachedStakeAmount = {
-  encode(message: CachedStakeAmount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.stakedAmount.length !== 0) {
-      writer.uint32(10).bytes(message.stakedAmount);
+export const CachedStakedBaseTokens = {
+  encode(message: CachedStakedBaseTokens, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.stakedBaseTokens.length !== 0) {
+      writer.uint32(10).bytes(message.stakedBaseTokens);
     }
 
     if (!message.cachedAt.isZero()) {
@@ -593,17 +593,17 @@ export const CachedStakeAmount = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): CachedStakeAmount {
+  decode(input: _m0.Reader | Uint8Array, length?: number): CachedStakedBaseTokens {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseCachedStakeAmount();
+    const message = createBaseCachedStakedBaseTokens();
 
     while (reader.pos < end) {
       const tag = reader.uint32();
 
       switch (tag >>> 3) {
         case 1:
-          message.stakedAmount = reader.bytes();
+          message.stakedBaseTokens = reader.bytes();
           break;
 
         case 2:
@@ -619,9 +619,9 @@ export const CachedStakeAmount = {
     return message;
   },
 
-  fromPartial(object: DeepPartial<CachedStakeAmount>): CachedStakeAmount {
-    const message = createBaseCachedStakeAmount();
-    message.stakedAmount = object.stakedAmount ?? new Uint8Array();
+  fromPartial(object: DeepPartial<CachedStakedBaseTokens>): CachedStakedBaseTokens {
+    const message = createBaseCachedStakedBaseTokens();
+    message.stakedBaseTokens = object.stakedBaseTokens ?? new Uint8Array();
     message.cachedAt = object.cachedAt !== undefined && object.cachedAt !== null ? Long.fromValue(object.cachedAt) : Long.ZERO;
     return message;
   }
diff --git a/proto/dydxprotocol/stats/stats.proto b/proto/dydxprotocol/stats/stats.proto
@@ -75,10 +75,10 @@ message UserStats {
   uint64 affiliate_30d_referred_volume_quote_quantums = 4;
 }
 
-// CachedStakeAmount stores the last calculated total staked amount for address
-message CachedStakeAmount {
-  // Last calculated total staked amount by the delegator (in coin amount).
-  bytes staked_amount = 1 [
+// CachedStakedBaseTokens stores the last calculated total staked base tokens
+message CachedStakedBaseTokens {
+  // Last calculated total staked base tokens by the delegator.
+  bytes staked_base_tokens = 1 [
     (gogoproto.customtype) =
         "github.com/dydxprotocol/v4-chain/protocol/dtypes.SerializableInt",
     (gogoproto.nullable) = false
diff --git a/protocol/lib/metrics/metric_keys.go b/protocol/lib/metrics/metric_keys.go
@@ -27,8 +27,8 @@ const (
 	ClobRateLimitPlaceOrderCount                       = "clob_rate_limit_place_order_count"
 	ClobRateLimitCancelOrderCount                      = "clob_rate_limit_cancel_order_count"
 	ClobRateLimitBatchCancelCount                      = "clob_rate_limit_batch_cancel_count"
-	StatsGetStakedAmountCacheHit                       = "stats_get_staked_amount_cache_hit"
-	StatsGetStakedAmountCacheMiss                      = "stats_get_staked_amount_cache_miss"
+	StatsGetStakedBaseTokensCacheHit                   = "stats_get_staked_base_tokens_cache_hit"
+	StatsGetStakedBaseTokensCacheMiss                  = "stats_get_staked_base_tokens_cache_miss"
 
 	// Gauges
 	InsuranceFundBalance                      = "insurance_fund_balance"
@@ -38,8 +38,8 @@ const (
 	ClobSubaccountsRequiringDeleveragingCount = "clob_subaccounts_requiring_deleveraging_count"
 	SendingProcessDepositToSubaccount         = "sending_process_deposit_to_subaccount"
 	RateLimitInsufficientWithdrawalAmount     = "rate_limit_insufficient_withdrawal_amount"
-	StatsGetStakedAmountLatencyCacheHit       = "stats_get_staked_amount_latency_cache_hit"
-	StatsGetStakedAmountLatencyCacheMiss      = "stats_get_staked_amount_latency_cache_miss"
+	StatsGetStakedBaseTokensLatencyCacheHit   = "stats_get_staked_base_tokens_latency_cache_hit"
+	StatsGetStakedBaseTokensLatencyCacheMiss  = "stats_get_staked_base_tokens_latency_cache_miss"
 
 	// Samples
 	ClobDeleverageSubaccountTotalQuoteQuantumsDistribution         = "clob_deleverage_subaccount_total_quote_quantums_distribution"
diff --git a/protocol/x/affiliates/keeper/grpc_query.go b/protocol/x/affiliates/keeper/grpc_query.go
@@ -40,7 +40,7 @@ func (k Keeper) AffiliateInfo(c context.Context,
 
 	userStats := k.statsKeeper.GetUserStats(ctx, addr.String())
 	referredVolume := userStats.Affiliate_30DReferredVolumeQuoteQuantums
-	stakedAmount := k.statsKeeper.GetStakedAmount(ctx, req.GetAddress())
+	stakedAmount := k.statsKeeper.GetStakedBaseTokens(ctx, req.GetAddress())
 
 	return &types.AffiliateInfoResponse{
 		IsWhitelisted:             isWhitelisted,
diff --git a/protocol/x/affiliates/keeper/keeper_test.go b/protocol/x/affiliates/keeper/keeper_test.go
@@ -220,7 +220,7 @@ func TestGetTakerFeeShareViaStakedAmount(t *testing.T) {
 	require.Equal(t, types.DefaultAffiliateTiers.Tiers[0].TakerFeeSharePpm, feeSharePpm)
 
 	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(
-		time.Duration(statstypes.StakedAmountCacheDurationSeconds+1) * time.Second,
+		time.Duration(statstypes.StakedBaseTokensCacheDurationSeconds+1) * time.Second,
 	))
 	// Add more staked amount to upgrade tier
 	err = stakingKeeper.SetDelegation(ctx,
diff --git a/protocol/x/affiliates/types/expected_keepers.go b/protocol/x/affiliates/types/expected_keepers.go
@@ -8,7 +8,7 @@ import (
 )
 
 type StatsKeeper interface {
-	GetStakedAmount(ctx sdk.Context, delegatorAddr string) *big.Int
+	GetStakedBaseTokens(ctx sdk.Context, delegatorAddr string) *big.Int
 	GetBlockStats(ctx sdk.Context) *stattypes.BlockStats
 	GetUserStats(ctx sdk.Context, address string) *stattypes.UserStats
 	SetUserStats(ctx sdk.Context, address string, userStats *stattypes.UserStats)
diff --git a/protocol/x/feetiers/keeper/grpc_query.go b/protocol/x/feetiers/keeper/grpc_query.go
@@ -152,7 +152,7 @@ func (k Keeper) UserStakingTier(
 	_, userFeeTier := k.getUserFeeTier(ctx, req.Address, affiliateParameters.RefereeMinimumFeeTierIdx)
 
 	// Get user's staking info
-	stakedAmount := k.statsKeeper.GetStakedAmount(ctx, req.Address)
+	stakedAmount := k.statsKeeper.GetStakedBaseTokens(ctx, req.Address)
 	discountPpm := k.GetStakingDiscountPpm(ctx, userFeeTier.Name, stakedAmount)
 
 	return &types.QueryUserStakingTierResponse{
diff --git a/protocol/x/feetiers/keeper/grpc_query_test.go b/protocol/x/feetiers/keeper/grpc_query_test.go
@@ -540,9 +540,9 @@ func TestUserStakingTier(t *testing.T) {
 				if tc.userBondedTokens != nil {
 					bondedAmount = tc.userBondedTokens
 				}
-				statsKeeper.UnsafeSetCachedStakedAmount(ctx, tc.req.Address, &stattypes.CachedStakeAmount{
-					StakedAmount: dtypes.NewIntFromBigInt(bondedAmount),
-					CachedAt:     ctx.BlockTime().Unix(),
+				statsKeeper.UnsafeSetCachedStakedBaseTokens(ctx, tc.req.Address, &stattypes.CachedStakedBaseTokens{
+					StakedBaseTokens: dtypes.NewIntFromBigInt(bondedAmount),
+					CachedAt:         ctx.BlockTime().Unix(),
 				})
 			}
 
diff --git a/protocol/x/feetiers/keeper/keeper.go b/protocol/x/feetiers/keeper/keeper.go
@@ -159,7 +159,7 @@ func (k Keeper) GetPerpetualFeePpm(
 				"error", err,
 			)
 		} else {
-			stakedAmount := k.statsKeeper.GetStakedAmount(ctx, address)
+			stakedAmount := k.statsKeeper.GetStakedBaseTokens(ctx, address)
 			stakingDiscountPpm := k.GetStakingDiscountPpm(ctx, userTier.Name, stakedAmount)
 			if stakingDiscountPpm > 0 {
 				// Final fee
diff --git a/protocol/x/feetiers/keeper/keeper_test.go b/protocol/x/feetiers/keeper/keeper_test.go
@@ -504,9 +504,9 @@ func TestGetPerpetualFeePpm(t *testing.T) {
 
 			// Set up user bonded tokens
 			if tc.userBondedTokens != nil {
-				statsKeeper.UnsafeSetCachedStakedAmount(ctx, tc.user, &stattypes.CachedStakeAmount{
-					StakedAmount: dtypes.NewIntFromBigInt(tc.userBondedTokens),
-					CachedAt:     ctx.BlockTime().Unix(),
+				statsKeeper.UnsafeSetCachedStakedBaseTokens(ctx, tc.user, &stattypes.CachedStakedBaseTokens{
+					StakedBaseTokens: dtypes.NewIntFromBigInt(tc.userBondedTokens),
+					CachedAt:         ctx.BlockTime().Unix(),
 				})
 			}
 
diff --git a/protocol/x/feetiers/types/expected_keepers.go b/protocol/x/feetiers/types/expected_keepers.go
@@ -13,7 +13,7 @@ import (
 type StatsKeeper interface {
 	GetUserStats(ctx sdk.Context, address string) *statstypes.UserStats
 	GetGlobalStats(ctx sdk.Context) *statstypes.GlobalStats
-	GetStakedAmount(ctx sdk.Context, delegatorAddr string) *big.Int
+	GetStakedBaseTokens(ctx sdk.Context, delegatorAddr string) *big.Int
 }
 
 // VaultKeeper defines the expected vault keeper.
diff --git a/protocol/x/stats/keeper/keeper.go b/protocol/x/stats/keeper/keeper.go
@@ -294,49 +294,49 @@ func (k Keeper) ExpireOldStats(ctx sdk.Context) {
 	k.SetStatsMetadata(ctx, metadata)
 }
 
-// GetStakedAmount returns the total staked amount for a delegator address.
+// GetStakedBaseTokens returns the total staked base tokens for a delegator address.
 // It maintains a cache to optimize performance. The function first checks
 // if there's a cached value that hasn't expired. If found, it returns the
 // cached amount. Otherwise, it calculates the staked amount by querying
-// the staking keeper, caches the result, and returns the calculated amount
-func (k Keeper) GetStakedAmount(ctx sdk.Context,
+// the staking keeper, caches the result, and returns the calculated amount.
+func (k Keeper) GetStakedBaseTokens(ctx sdk.Context,
 	delegatorAddr string) *big.Int {
 	startTime := time.Now()
-	stakedAmount := big.NewInt(0)
+	stakedBaseTokens := big.NewInt(0)
 	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.CachedStakeAmountKeyPrefix))
 	bytes := store.Get([]byte(delegatorAddr))
 
 	// return cached value if it's not expired
 	if bytes != nil {
-		var cachedStakedAmount types.CachedStakeAmount
-		k.cdc.MustUnmarshal(bytes, &cachedStakedAmount)
+		var cachedStakedBaseTokens types.CachedStakedBaseTokens
+		k.cdc.MustUnmarshal(bytes, &cachedStakedBaseTokens)
 		// sanity checks
-		if cachedStakedAmount.CachedAt < 0 {
-			panic("cachedStakedAmount.CachedAt is negative")
+		if cachedStakedBaseTokens.CachedAt < 0 {
+			panic("cachedStakedBaseTokens.CachedAt is negative")
 		}
 		if ctx.BlockTime().Unix() < 0 {
 			panic("Invariant violation: ctx.BlockTime().Unix() is negative")
 		}
-		if cachedStakedAmount.CachedAt < 0 {
-			panic("Invariant violation: cachedStakedAmount.CachedAt is negative")
+		if cachedStakedBaseTokens.CachedAt < 0 {
+			panic("Invariant violation: cachedStakedBaseTokens.CachedAt is negative")
 		}
-		if cachedStakedAmount.CachedAt > ctx.BlockTime().Unix() {
-			panic("Invariant violation: cachedStakedAmount.CachedAt is greater than blocktime")
+		if cachedStakedBaseTokens.CachedAt > ctx.BlockTime().Unix() {
+			panic("Invariant violation: cachedStakedBaseTokens.CachedAt is greater than blocktime")
 		}
-		if ctx.BlockTime().Unix()-cachedStakedAmount.CachedAt <= types.StakedAmountCacheDurationSeconds {
-			stakedAmount.Set(cachedStakedAmount.StakedAmount.BigInt())
-			metrics.IncrCounterWithLabels(metrics.StatsGetStakedAmountCacheHit, 1)
+		if ctx.BlockTime().Unix()-cachedStakedBaseTokens.CachedAt <= types.StakedBaseTokensCacheDurationSeconds {
+			stakedBaseTokens.Set(cachedStakedBaseTokens.StakedBaseTokens.BigInt())
+			metrics.IncrCounterWithLabels(metrics.StatsGetStakedBaseTokensCacheHit, 1)
 			telemetry.MeasureSince(
 				startTime,
 				types.ModuleName,
-				metrics.StatsGetStakedAmountLatencyCacheHit,
+				metrics.StatsGetStakedBaseTokensLatencyCacheHit,
 				metrics.Latency,
 			)
-			return stakedAmount
+			return stakedBaseTokens
 		}
 	}
 
-	metrics.IncrCounterWithLabels(metrics.StatsGetStakedAmountCacheMiss, 1)
+	metrics.IncrCounterWithLabels(metrics.StatsGetStakedBaseTokensCacheMiss, 1)
 
 	// calculate staked amount
 	delegator, err := sdk.AccAddressFromBech32(delegatorAddr)
@@ -350,26 +350,41 @@ func (k Keeper) GetStakedAmount(ctx sdk.Context,
 	}
 
 	for _, delegation := range delegations {
-		stakedAmount.Add(stakedAmount, delegation.GetShares().RoundInt().BigInt())
+		// Get the validator to convert shares to tokens
+		valAddr, err := sdk.ValAddressFromBech32(delegation.GetValidatorAddr())
+		if err != nil {
+			// If invalid validator address, skip this delegation
+			continue
+		}
+
+		validator, err := k.stakingKeeper.GetValidator(ctx, valAddr)
+		if err != nil {
+			// If validator not found, skip this delegation
+			continue
+		}
+
+		// Convert shares to tokens using validator exchange rate
+		tokens := validator.TokensFromShares(delegation.GetShares())
+		stakedBaseTokens.Add(stakedBaseTokens, tokens.RoundInt().BigInt())
 	}
 
 	// update cache
-	cachedStakedAmount := types.CachedStakeAmount{
-		StakedAmount: dtypes.NewIntFromBigInt(stakedAmount),
-		CachedAt:     ctx.BlockTime().Unix(),
+	cachedStakedBaseTokens := types.CachedStakedBaseTokens{
+		StakedBaseTokens: dtypes.NewIntFromBigInt(stakedBaseTokens),
+		CachedAt:         ctx.BlockTime().Unix(),
 	}
-	store.Set([]byte(delegatorAddr), k.cdc.MustMarshal(&cachedStakedAmount))
+	store.Set([]byte(delegatorAddr), k.cdc.MustMarshal(&cachedStakedBaseTokens))
 	telemetry.MeasureSince(
 		startTime,
 		types.ModuleName,
-		metrics.StatsGetStakedAmountLatencyCacheMiss,
+		metrics.StatsGetStakedBaseTokensLatencyCacheMiss,
 		metrics.Latency,
 	)
-	return stakedAmount
+	return stakedBaseTokens
 }
 
-func (k Keeper) UnsafeSetCachedStakedAmount(ctx sdk.Context, delegatorAddr string,
-	cachedStakedAmount *types.CachedStakeAmount) {
+func (k Keeper) UnsafeSetCachedStakedBaseTokens(ctx sdk.Context, delegatorAddr string,
+	cachedStakedBaseTokens *types.CachedStakedBaseTokens) {
 	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.CachedStakeAmountKeyPrefix))
-	store.Set([]byte(delegatorAddr), k.cdc.MustMarshal(cachedStakedAmount))
+	store.Set([]byte(delegatorAddr), k.cdc.MustMarshal(cachedStakedBaseTokens))
 }
diff --git a/protocol/x/stats/keeper/keeper_test.go b/protocol/x/stats/keeper/keeper_test.go
diff --git a/protocol/x/stats/types/constants.go b/protocol/x/stats/types/constants.go
diff --git a/protocol/x/stats/types/expected_keepers.go b/protocol/x/stats/types/expected_keepers.go
diff --git a/protocol/x/stats/types/stats.pb.go b/protocol/x/stats/types/stats.pb.go

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import (`
`8`	`8`	`)`
`9`	`9`
`10`	`10`	`type StatsKeeper interface {`
`11`		`- GetStakedAmount(ctx sdk.Context, delegatorAddr string) *big.Int`
	`11`	`+ GetStakedBaseTokens(ctx sdk.Context, delegatorAddr string) *big.Int`
`12`	`12`	`GetBlockStats(ctx sdk.Context) *stattypes.BlockStats`
`13`	`13`	`GetUserStats(ctx sdk.Context, address string) *stattypes.UserStats`
`14`	`14`	`SetUserStats(ctx sdk.Context, address string, userStats *stattypes.UserStats)`
Original file line number	Diff line number	Diff line change
`@@ -540,9 +540,9 @@ func TestUserStakingTier(t *testing.T) {`
`540`	`540`	`if tc.userBondedTokens != nil {`
`541`	`541`	`bondedAmount = tc.userBondedTokens`
`542`	`542`	`}`
`543`		`- statsKeeper.UnsafeSetCachedStakedAmount(ctx, tc.req.Address, &stattypes.CachedStakeAmount{`
`544`		`- StakedAmount: dtypes.NewIntFromBigInt(bondedAmount),`
`545`		`- CachedAt: ctx.BlockTime().Unix(),`
	`543`	`+ statsKeeper.UnsafeSetCachedStakedBaseTokens(ctx, tc.req.Address, &stattypes.CachedStakedBaseTokens{`
	`544`	`+ StakedBaseTokens: dtypes.NewIntFromBigInt(bondedAmount),`
	`545`	`+ CachedAt: ctx.BlockTime().Unix(),`
`546`	`546`	`})`
`547`	`547`	`}`
`548`	`548`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ func (k Keeper) GetPerpetualFeePpm(`
`159`	`159`	`"error", err,`
`160`	`160`	`)`
`161`	`161`	`} else {`
`162`		`- stakedAmount := k.statsKeeper.GetStakedAmount(ctx, address)`
	`162`	`+ stakedAmount := k.statsKeeper.GetStakedBaseTokens(ctx, address)`
`163`	`163`	`stakingDiscountPpm := k.GetStakingDiscountPpm(ctx, userTier.Name, stakedAmount)`
`164`	`164`	`if stakingDiscountPpm > 0 {`
`165`	`165`	`// Final fee`