fix: add missing provider status checks in plan message handler

Author: ironman0x7b2

x/lease/keeper/msg_handler.go

@@ -213,12 +213,23 @@ func (k *Keeper) HandleMsgStartLease(ctx sdk.Context, msg *v1.MsgStartLeaseReque
 		return nil, types.NewErrorInvalidHours(msg.Hours)
 	}
 
+	// Parse and validate the node address
+	nodeAddr, err := base.NodeAddressFromBech32(msg.NodeAddress)
+	if err != nil {
+		return nil, err
+	}
+
 	// Parse and validate the provider's Bech32 address
 	provAddr, err := base.ProvAddressFromBech32(msg.From)
 	if err != nil {
 		return nil, err
 	}
 
+	// Check if a lease already exists between this provider and node
+	if k.HasAnyLeaseForNodeByProvider(ctx, nodeAddr, provAddr) {
+		return nil, types.NewErrorDuplicateLease(nodeAddr, provAddr)
+	}
+
 	// Ensure provider exists and is currently active
 	provider, found := k.GetProvider(ctx, provAddr)
 	if !found {
@@ -229,12 +240,6 @@ func (k *Keeper) HandleMsgStartLease(ctx sdk.Context, msg *v1.MsgStartLeaseReque
 		return nil, types.NewErrorInvalidProviderStatus(provAddr, provider.Status)
 	}
 
-	// Parse and validate the node address
-	nodeAddr, err := base.NodeAddressFromBech32(msg.NodeAddress)
-	if err != nil {
-		return nil, err
-	}
-
 	// Confirm the node exists and is active
 	node, found := k.GetNode(ctx, nodeAddr)
 	if !found {
@@ -262,11 +267,6 @@ func (k *Keeper) HandleMsgStartLease(ctx sdk.Context, msg *v1.MsgStartLeaseReque
 		return nil, types.NewErrorInvalidPrice(price)
 	}
 
-	// Check if a lease already exists between this provider and node
-	if k.HasAnyLeaseForNodeByProvider(ctx, nodeAddr, provAddr) {
-		return nil, types.NewErrorDuplicateLease(nodeAddr, provAddr)
-	}
-
 	// Generate a new lease ID and construct the lease object
 	count := k.GetLeaseCount(ctx)
 	lease := v1.Lease{

x/plan/keeper/alias.go

@@ -6,6 +6,7 @@ import (
 	base "github.com/sentinel-official/sentinelhub/v12/types"
 	leasetypes "github.com/sentinel-official/sentinelhub/v12/x/lease/types/v1"
 	nodetypes "github.com/sentinel-official/sentinelhub/v12/x/node/types/v3"
+	providertypes "github.com/sentinel-official/sentinelhub/v12/x/provider/types/v2"
 )
 
 func (k *Keeper) GetLease(ctx sdk.Context, id uint64) (leasetypes.Lease, bool) {
@@ -36,8 +37,8 @@ func (k *Keeper) HasNodeForPlan(ctx sdk.Context, id uint64, addr base.NodeAddres
 	return k.node.HasNodeForPlan(ctx, id, addr)
 }
 
-func (k *Keeper) HasProvider(ctx sdk.Context, addr base.ProvAddress) bool {
-	return k.provider.HasProvider(ctx, addr)
+func (k *Keeper) GetProvider(ctx sdk.Context, addr base.ProvAddress) (providertypes.Provider, bool) {
+	return k.provider.GetProvider(ctx, addr)
 }
 
 func (k *Keeper) PlanUnlinkNodePreHook(ctx sdk.Context, id uint64, addr base.NodeAddress) error {

x/plan/keeper/expected.go

@@ -7,6 +7,7 @@ import (
 	base "github.com/sentinel-official/sentinelhub/v12/types"
 	leasetypes "github.com/sentinel-official/sentinelhub/v12/x/lease/types/v1"
 	nodetypes "github.com/sentinel-official/sentinelhub/v12/x/node/types/v3"
+	providertypes "github.com/sentinel-official/sentinelhub/v12/x/provider/types/v2"
 	subscriptiontypes "github.com/sentinel-official/sentinelhub/v12/x/subscription/types/v3"
 )
 
@@ -32,7 +33,7 @@ type NodeKeeper interface {
 }
 
 type ProviderKeeper interface {
-	HasProvider(ctx sdk.Context, addr base.ProvAddress) bool
+	GetProvider(ctx sdk.Context, addr base.ProvAddress) (providertypes.Provider, bool)
 }
 
 type SessionKeeper interface {

x/plan/keeper/msg_handler.go

@@ -19,11 +19,16 @@ func (k *Keeper) HandleMsgCreatePlan(ctx sdk.Context, msg *v3.MsgCreatePlanReque
 		return nil, err
 	}
 
-	// Ensure provider exists in the state
-	if !k.HasProvider(ctx, provAddr) {
+	// Verify the provider exists and is in an active state
+	provider, found := k.GetProvider(ctx, provAddr)
+	if !found {
 		return nil, types.NewErrorProviderNotFound(provAddr)
 	}
 
+	if !provider.Status.Equal(v1base.StatusActive) {
+		return nil, types.NewErrorInvalidProviderStatus(provAddr, provider.Status)
+	}
+
 	// Construct the new plan with an incremented ID and inactive status
 	count := k.GetPlanCount(ctx)
 	plan := v3.Plan{
@@ -76,16 +81,6 @@ func (k *Keeper) HandleMsgLinkNode(ctx sdk.Context, msg *v3.MsgLinkNodeRequest)
 		return nil, err
 	}
 
-	// Ensure the node exists and is active
-	node, found := k.GetNode(ctx, nodeAddr)
-	if !found {
-		return nil, types.NewErrorNodeNotFound(nodeAddr)
-	}
-
-	if !node.Status.Equal(v1base.StatusActive) {
-		return nil, types.NewErrorInvalidNodeStatus(nodeAddr, node.Status)
-	}
-
 	// Prevent duplicate node linkage for the same plan
 	if k.HasNodeForPlan(ctx, plan.ID, nodeAddr) {
 		return nil, types.NewErrorDuplicateNodeForPlan(plan.ID, nodeAddr)
@@ -111,7 +106,7 @@ func (k *Keeper) HandleMsgLinkNode(ctx sdk.Context, msg *v3.MsgLinkNodeRequest)
 		&v3.EventLinkNode{
 			PlanID:      plan.ID,
 			ProvAddress: plan.ProvAddress,
-			NodeAddress: node.Address,
+			NodeAddress: nodeAddr.String(),
 		},
 	)
 
@@ -182,6 +177,23 @@ func (k *Keeper) HandleMsgUpdatePlanStatus(ctx sdk.Context, msg *v3.MsgUpdatePla
 		return nil, types.NewErrorUnauthorized(msg.From)
 	}
 
+	if msg.Status.Equal(v1base.StatusActive) {
+		provAddr, err := base.ProvAddressFromBech32(plan.ProvAddress)
+		if err != nil {
+			return nil, err
+		}
+
+		// Ensure provider exists and is currently active
+		provider, found := k.GetProvider(ctx, provAddr)
+		if !found {
+			return nil, types.NewErrorProviderNotFound(provAddr)
+		}
+
+		if !provider.Status.Equal(v1base.StatusActive) {
+			return nil, types.NewErrorInvalidProviderStatus(provAddr, provider.Status)
+		}
+	}
+
 	// Remove old status index if transitioning state
 	if msg.Status.Equal(v1base.StatusActive) {
 		if plan.Status.Equal(v1base.StatusInactive) {

x/plan/types/errors.go

@@ -12,6 +12,7 @@ const (
 	ErrCodeDuplicateNodeForPlan
 	ErrCodeInvalidMessage
 	ErrCodeInvalidNodeStatus
+	ErrCodeInvalidProviderStatus
 	ErrCodeLeaseForNodeByProviderNotFound
 	ErrCodeLeaseNotFound
 	ErrCodeNodeForPlanNotFound
@@ -25,6 +26,7 @@ var (
 	ErrDuplicateNodeForPlan           = sdkerrors.Register(ModuleName, ErrCodeDuplicateNodeForPlan, "duplicate node for plan")
 	ErrInvalidMessage                 = sdkerrors.Register(ModuleName, ErrCodeInvalidMessage, "invalid message")
 	ErrInvalidNodeStatus              = sdkerrors.Register(ModuleName, ErrCodeInvalidNodeStatus, "invalid node status")
+	ErrInvalidProviderStatus          = sdkerrors.Register(ModuleName, ErrCodeInvalidProviderStatus, "invalid provider status")
 	ErrLeaseForNodeByProviderNotFound = sdkerrors.Register(ModuleName, ErrCodeLeaseForNodeByProviderNotFound, "lease for node by provider not found")
 	ErrLeaseNotFound                  = sdkerrors.Register(ModuleName, ErrCodeLeaseNotFound, "lease not found")
 	ErrNodeForPlanNotFound            = sdkerrors.Register(ModuleName, ErrCodeNodeForPlanNotFound, "node for plan not found")
@@ -49,6 +51,11 @@ func NewErrorInvalidNodeStatus(addr base.NodeAddress, status v1base.Status) erro
 	return sdkerrors.Wrapf(ErrInvalidNodeStatus, "invalid status %s for node %s", status, addr)
 }
 
+// NewErrorInvalidProviderStatus returns an error indicating that the provided status is invalid for the given provider.
+func NewErrorInvalidProviderStatus(addr base.ProvAddress, status v1base.Status) error {
+	return sdkerrors.Wrapf(ErrInvalidProviderStatus, "invalid status %s for provider %s", status, addr)
+}
+
 // NewErrorLeaseForNodeByProviderNotFound returns an error indicating that the specified lease does not exist.
 func NewErrorLeaseForNodeByProviderNotFound(nodeAddr base.NodeAddress, provAddr base.ProvAddress) error {
 	return sdkerrors.Wrapf(ErrLeaseForNodeByProviderNotFound, "lease for node %s by provider %s does not exist", nodeAddr, provAddr)

x/subscription/keeper/msg_handler.go

@@ -466,15 +466,6 @@ func (k *Keeper) HandleMsgStartSession(ctx sdk.Context, msg *v3.MsgStartSessionR
 		return nil, err
 	}
 
-	node, found := k.GetNode(ctx, nodeAddr)
-	if !found {
-		return nil, types.NewErrorNodeNotFound(nodeAddr)
-	}
-
-	if !node.Status.Equal(v1base.StatusActive) {
-		return nil, types.NewErrorInvalidNodeStatus(nodeAddr, node.Status)
-	}
-
 	// Ensure the node is authorized to serve this plan
 	if !k.HasNodeForPlan(ctx, subscription.PlanID, nodeAddr) {
 		return nil, types.NewErrorNodeForPlanNotFound(subscription.PlanID, nodeAddr)