fix: overflow, DRY

Author: tejasbadadare

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

@@ -673,7 +673,7 @@ abstract contract Scheduler is IScheduler, SchedulerState {
     ) external pure override returns (uint256 minimumBalanceInWei) {
         // Placeholder implementation
         // TODO: make this governable
-        return numPriceFeeds * 1 wei;
+        return uint256(numPriceFeeds) * 0.01 ether;
     }
 
     // ACCESS CONTROL MODIFIERS

target_chains/ethereum/contracts/forge-test/PulseSchedulerGasBenchmark.t.sol

@@ -17,69 +17,44 @@ import "./utils/PulseSchedulerTestUtils.t.sol";
 contract PulseSchedulerGasBenchmark is Test, PulseSchedulerTestUtils {
     ERC1967Proxy public proxy;
     SchedulerUpgradeable public scheduler;
-    address public owner;
+    address public manager;
     address public admin;
     address public pyth;
-    address public pusher;
 
     // Constants
-    uint96 constant PYTH_FEE = 1 wei;
+    uint96 constant PYTH_FEE = 10 wei;
 
     function setUp() public {
-        owner = address(1);
+        manager = address(1);
         admin = address(2);
         pyth = address(3);
-        pusher = address(4);
 
         SchedulerUpgradeable _scheduler = new SchedulerUpgradeable();
         proxy = new ERC1967Proxy(address(_scheduler), "");
         scheduler = SchedulerUpgradeable(address(proxy));
 
-        scheduler.initialize(owner, admin, pyth);
+        scheduler.initialize(manager, admin, pyth);
 
         // Start tests at a high timestamp to avoid underflow when we set
         // `minPublishTime = timestamp - 1 hour` in updatePriceFeeds
         vm.warp(100000);
 
-        // Give pusher and owner 1000 ETH for testing
-        vm.deal(pusher, 1000 ether);
-        vm.deal(owner, 1000 ether);
+        // Give manager 1000 ETH for testing
+        vm.deal(manager, 1000 ether);
     }
 
     // Helper function to run the price feed update benchmark with a specified number of feeds
     function _runUpdateAndQueryPriceFeedsBenchmark(uint8 numFeeds) internal {
-        // Setup: Create subscription and initial price update
-        vm.prank(owner);
-        uint256 subscriptionId = addTestSubscriptionWithFeeds(
-            scheduler,
-            numFeeds,
-            address(owner)
-        );
-
-        // Fetch the price IDS
+        // Setup: Create subscription and perform initial update
+        vm.prank(manager);
+        uint256 subscriptionId = _setupSubscriptionWithInitialUpdate(numFeeds);
         (SchedulerState.SubscriptionParams memory params, ) = scheduler
             .getSubscription(subscriptionId);
-        bytes32[] memory priceIds = params.priceIds;
-
-        // Create initial price feed updates
-        uint64 publishTime = SafeCast.toUint64(block.timestamp);
-        PythStructs.PriceFeed[] memory priceFeeds;
-        uint64[] memory slots;
-
-        (priceFeeds, slots) = createMockPriceFeedsWithSlots(
-            publishTime,
-            numFeeds
-        );
-
-        mockParsePriceFeedUpdatesWithSlots(pyth, priceFeeds, slots);
-        bytes[] memory updateData1 = createMockUpdateData(priceFeeds);
-        vm.prank(pusher);
-        scheduler.updatePriceFeeds(subscriptionId, updateData1, priceIds);
 
         // Advance time to meet heartbeat criteria
         vm.warp(block.timestamp + 100);
 
-        // Create new price feed updates with updated timestamp and prices
+        // Create new price feed updates with updated timestamp
         uint64 newPublishTime = SafeCast.toUint64(block.timestamp);
         PythStructs.PriceFeed[] memory newPriceFeeds;
         uint64[] memory newSlots;
@@ -89,24 +64,16 @@ contract PulseSchedulerGasBenchmark is Test, PulseSchedulerTestUtils {
             numFeeds
         );
 
-        // Apply price deviation to ensure update criteria is met
-        for (uint i = 0; i < numFeeds; i++) {
-            // Apply a 200 bps price increase (satisfies update criteria)
-            int64 priceDiff = int64(
-                (uint64(newPriceFeeds[i].price.price) * 200) / 10_000
-            );
-            newPriceFeeds[i].price.price =
-                newPriceFeeds[i].price.price +
-                priceDiff;
-        }
-
+        // Mock Pyth response for the benchmark
         mockParsePriceFeedUpdatesWithSlots(pyth, newPriceFeeds, newSlots);
-        bytes[] memory updateData2 = createMockUpdateData(newPriceFeeds);
 
         // Actual benchmark: Measure gas for updating price feeds
-        vm.prank(pusher);
         uint256 startGas = gasleft();
-        scheduler.updatePriceFeeds(subscriptionId, updateData2, priceIds);
+        scheduler.updatePriceFeeds(
+            subscriptionId,
+            createMockUpdateData(newPriceFeeds),
+            params.priceIds
+        );
         uint256 updateGasUsed = startGas - gasleft();
 
         console.log(
@@ -117,7 +84,7 @@ contract PulseSchedulerGasBenchmark is Test, PulseSchedulerTestUtils {
 
         // Benchmark querying the price feeds after updating
         uint256 queryStartGas = gasleft();
-        scheduler.getPricesUnsafe(subscriptionId, priceIds);
+        scheduler.getPricesUnsafe(subscriptionId, params.priceIds);
         uint256 queryGasUsed = queryStartGas - gasleft();
 
         console.log(
@@ -132,52 +99,60 @@ contract PulseSchedulerGasBenchmark is Test, PulseSchedulerTestUtils {
         );
     }
 
+    // Helper function to set up a subscription with initial price update
+    function _setupSubscriptionWithInitialUpdate(
+        uint8 numFeeds
+    ) internal returns (uint256) {
+        uint256 subscriptionId = addTestSubscriptionWithFeeds(
+            scheduler,
+            numFeeds,
+            address(manager)
+        );
+
+        // Fetch the price IDs
+        (SchedulerState.SubscriptionParams memory params, ) = scheduler
+            .getSubscription(subscriptionId);
+
+        // Create initial price feed updates
+        uint64 publishTime = SafeCast.toUint64(block.timestamp);
+        PythStructs.PriceFeed[] memory priceFeeds;
+        uint64[] memory slots;
+
+        (priceFeeds, slots) = createMockPriceFeedsWithSlots(
+            publishTime,
+            numFeeds
+        );
+
+        mockParsePriceFeedUpdatesWithSlots(pyth, priceFeeds, slots);
+        bytes[] memory updateData = createMockUpdateData(priceFeeds);
+
+        scheduler.updatePriceFeeds(subscriptionId, updateData, params.priceIds);
+        return subscriptionId;
+    }
+
+    // Helper function to create updated price feeds for benchmark
+    function _createUpdatedPriceFeeds(
+        uint8 numFeeds
+    ) internal returns (PythStructs.PriceFeed[] memory, uint64[] memory) {}
+
     /// Helper function for benchmarking querying active subscriptions with a specified number of total subscriptions.
     /// Half of them will be inactive to simulate gaps in the subscriptions list.
     /// Keepers will poll this function to get the list of active subscriptions.
     function _runGetActiveSubscriptionsBenchmark(
         uint256 numSubscriptions
     ) internal {
-        // Setup: Create subscriptions and then deactivate every other one.
-        vm.startPrank(owner);
+        // Setup: As manager, create subscriptions and then deactivate every other one.
+        vm.startPrank(manager);
 
         // Array to store subscription IDs
         uint256[] memory subscriptionIds = new uint256[](numSubscriptions);
 
-        // First create all subscriptions as active with 2 price feeds
+        // First create all subscriptions as active (with default 2 price feeds)
         for (uint256 i = 0; i < numSubscriptions; i++) {
-            bytes32[] memory priceIds = createPriceIds();
-            address[] memory readerWhitelist = new address[](0);
-
-            SchedulerState.UpdateCriteria memory updateCriteria = SchedulerState
-                .UpdateCriteria({
-                    updateOnHeartbeat: true,
-                    heartbeatSeconds: 60,
-                    updateOnDeviation: true,
-                    deviationThresholdBps: 100
-                });
-
-            SchedulerState.GasConfig memory gasConfig = SchedulerState
-                .GasConfig({
-                    maxBaseFeeMultiplierCapPct: 10_000,
-                    maxPriorityFeeMultiplierCapPct: 10_000
-                });
-
-            SchedulerState.SubscriptionParams memory params = SchedulerState
-                .SubscriptionParams({
-                    priceIds: priceIds,
-                    readerWhitelist: readerWhitelist,
-                    whitelistEnabled: false,
-                    isActive: true, // All start as active
-                    isPermanent: false,
-                    updateCriteria: updateCriteria,
-                    gasConfig: gasConfig
-                });
-
-            uint256 minimumBalance = scheduler.getMinimumBalance(2);
-            subscriptionIds[i] = scheduler.createSubscription{
-                value: minimumBalance
-            }(params);
+            subscriptionIds[i] = addTestSubscription(
+                scheduler,
+                address(manager)
+            );
         }
 
         // Deactivate every other subscription
@@ -198,7 +173,7 @@ contract PulseSchedulerGasBenchmark is Test, PulseSchedulerTestUtils {
 
         console.log(
             "Gas used for fetching %s active subscriptions out of %s total: %s",
-            vm.toString((numSubscriptions + 1) / 2), // Only half are active (rounded up)
+            vm.toString((numSubscriptions + 1) / 2),
             vm.toString(numSubscriptions),
             vm.toString(gasUsed)
         );