[CORE-824] x/ratelimit: Implement UpdateCapacityEndBlocker

protocol/app/app.go

@@ -588,10 +588,22 @@ func New(
 	transferModule := transfer.NewAppModule(app.TransferKeeper)
 	transferIBCModule := transfer.NewIBCModule(app.TransferKeeper)
 
+	app.BlockTimeKeeper = *blocktimemodulekeeper.NewKeeper(
+		appCodec,
+		keys[blocktimemoduletypes.StoreKey],
+		// set the governance and delaymsg module accounts as the authority for conducting upgrades
+		[]string{
+			lib.GovModuleAddress.String(),
+			delaymsgmoduletypes.ModuleAddress.String(),
+		},
+	)
+	blockTimeModule := blocktimemodule.NewAppModule(appCodec, app.BlockTimeKeeper)
+
 	app.RatelimitKeeper = *ratelimitmodulekeeper.NewKeeper(
 		appCodec,
 		keys[ratelimitmoduletypes.StoreKey],
 		app.BankKeeper,
+		app.BlockTimeKeeper,
 		// set the governance and delaymsg module accounts as the authority for conducting upgrades
 		[]string{
 			lib.GovModuleAddress.String(),
@@ -792,17 +804,6 @@ func New(
 	)
 	assetsModule := assetsmodule.NewAppModule(appCodec, app.AssetsKeeper)
 
-	app.BlockTimeKeeper = *blocktimemodulekeeper.NewKeeper(
-		appCodec,
-		keys[blocktimemoduletypes.StoreKey],
-		// set the governance and delaymsg module accounts as the authority for conducting upgrades
-		[]string{
-			lib.GovModuleAddress.String(),
-			delaymsgmoduletypes.ModuleAddress.String(),
-		},
-	)
-	blockTimeModule := blocktimemodule.NewAppModule(appCodec, app.BlockTimeKeeper)
-
 	app.DelayMsgKeeper = *delaymsgmodulekeeper.NewKeeper(
 		appCodec,
 		keys[delaymsgmoduletypes.StoreKey],

protocol/lib/metrics/constants.go

@@ -397,6 +397,11 @@ const (
 	ValidatorNumFills              = "validator_num_fills"
 	ValidatorNumMatchedTakerOrders = "validator_num_matched_taker_orders"
 	ValidatorVolumeQuoteQuantums   = "validator_volume_quote_quantums"
+
+	// x/ratelimit
+	Capacity       = "capacity"
+	RateLimitDenom = "rate_limit_denom"
+	LimiterIndex   = "limiter_index"
 )
 
 const (

protocol/x/blocktime/keeper/keeper.go

@@ -79,6 +79,12 @@ func (k Keeper) GetPreviousBlockInfo(ctx sdk.Context) types.BlockInfo {
 	return info
 }
 
+// GetTimeSinceLastBlock returns the time delta between the current block time and the last block time.
+func (k Keeper) GetTimeSinceLastBlock(ctx sdk.Context) time.Duration {
+	prevBlockInfo := k.GetPreviousBlockInfo(ctx)
+	return ctx.BlockTime().Sub(prevBlockInfo.Timestamp)
+}
+
 func (k Keeper) SetPreviousBlockInfo(ctx sdk.Context, info *types.BlockInfo) {
 	store := ctx.KVStore(k.storeKey)
 	b := k.cdc.MustMarshal(info)

protocol/x/blocktime/keeper/keeper_test.go

@@ -243,3 +243,46 @@ func TestGetDowntimeInfoFor(t *testing.T) {
 		})
 	}
 }
+
+func TestGetTimeSinceLastBlock(t *testing.T) {
+	testPrevBlockHeight := uint32(5)
+	tests := map[string]struct {
+		prevBlockTime              time.Time
+		currBlockTime              time.Time
+		expectedTimeSinceLastBlock time.Duration
+	}{
+		"2 sec": {
+			prevBlockTime:              time.Unix(100, 0).UTC(),
+			currBlockTime:              time.Unix(102, 0).UTC(),
+			expectedTimeSinceLastBlock: time.Second * 2,
+		},
+		"Realistic values": {
+			prevBlockTime:              time.Unix(1_704_827_023, 123_000_000).UTC(),
+			currBlockTime:              time.Unix(1_704_827_024, 518_000_000).UTC(),
+			expectedTimeSinceLastBlock: time.Second*1 + time.Nanosecond*395_000_000,
+		},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			tApp := testapp.NewTestAppBuilder(t).Build()
+			tApp.InitChain()
+
+			ctx := tApp.AdvanceToBlock(
+				testPrevBlockHeight,
+				testapp.AdvanceToBlockOptions{
+					BlockTime: tc.prevBlockTime,
+				},
+			)
+
+			k := tApp.App.BlockTimeKeeper
+
+			actual := k.GetTimeSinceLastBlock(ctx.WithBlockTime(tc.currBlockTime))
+			require.Equal(
+				t,
+				tc.expectedTimeSinceLastBlock,
+				actual,
+			)
+		})
+	}
+}

protocol/x/blocktime/module.go

@@ -2,10 +2,11 @@ package blocktime
 
 import (
 	"context"
-	"cosmossdk.io/core/appmodule"
 	"encoding/json"
 	"fmt"
 
+	"cosmossdk.io/core/appmodule"
+
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/spf13/cobra"
 

protocol/x/ratelimit/keeper/keeper.go

@@ -9,17 +9,22 @@ import (
 	"cosmossdk.io/store/prefix"
 	storetypes "cosmossdk.io/store/types"
 	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/dydxprotocol/v4-chain/protocol/dtypes"
 	"github.com/dydxprotocol/v4-chain/protocol/lib"
+	"github.com/dydxprotocol/v4-chain/protocol/lib/metrics"
 	"github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/types"
+	ratelimitutil "github.com/dydxprotocol/v4-chain/protocol/x/ratelimit/util"
+	gometrics "github.com/hashicorp/go-metrics"
 )
 
 type (
 	Keeper struct {
-		cdc        codec.BinaryCodec
-		storeKey   storetypes.StoreKey
-		bankKeeper types.BankKeeper
+		cdc             codec.BinaryCodec
+		storeKey        storetypes.StoreKey
+		bankKeeper      types.BankKeeper
+		blockTimeKeeper types.BlockTimeKeeper
 
 		// TODO(CORE-824): Implement `x/ratelimit` keeper
 
@@ -32,13 +37,15 @@ func NewKeeper(
 	cdc codec.BinaryCodec,
 	storeKey storetypes.StoreKey,
 	bankKeeper types.BankKeeper,
+	blockTimeKeeper types.BlockTimeKeeper,
 	authorities []string,
 ) *Keeper {
 	return &Keeper{
-		cdc:         cdc,
-		storeKey:    storeKey,
-		bankKeeper:  bankKeeper,
-		authorities: lib.UniqueSliceToSet(authorities),
+		cdc:             cdc,
+		storeKey:        storeKey,
+		bankKeeper:      bankKeeper,
+		blockTimeKeeper: blockTimeKeeper,
+		authorities:     lib.UniqueSliceToSet(authorities),
 	}
 }
 
@@ -116,28 +123,6 @@ func (k Keeper) ProcessDeposit(
 	})
 }
 
-// GetBaseline returns the current capacity baseline for the given limiter.
-// `baseline` formula:
-//
-//	baseline = max(baseline_minimum, baseline_tvl_ppm * current_tvl)
-func (k Keeper) GetBaseline(
-	ctx sdk.Context,
-	denom string,
-	limiter types.Limiter,
-) *big.Int {
-	// Get the current TVL.
-	supply := k.bankKeeper.GetSupply(ctx, denom)
-	currentTVL := supply.Amount.BigInt()
-
-	return lib.BigMax(
-		limiter.BaselineMinimum.BigInt(),
-		lib.BigIntMulPpm(
-			currentTVL,
-			limiter.BaselineTvlPpm,
-		),
-	)
-}
-
 // SetLimitParams sets `LimitParams` for the given denom.
 // Also overwrites the existing `DenomCapacity` object for the denom with a default `capacity_list` of the
 // same length as the `limiters` list. Each `capacity` is initialized to the current baseline.
@@ -161,11 +146,12 @@ func (k Keeper) SetLimitParams(
 		return
 	}
 
+	currentTvl := k.bankKeeper.GetSupply(ctx, limitParams.Denom)
 	// Initialize the capacity list with the current baseline.
 	newCapacityList := make([]dtypes.SerializableInt, len(limitParams.Limiters))
 	for i, limiter := range limitParams.Limiters {
 		newCapacityList[i] = dtypes.NewIntFromBigInt(
-			k.GetBaseline(ctx, limitParams.Denom, limiter),
+			ratelimitutil.GetBaseline(currentTvl.Amount.BigInt(), limiter),
 		)
 	}
 	// Set correspondong `DenomCapacity` in state.
@@ -216,6 +202,85 @@ func (k Keeper) SetDenomCapacity(
 		b := k.cdc.MustMarshal(&denomCapacity)
 		store.Set(key, b)
 	}
+
+	// Emit telemetry for the new capacity list.
+	for i, capacity := range denomCapacity.CapacityList {
+		telemetry.SetGaugeWithLabels(
+			[]string{types.ModuleName, metrics.Capacity},
+			metrics.GetMetricValueFromBigInt(capacity.BigInt()),
+			[]gometrics.Label{
+				metrics.GetLabelForStringValue(metrics.RateLimitDenom, denomCapacity.Denom),
+				metrics.GetLabelForIntValue(metrics.LimiterIndex, i),
+			},
+		)
+	}
+}
+
+// UpdateAllCapacitiesEndBlocker is called during the EndBlocker to update the capacity for all limit params.
+func (k Keeper) UpdateAllCapacitiesEndBlocker(
+	ctx sdk.Context,
+) {
+	// Iterate through all the limit params in state.
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), []byte(types.LimitParamsKeyPrefix))
+	iterator := storetypes.KVStorePrefixIterator(store, []byte{})
+
+	defer iterator.Close()
+
+	for ; iterator.Valid(); iterator.Next() {
+		var limitParams types.LimitParams
+		k.cdc.MustUnmarshal(iterator.Value(), &limitParams)
+		k.updateCapacityForLimitParams(ctx, limitParams)
+	}
+}
+
+// updateCapacityForLimitParams calculates current baseline for a denom and recovers some amount of capacity
+// towards baseline.
+// Assumes that the `LimitParams` exist in state.
+func (k Keeper) updateCapacityForLimitParams(
+	ctx sdk.Context,
+	limitParams types.LimitParams,
+) {
+	tvl := k.bankKeeper.GetSupply(ctx, limitParams.Denom)
+
+	capacityList := k.GetDenomCapacity(ctx, limitParams.Denom).CapacityList
+	if len(capacityList) != len(limitParams.Limiters) {
+		// This violates an invariant. Since this is in the `EndBlocker`, we log an error instead of panicking.
+		k.Logger(ctx).Error(
+			fmt.Sprintf(
+				"denom (%s) capacity list length (%v) != limiters length (%v); skipping capacity update",
+				limitParams.Denom,
+				len(capacityList),
+				len(limitParams.Limiters),
+			),
+		)
+		return
+	}
+
+	timeSinceLastBlock := k.blockTimeKeeper.GetTimeSinceLastBlock(ctx)
+
+	if timeSinceLastBlock < 0 {
+		// This violates an invariant (current block time > prev block time).
+		// Since this is in the `EndBlocker`, we log an error instead of panicking.
+		k.Logger(ctx).Error(
+			fmt.Sprintf(
+				"timeSinceLastBlock (%v) <= 0; skipping capacity update",
+				timeSinceLastBlock,
+			),
+		)
+		return
+	}
+
+	newCapacityList := ratelimitutil.CalculateNewCapacityList(
+		tvl.Amount.BigInt(),
+		limitParams,
+		capacityList,
+		timeSinceLastBlock,
+	)
+
+	k.SetDenomCapacity(ctx, types.DenomCapacity{
+		Denom:        limitParams.Denom,
+		CapacityList: newCapacityList,
+	})
 }
 
 // GetDenomCapacity returns `DenomCapacity` for the given denom.