feat: limit the number of allocations for a subscription

Author: ironman0x7b2

proto/sentinel/subscription/v3/params.proto

@@ -9,11 +9,12 @@ option (gogoproto.equal_all) = false;
 option (gogoproto.goproto_getters_all) = false;
 
 message Params {
-  string staking_share = 1 [
+  int64 max_allocations = 1;
+  string staking_share = 2 [
     (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec",
     (gogoproto.nullable) = false
   ];
-  google.protobuf.Duration status_timeout = 2 [
+  google.protobuf.Duration status_timeout = 3 [
     (gogoproto.nullable) = false,
     (gogoproto.stdduration) = true
   ];

x/subscription/keeper/msg_handler.go

@@ -209,6 +209,11 @@ func (k *Keeper) HandleMsgShareSubscription(ctx sdk.Context, msg *v3.MsgShareSub
 		return nil, types.NewErrorUnauthorized(msg.From)
 	}
 
+	// Check if the subscription has reached maximum allocations
+	if k.IsMaxAllocationsReached(ctx, subscription.ID) {
+		return nil, types.NewErrorMaxAllocationsReached(subscription.ID)
+	}
+
 	// Load allocation from sender and parse both account addresses
 	fromAddr, err := sdk.AccAddressFromBech32(msg.From)
 	if err != nil {

x/subscription/keeper/params.go

@@ -7,6 +7,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/sentinel-official/sentinelhub/v12/x/subscription/types"
+	"github.com/sentinel-official/sentinelhub/v12/x/subscription/types/v2"
 	"github.com/sentinel-official/sentinelhub/v12/x/subscription/types/v3"
 )
 
@@ -30,6 +31,11 @@ func (k *Keeper) GetParams(ctx sdk.Context) (v v3.Params) {
 	return v
 }
 
+// MaxAllocations retrieves the max allocations parameter from the module's parameters.
+func (k *Keeper) MaxAllocations(ctx sdk.Context) int64 {
+	return k.GetParams(ctx).MaxAllocations
+}
+
 // StakingShare retrieves the staking share parameter from the module's parameters.
 func (k *Keeper) StakingShare(ctx sdk.Context) sdkmath.LegacyDec {
 	return k.GetParams(ctx).StakingShare
@@ -46,3 +52,21 @@ func (k *Keeper) GetInactiveAt(ctx sdk.Context) time.Time {
 
 	return ctx.BlockTime().Add(d)
 }
+
+// IsMaxAllocationsReached checks if the maximum number of allocations for a given subscription has been reached.
+func (k *Keeper) IsMaxAllocationsReached(ctx sdk.Context, id uint64) bool {
+	maxAllocations := k.MaxAllocations(ctx)
+
+	var count int64
+
+	k.IterateAllocationsForSubscription(ctx, id, func(_ int, _ v2.Allocation) bool {
+		count++
+		if count >= maxAllocations {
+			return true // Stop iterating when maxAllocations is reached
+		}
+
+		return false
+	})
+
+	return count >= maxAllocations
+}

x/subscription/migrations/migrator.go

@@ -76,8 +76,9 @@ func (k *Migrator) deleteKeys(ctx sdk.Context, keyPrefix []byte) (keys [][]byte)
 
 func (k *Migrator) setParams(ctx sdk.Context) {
 	params := v3.Params{
-		StakingShare:  sdkmath.LegacyMustNewDecFromStr("0.2"),
-		StatusTimeout: 4 * time.Hour,
+		MaxAllocations: 8,
+		StakingShare:   sdkmath.LegacyMustNewDecFromStr("0.2"),
+		StatusTimeout:  4 * time.Hour,
 	}
 
 	k.subscription.SetParams(ctx, params)

x/subscription/types/errors.go

@@ -20,6 +20,7 @@ const (
 	ErrCodeInvalidRenewalPolicy
 	ErrCodeInvalidSessionStatus
 	ErrCodeInvalidSubscriptionStatus
+	ErrCodeMaxAllocationsReached
 	ErrCodeNodeForPlanNotFound
 	ErrCodeNodeNotFound
 	ErrCodePlanNotFound
@@ -39,6 +40,7 @@ var (
 	ErrInvalidRenewalPolicy      = sdkerrors.Register(ModuleName, ErrCodeInvalidRenewalPolicy, "invalid renewal policy")
 	ErrInvalidSessionStatus      = sdkerrors.Register(ModuleName, ErrCodeInvalidSessionStatus, "invalid session status")
 	ErrInvalidSubscriptionStatus = sdkerrors.Register(ModuleName, ErrCodeInvalidSubscriptionStatus, "invalid subscription status")
+	ErrMaxAllocationsReached     = sdkerrors.Register(ModuleName, ErrCodeMaxAllocationsReached, "max allocations reached")
 	ErrNodeForPlanNotFound       = sdkerrors.Register(ModuleName, ErrCodeNodeForPlanNotFound, "node for plan not found")
 	ErrNodeNotFound              = sdkerrors.Register(ModuleName, ErrCodeNodeNotFound, "node not found")
 	ErrPlanNotFound              = sdkerrors.Register(ModuleName, ErrCodePlanNotFound, "plan not found")
@@ -88,6 +90,11 @@ func NewErrorInvalidSubscriptionStatus(id uint64, status v1base.Status) error {
 	return sdkerrors.Wrapf(ErrInvalidSubscriptionStatus, "invalid status %s for subscription %d", status, id)
 }
 
+// NewErrorMaxAllocationsReached returns an error indicating that the specified subscription has reached maximum allocations.
+func NewErrorMaxAllocationsReached(id uint64) error {
+	return sdkerrors.Wrapf(ErrNodeForPlanNotFound, "subscription %d has reached maximum allocations", id)
+}
+
 // NewErrorNodeForPlanNotFound returns an error indicating that the specified node does not exist for the plan.
 func NewErrorNodeForPlanNotFound(id uint64, addr base.NodeAddress) error {
 	return sdkerrors.Wrapf(ErrNodeForPlanNotFound, "node %s for plan %d does not exist", addr, id)

x/subscription/types/v3/params.go

@@ -10,12 +10,17 @@ import (
 
 // Default parameter values for the Params struct.
 var (
-	DefaultStakingShare  = sdkmath.LegacyMustNewDecFromStr("0.1") // Default staking share: 0.1
-	DefaultStatusTimeout = 2 * time.Minute                        // Default timeout for status change
+	DefaultMaxAllocations int64 = 8                                      // Default max allocations per subscription
+	DefaultStakingShare         = sdkmath.LegacyMustNewDecFromStr("0.1") // Default staking share: 0.1
+	DefaultStatusTimeout        = 2 * time.Minute                        // Default timeout for status change
 )
 
 // Validate checks whether the Params fields are valid according to defined rules.
 func (m *Params) Validate() error {
+	if err := validateMaxAllocations(m.MaxAllocations); err != nil {
+		return fmt.Errorf("invalid max_allocations: %w", err)
+	}
+
 	if err := validateStakingShare(m.StakingShare); err != nil {
 		return fmt.Errorf("invalid staking_share: %w", err)
 	}
@@ -28,21 +33,36 @@ func (m *Params) Validate() error {
 }
 
 // NewParams creates a new Params instance with custom values.
-func NewParams(stakingShare sdkmath.LegacyDec, statusTimeout time.Duration) Params {
+func NewParams(maxAllocations int64, stakingShare sdkmath.LegacyDec, statusTimeout time.Duration) Params {
 	return Params{
-		StakingShare:  stakingShare,
-		StatusTimeout: statusTimeout,
+		MaxAllocations: maxAllocations,
+		StakingShare:   stakingShare,
+		StatusTimeout:  statusTimeout,
 	}
 }
 
 // DefaultParams returns a Params struct initialized with default values.
 func DefaultParams() Params {
 	return NewParams(
+		DefaultMaxAllocations,
 		DefaultStakingShare,
 		DefaultStatusTimeout,
 	)
 }
 
+// validateMaxAllocations checks that maxAllocations is positive.
+func validateMaxAllocations(v int64) error {
+	if v == 0 {
+		return errors.New("value cannot be zero")
+	}
+
+	if v < 0 {
+		return errors.New("value cannot be negative")
+	}
+
+	return nil
+}
+
 // validateStakingShare ensures that the staking share is:
 // - Not nil
 // - Not negative