feat: add active_duration and inactive_pending_duration for session instead status_change_delay

Author: ironman0x7b2

proto/sentinel/session/v3/params.proto

@@ -9,17 +9,21 @@ option (gogoproto.equal_all) = false;
 option (gogoproto.goproto_getters_all) = false;
 
 message Params {
-  int64 max_gigabytes = 1;
-  int64 min_gigabytes = 2;
-  int64 max_hours = 3;
-  int64 min_hours = 4;
-  bool proof_verification_enabled = 5;
-  string staking_share = 6 [
-    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
-    (gogoproto.nullable) = false
+  google.protobuf.Duration active_duration = 1 [
+    (gogoproto.nullable) = false,
+    (gogoproto.stdduration) = true
   ];
-  google.protobuf.Duration status_change_delay = 7 [
+  google.protobuf.Duration inactive_pending_duration = 2 [
     (gogoproto.nullable) = false,
     (gogoproto.stdduration) = true
   ];
+  int64 max_gigabytes = 3;
+  int64 min_gigabytes = 4;
+  int64 max_hours = 5;
+  int64 min_hours = 6;
+  bool proof_verification_enabled = 7;
+  string staking_share = 8 [
+    (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
+    (gogoproto.nullable) = false
+  ];
 }

x/node/keeper/alias.go

@@ -78,8 +78,8 @@ func (k *Keeper) GetSessionCount(ctx sdk.Context) uint64 {
 	return k.session.GetSessionCount(ctx)
 }
 
-func (k *Keeper) GetSessionInactiveAt(ctx sdk.Context) time.Time {
-	return k.session.GetInactiveAt(ctx)
+func (k *Keeper) GetSessionInactivePendingAt(ctx sdk.Context) time.Time {
+	return k.session.GetInactivePendingAt(ctx)
 }
 
 func (k *Keeper) GetSession(ctx sdk.Context, id uint64) (sessiontypes.Session, bool) {

x/node/keeper/expected.go

@@ -42,7 +42,7 @@ type SessionKeeper interface {
 	DeleteSession(ctx sdk.Context, id uint64)
 	DeleteSessionForAccount(ctx sdk.Context, addr sdk.AccAddress, id uint64)
 	DeleteSessionForNode(ctx sdk.Context, addr base.NodeAddress, id uint64)
-	GetInactiveAt(ctx sdk.Context) time.Time
+	GetInactivePendingAt(ctx sdk.Context) time.Time
 	GetSessionCount(ctx sdk.Context) uint64
 	GetSession(ctx sdk.Context, id uint64) (sessiontypes.Session, bool)
 	IsValidGigabytes(ctx sdk.Context, id int64) bool

x/node/keeper/msg_handler.go

@@ -252,11 +252,9 @@ func (k *Keeper) HandleMsgStartSession(ctx sdk.Context, msg *v3.MsgStartSessionR
 		return nil, err
 	}
 
-	// Generate new session ID and expiration time
+	// Build a new session with default usage and time fields
 	count := k.GetSessionCount(ctx)
-	inactiveAt := k.GetSessionInactiveAt(ctx)
-
-	// Construct the session object with bandwidth/time limits and metadata
+	inactiveAt := k.GetSessionInactivePendingAt(ctx)
 	session := &v3.Session{
 		BaseSession: &sessiontypes.BaseSession{
 			ID:            count + 1,

x/session/keeper/msg_handler.go

@@ -126,8 +126,8 @@ func (k *Keeper) HandleMsgUpdateSession(ctx sdk.Context, msg *v3.MsgUpdateSessio
 
 	// If active, refresh inactivity timeout
 	if session.GetStatus().Equal(v1base.StatusActive) {
-		inactiveAt := k.GetInactiveAt(ctx)
-		session.SetInactiveAt(inactiveAt)
+		inactivePendingAt := k.GetInactivePendingAt(ctx)
+		session.SetInactiveAt(inactivePendingAt)
 	}
 
 	// Persist updated session and reindex if still active

x/session/keeper/params.go

@@ -30,6 +30,16 @@ func (k *Keeper) GetParams(ctx sdk.Context) (v v3.Params) {
 	return v
 }
 
+// ActiveDuration returns the active duration from the module's parameters.
+func (k *Keeper) ActiveDuration(ctx sdk.Context) time.Duration {
+	return k.GetParams(ctx).ActiveDuration
+}
+
+// InactivePendingDuration returns the inactive pending duration from the module's parameters.
+func (k *Keeper) InactivePendingDuration(ctx sdk.Context) time.Duration {
+	return k.GetParams(ctx).InactivePendingDuration
+}
+
 // MaxGigabytes retrieves the maximum gigabytes parameter from the module's parameters.
 func (k *Keeper) MaxGigabytes(ctx sdk.Context) int64 {
 	return k.GetParams(ctx).MaxGigabytes
@@ -60,11 +70,6 @@ func (k *Keeper) StakingShare(ctx sdk.Context) sdkmath.LegacyDec {
 	return k.GetParams(ctx).StakingShare
 }
 
-// StatusChangeDelay returns the delay for status changes from the module's parameters.
-func (k *Keeper) StatusChangeDelay(ctx sdk.Context) time.Duration {
-	return k.GetParams(ctx).StatusChangeDelay
-}
-
 // IsValidGigabytes checks if the provided gigabytes are within the valid range defined by the module's parameters.
 func (k *Keeper) IsValidGigabytes(ctx sdk.Context, gigabytes int64) bool {
 	if gigabytes > k.MaxGigabytes(ctx) {
@@ -91,9 +96,16 @@ func (k *Keeper) IsValidHours(ctx sdk.Context, hours int64) bool {
 	return true
 }
 
-// GetInactiveAt returns the inactive time by adding StatusChangeDelay to the current block time.
+// GetInactivePendingAt returns the inactive pending time by adding ActiveDuration to the current block time.
+func (k *Keeper) GetInactivePendingAt(ctx sdk.Context) time.Time {
+	d := k.ActiveDuration(ctx)
+
+	return ctx.BlockTime().Add(d)
+}
+
+// GetInactiveAt returns the inactive time by adding InactivePendingDuration to the current block time.
 func (k *Keeper) GetInactiveAt(ctx sdk.Context) time.Time {
-	d := k.StatusChangeDelay(ctx)
+	d := k.InactivePendingDuration(ctx)
 
 	return ctx.BlockTime().Add(d)
 }

x/session/migrations/migrator.go

@@ -53,13 +53,14 @@ func (k *Migrator) deleteKeys(ctx sdk.Context, keyPrefix []byte) (keys [][]byte)
 
 func (k *Migrator) setParams(ctx sdk.Context) {
 	params := v3.Params{
+		ActiveDuration:           2 * time.Hour,
+		InactivePendingDuration:  2 * time.Hour,
 		MaxGigabytes:             1_000_000,
 		MinGigabytes:             1,
 		MaxHours:                 720,
 		MinHours:                 1,
 		ProofVerificationEnabled: false,
 		StakingShare:             sdkmath.LegacyMustNewDecFromStr("0.2"),
-		StatusChangeDelay:        2 * time.Hour,
 	}
 
 	k.session.SetParams(ctx, params)

x/session/types/v3/params.go

@@ -10,17 +10,26 @@ import (
 
 // Default parameter values for the Params struct.
 var (
+	DefaultActiveDuration                 = 1 * time.Minute                     // Default active duration
+	DefaultInactivePendingDuration        = 1 * time.Minute                     // Default inactive pending duration
 	DefaultMaxGigabytes             int64 = 10                                  // Default maximum allowed gigabytes
 	DefaultMinGigabytes             int64 = 1                                   // Default minimum allowed gigabytes
 	DefaultMaxHours                 int64 = 10                                  // Default maximum allowed hours
 	DefaultMinHours                 int64 = 1                                   // Default minimum allowed hours
 	DefaultProofVerificationEnabled       = false                               // Default proof verification flag
 	DefaultStakingShare                   = math.LegacyMustNewDecFromStr("0.1") // Default staking share: 0.1
-	DefaultStatusChangeDelay              = 1 * time.Minute                     // Default delay before validator status change
 )
 
 // Validate checks whether the Params fields are valid according to defined rules.
 func (m *Params) Validate() error {
+	if err := validateActiveDuration(m.ActiveDuration); err != nil {
+		return fmt.Errorf("invalid active_duration: %w", err)
+	}
+
+	if err := validateInactivePendingDuration(m.InactivePendingDuration); err != nil {
+		return fmt.Errorf("invalid inactive_pending_duration: %w", err)
+	}
+
 	if err := validateMaxGigabytes(m.MaxGigabytes); err != nil {
 		return fmt.Errorf("invalid max_gigabytes: %w", err)
 	}
@@ -45,42 +54,66 @@ func (m *Params) Validate() error {
 		return fmt.Errorf("invalid staking_share: %w", err)
 	}
 
-	if err := validateStatusChangeDelay(m.StatusChangeDelay); err != nil {
-		return fmt.Errorf("invalid status_change_delay: %w", err)
-	}
-
 	return nil
 }
 
 // NewParams creates a new Params instance with custom values.
 func NewParams(
-	maxGigabytes, minGigabytes, maxHours, minHours int64, proofVerificationEnabled bool, stakingShare math.LegacyDec,
-	statusChangeDelay time.Duration,
+	activeDuration, inactivePendingDuration time.Duration, maxGigabytes, minGigabytes, maxHours, minHours int64,
+	proofVerificationEnabled bool, stakingShare math.LegacyDec,
 ) Params {
 	return Params{
+		ActiveDuration:           activeDuration,
+		InactivePendingDuration:  inactivePendingDuration,
 		MaxGigabytes:             maxGigabytes,
 		MinGigabytes:             minGigabytes,
 		MaxHours:                 maxHours,
 		MinHours:                 minHours,
 		ProofVerificationEnabled: proofVerificationEnabled,
 		StakingShare:             stakingShare,
-		StatusChangeDelay:        statusChangeDelay,
 	}
 }
 
 // DefaultParams returns a Params struct initialized with default values.
 func DefaultParams() Params {
 	return NewParams(
+		DefaultActiveDuration,
+		DefaultInactivePendingDuration,
 		DefaultMaxGigabytes,
 		DefaultMinGigabytes,
 		DefaultMaxHours,
 		DefaultMinHours,
 		DefaultProofVerificationEnabled,
 		DefaultStakingShare,
-		DefaultStatusChangeDelay,
 	)
 }
 
+// validateActiveDuration ensures the activeDuration is positive and non-zero.
+func validateActiveDuration(v time.Duration) error {
+	if v == 0 {
+		return errors.New("value cannot be zero")
+	}
+
+	if v < 0 {
+		return errors.New("value cannot be negative")
+	}
+
+	return nil
+}
+
+// validateInactivePendingDuration ensures the inactivePendingDuration is positive and non-zero.
+func validateInactivePendingDuration(v time.Duration) error {
+	if v == 0 {
+		return errors.New("value cannot be zero")
+	}
+
+	if v < 0 {
+		return errors.New("value cannot be negative")
+	}
+
+	return nil
+}
+
 // validateMaxGigabytes ensures maxGigabytes is a positive non-zero integer.
 func validateMaxGigabytes(v int64) error {
 	if v == 0 {
@@ -155,16 +188,3 @@ func validateStakingShare(v math.LegacyDec) error {
 
 	return nil
 }
-
-// validateStatusChangeDelay ensures the delay is positive and non-zero.
-func validateStatusChangeDelay(v time.Duration) error {
-	if v == 0 {
-		return errors.New("value cannot be zero")
-	}
-
-	if v < 0 {
-		return errors.New("value cannot be negative")
-	}
-
-	return nil
-}