feat: impl min bal and refactor subscription mgmt

Co-Authored-By: Tejas Badadare <[email protected]>

Author: devin-ai-integration[bot]

target_chains/ethereum/contracts/contracts/pulse/scheduler/IScheduler.sol

@@ -14,10 +14,11 @@ interface IScheduler is SchedulerEvents {
      * @notice Adds a new subscription
      * @param subscriptionParams The parameters for the subscription
      * @return subscriptionId The ID of the newly created subscription
+     * @dev Requires msg.value to be at least the minimum balance for the subscription
      */
     function addSubscription(
         SchedulerState.SubscriptionParams calldata subscriptionParams
-    ) external returns (uint256 subscriptionId);
+    ) external payable returns (uint256 subscriptionId);
 
     /**
      * @notice Gets a subscription's parameters and status
@@ -43,13 +44,9 @@ interface IScheduler is SchedulerEvents {
     function updateSubscription(
         uint256 subscriptionId,
         SchedulerState.SubscriptionParams calldata newSubscriptionParams
-    ) external;
+    ) external payable;
 
-    /**
-     * @notice Deactivates a subscription
-     * @param subscriptionId The ID of the subscription to deactivate
-     */
-    function deactivateSubscription(uint256 subscriptionId) external;
+    // Deactivation is now handled through updateSubscription by setting isActive to false
 
     /**
      * @notice Updates price feeds for a subscription.
@@ -116,7 +113,7 @@ interface IScheduler is SchedulerEvents {
      */
     function getMinimumBalance(
         uint8 numPriceFeeds
-    ) external returns (uint256 minimumBalance);
+    ) external view returns (uint256 minimumBalance);
 
     /**
      * @notice Gets all active subscriptions with their parameters

target_chains/ethereum/contracts/contracts/pulse/scheduler/Scheduler.sol

@@ -22,7 +22,7 @@ abstract contract Scheduler is IScheduler, SchedulerState {
 
     function addSubscription(
         SubscriptionParams memory subscriptionParams
-    ) external override returns (uint256 subscriptionId) {
+    ) external payable override returns (uint256 subscriptionId) {
         if (subscriptionParams.priceIds.length > MAX_PRICE_IDS) {
             revert TooManyPriceIds(
                 subscriptionParams.priceIds.length,
@@ -51,6 +51,17 @@ abstract contract Scheduler is IScheduler, SchedulerState {
                 .maxGasMultiplierCapPct = DEFAULT_MAX_GAS_MULTIPLIER_CAP_PCT;
         }
 
+        // Calculate minimum balance required for this subscription
+        uint256 minimumBalance = this.getMinimumBalance(uint8(subscriptionParams.priceIds.length));
+        
+        // Ensure enough funds were provided
+        if (msg.value < minimumBalance) {
+            revert InsufficientBalance();
+        }
+
+        // Set subscription to active
+        subscriptionParams.isActive = true;
+
         subscriptionId = _state.subscriptionNumber++;
 
         // Store the subscription parameters
@@ -61,7 +72,7 @@ abstract contract Scheduler is IScheduler, SchedulerState {
             subscriptionId
         ];
         status.priceLastUpdatedAt = 0;
-        status.balanceInWei = 0;
+        status.balanceInWei = msg.value;
         status.totalUpdates = 0;
         status.totalSpent = 0;
         status.isActive = true;
@@ -93,11 +104,20 @@ abstract contract Scheduler is IScheduler, SchedulerState {
     function updateSubscription(
         uint256 subscriptionId,
         SubscriptionParams memory newSubscriptionParams
-    ) external override onlyManager(subscriptionId) {
-        if (!_state.subscriptionStatuses[subscriptionId].isActive) {
-            revert InactiveSubscription();
+    ) external payable override onlyManager(subscriptionId) {
+        SubscriptionStatus storage status = _state.subscriptionStatuses[subscriptionId];
+        bool wasActive = status.isActive;
+        bool willBeActive = newSubscriptionParams.isActive;
+        
+        // If subscription is inactive and will remain inactive, no need to validate parameters
+        if (!wasActive && !willBeActive) {
+            // Update subscription parameters
+            _state.subscriptionParams[subscriptionId] = newSubscriptionParams;
+            emit SubscriptionUpdated(subscriptionId);
+            return;
         }
-
+        
+        // Validate parameters for active or to-be-activated subscriptions
         if (newSubscriptionParams.priceIds.length > MAX_PRICE_IDS) {
             revert TooManyPriceIds(
                 newSubscriptionParams.priceIds.length,
@@ -125,24 +145,35 @@ abstract contract Scheduler is IScheduler, SchedulerState {
                 .gasConfig
                 .maxGasMultiplierCapPct = DEFAULT_MAX_GAS_MULTIPLIER_CAP_PCT;
         }
+        
+        // Handle activation/deactivation
+        if (!wasActive && willBeActive) {
+            // Reactivating a subscription - ensure minimum balance
+            uint256 minimumBalance = this.getMinimumBalance(uint8(newSubscriptionParams.priceIds.length));
+            
+            // Add any funds sent with this transaction
+            status.balanceInWei += msg.value;
+            
+            // Check if balance meets minimum requirement
+            if (status.balanceInWei < minimumBalance) {
+                revert InsufficientBalance();
+            }
+            
+            status.isActive = true;
+            emit SubscriptionActivated(subscriptionId);
+        } else if (wasActive && !willBeActive) {
+            // Deactivating a subscription
+            status.isActive = false;
+            emit SubscriptionDeactivated(subscriptionId);
+        }
 
         // Update subscription parameters
         _state.subscriptionParams[subscriptionId] = newSubscriptionParams;
 
         emit SubscriptionUpdated(subscriptionId);
     }
 
-    function deactivateSubscription(
-        uint256 subscriptionId
-    ) external override onlyManager(subscriptionId) {
-        if (!_state.subscriptionStatuses[subscriptionId].isActive) {
-            revert InactiveSubscription();
-        }
-
-        _state.subscriptionStatuses[subscriptionId].isActive = false;
-
-        emit SubscriptionDeactivated(subscriptionId);
-    }
+    // Removed standalone deactivateSubscription function as it's now handled in updateSubscription
 
     function updatePriceFeeds(
         uint256 subscriptionId,
@@ -439,11 +470,22 @@ abstract contract Scheduler is IScheduler, SchedulerState {
         SubscriptionStatus storage status = _state.subscriptionStatuses[
             subscriptionId
         ];
+        SubscriptionParams storage params = _state.subscriptionParams[
+            subscriptionId
+        ];
 
         if (status.balanceInWei < amount) {
             revert InsufficientBalance();
         }
 
+        // If subscription is active, ensure minimum balance is maintained
+        if (status.isActive) {
+            uint256 minimumBalance = this.getMinimumBalance(uint8(params.priceIds.length));
+            if (status.balanceInWei - amount < minimumBalance) {
+                revert InsufficientBalance();
+            }
+        }
+
         status.balanceInWei -= amount;
 
         (bool sent, ) = msg.sender.call{value: amount}("");

target_chains/ethereum/contracts/contracts/pulse/scheduler/SchedulerEvents.sol

@@ -10,5 +10,6 @@ interface SchedulerEvents {
     );
     event SubscriptionUpdated(uint256 indexed subscriptionId);
     event SubscriptionDeactivated(uint256 indexed subscriptionId);
+    event SubscriptionActivated(uint256 indexed subscriptionId);
     event PricesUpdated(uint256 indexed subscriptionId, uint256 timestamp);
 }

target_chains/ethereum/contracts/contracts/pulse/scheduler/SchedulerState.sol

@@ -32,6 +32,7 @@ contract SchedulerState {
         bytes32[] priceIds;
         address[] readerWhitelist;
         bool whitelistEnabled;
+        bool isActive;
         UpdateCriteria updateCriteria;
         GasConfig gasConfig;
     }

target_chains/ethereum/contracts/contracts/pulse/scheduler/SchedulerUpgradeable.sol

@@ -61,4 +61,16 @@ contract SchedulerUpgradeable is
     function version() public pure returns (string memory) {
         return "1.0.0";
     }
+    
+    // Implementation of deactivateSubscription that forwards to updateSubscription
+    function deactivateSubscription(uint256 subscriptionId) external onlyManager(subscriptionId) {
+        // Get current subscription parameters
+        SchedulerState.SubscriptionParams memory params = _state.subscriptionParams[subscriptionId];
+        
+        // Set isActive to false
+        params.isActive = false;
+        
+        // Call updateSubscription to handle the deactivation
+        this.updateSubscription(subscriptionId, params);
+    }
 }