feat: add parsePriceFeedUpdatesWithSlots to Pyth contract

Author: tejasbadadare

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

@@ -173,16 +173,19 @@ abstract contract Scheduler is IScheduler, SchedulerState {
         // Parse price feed updates with an expected timestamp range of [-10s, now]
         // We will validate the trigger conditions and timestamps ourselves
         // using the returned PriceFeeds.
-        uint64 maxPublishTime = SafeCast.toUint64(block.timestamp);
-        uint64 minPublishTime = maxPublishTime - 10 seconds;
-        PythStructs.PriceFeed[] memory priceFeeds = pyth.parsePriceFeedUpdates{
+        uint64 maxPublishTime = SafeCast.toUint64(block.timestamp) +
+            FUTURE_TIMESTAMP_GRACE_PERIOD;
+        uint64 minPublishTime = maxPublishTime - PAST_TIMESTAMP_GRACE_PERIOD;
+        PythStructs.PriceFeed[] memory priceFeeds;
+        uint64[] memory slots;
+        (priceFeeds, slots) = pyth.parsePriceFeedUpdatesWithSlots{
             value: pythFee
         }(updateData, priceIds, minPublishTime, maxPublishTime);
 
-        // Verify all price feeds have the same timestamp
-        uint256 timestamp = priceFeeds[0].price.publishTime;
-        for (uint8 i = 1; i < priceFeeds.length; i++) {
-            if (priceFeeds[i].price.publishTime != timestamp) {
+        // Verify all price feeds have the same Pythnet slot
+        uint64 slot = slots[0];
+        for (uint8 i = 1; i < slots.length; i++) {
+            if (slots[i] != slot) {
                 revert PriceTimestampMismatch();
             }
         }

target_chains/ethereum/contracts/contracts/pyth/Pyth.sol

@@ -179,111 +179,174 @@ abstract contract Pyth is
         if (price.publishTime == 0) revert PythErrors.PriceFeedNotFound();
     }
 
+    /// Internal struct to hold parameters for update processing
+    /// @dev Storing these variable in a struct rather than local variables
+    /// helps reduce stack depth.
+    struct UpdateProcessingContext {
+        bytes32[] priceIds;
+        uint64 minPublishTime;
+        uint64 maxPublishTime;
+        bool checkUniqueness;
+        PythStructs.PriceFeed[] priceFeeds;
+        uint64[] slots;
+    }
+
+    /// The initial Merkle header data in an updateData. The encoded bytes
+    /// are kept in calldata for gas efficiency.
+    /// @dev Storing these variable in a struct rather than local variables
+    /// helps reduce stack depth.
+    struct MerkleData {
+        bytes20 digest;
+        uint8 numUpdates;
+        uint64 slot;
+    }
+
+    /// @dev Helper function to process a single price update within a Merkle proof.
+    function _processSingleMerkleUpdate(
+        MerkleData memory merkleData,
+        bytes calldata encoded,
+        uint offset,
+        UpdateProcessingContext memory context
+    ) internal pure returns (uint newOffset) {
+        PythInternalStructs.PriceInfo memory priceInfo;
+        bytes32 priceId;
+        uint64 prevPublishTime;
+
+        (
+            newOffset,
+            priceInfo,
+            priceId,
+            prevPublishTime
+        ) = extractPriceInfoFromMerkleProof(merkleData.digest, encoded, offset);
+
+        uint k = 0;
+        for (; k < context.priceIds.length; k++) {
+            if (context.priceIds[k] == priceId) {
+                break;
+            }
+        }
+
+        // Check if the priceId was requested and not already filled
+        if (k < context.priceIds.length && context.priceFeeds[k].id == 0) {
+            uint publishTime = uint(priceInfo.publishTime);
+            if (
+                publishTime >= context.minPublishTime &&
+                publishTime <= context.maxPublishTime &&
+                (!context.checkUniqueness ||
+                    context.minPublishTime > prevPublishTime)
+            ) {
+                context.priceFeeds[k].id = priceId;
+                context.priceFeeds[k].price.price = priceInfo.price;
+                context.priceFeeds[k].price.conf = priceInfo.conf;
+                context.priceFeeds[k].price.expo = priceInfo.expo;
+                context.priceFeeds[k].price.publishTime = publishTime;
+                context.priceFeeds[k].emaPrice.price = priceInfo.emaPrice;
+                context.priceFeeds[k].emaPrice.conf = priceInfo.emaConf;
+                context.priceFeeds[k].emaPrice.expo = priceInfo.expo;
+                context.priceFeeds[k].emaPrice.publishTime = publishTime;
+                context.slots[k] = merkleData.slot;
+            }
+        }
+    }
+
+    /// @dev Processes a single entry from the updateData array.
+    function _processSingleUpdateDataBlob(
+        bytes calldata singleUpdateData,
+        UpdateProcessingContext memory context
+    ) internal view {
+        // Check magic number and length first
+        if (
+            singleUpdateData.length <= 4 ||
+            UnsafeCalldataBytesLib.toUint32(singleUpdateData, 0) !=
+            ACCUMULATOR_MAGIC
+        ) {
+            revert PythErrors.InvalidUpdateData();
+        }
+
+        uint offset;
+        {
+            UpdateType updateType;
+            (offset, updateType) = extractUpdateTypeFromAccumulatorHeader(
+                singleUpdateData
+            );
+
+            if (updateType != UpdateType.WormholeMerkle) {
+                revert PythErrors.InvalidUpdateData();
+            }
+        }
+
+        // Extract Merkle data
+        MerkleData memory merkleData;
+        bytes calldata encoded;
+        (
+            offset,
+            merkleData.digest,
+            merkleData.numUpdates,
+            encoded,
+            merkleData.slot
+        ) = extractWormholeMerkleHeaderDigestAndNumUpdatesAndEncodedAndSlotFromAccumulatorUpdate(
+            singleUpdateData,
+            offset
+        );
+
+        // Process each update within the Merkle proof
+        for (uint j = 0; j < merkleData.numUpdates; j++) {
+            offset = _processSingleMerkleUpdate(
+                merkleData,
+                encoded,
+                offset,
+                context
+            );
+        }
+
+        // Check final offset
+        if (offset != encoded.length) {
+            revert PythErrors.InvalidUpdateData();
+        }
+    }
+
     function parsePriceFeedUpdatesInternal(
         bytes[] calldata updateData,
         bytes32[] calldata priceIds,
         PythInternalStructs.ParseConfig memory config
-    ) internal returns (PythStructs.PriceFeed[] memory priceFeeds) {
+    )
+        internal
+        returns (
+            PythStructs.PriceFeed[] memory priceFeeds,
+            uint64[] memory slots
+        )
+    {
         {
             uint requiredFee = getUpdateFee(updateData);
             if (msg.value < requiredFee) revert PythErrors.InsufficientFee();
         }
-        unchecked {
-            priceFeeds = new PythStructs.PriceFeed[](priceIds.length);
-            for (uint i = 0; i < updateData.length; i++) {
-                if (
-                    updateData[i].length > 4 &&
-                    UnsafeCalldataBytesLib.toUint32(updateData[i], 0) ==
-                    ACCUMULATOR_MAGIC
-                ) {
-                    uint offset;
-                    {
-                        UpdateType updateType;
-                        (
-                            offset,
-                            updateType
-                        ) = extractUpdateTypeFromAccumulatorHeader(
-                            updateData[i]
-                        );
-
-                        if (updateType != UpdateType.WormholeMerkle) {
-                            revert PythErrors.InvalidUpdateData();
-                        }
-                    }
 
-                    bytes20 digest;
-                    uint8 numUpdates;
-                    bytes calldata encoded;
-                    (
-                        offset,
-                        digest,
-                        numUpdates,
-                        encoded
-                    ) = extractWormholeMerkleHeaderDigestAndNumUpdatesAndEncodedFromAccumulatorUpdate(
-                        updateData[i],
-                        offset
-                    );
+        // Create the context struct that holds all shared parameters
+        UpdateProcessingContext memory context;
+        context.priceIds = priceIds;
+        context.minPublishTime = config.minPublishTime;
+        context.maxPublishTime = config.maxPublishTime;
+        context.checkUniqueness = config.checkUniqueness;
+        context.priceFeeds = new PythStructs.PriceFeed[](priceIds.length);
+        context.slots = new uint64[](priceIds.length);
 
-                    for (uint j = 0; j < numUpdates; j++) {
-                        PythInternalStructs.PriceInfo memory priceInfo;
-                        bytes32 priceId;
-                        uint64 prevPublishTime;
-                        (
-                            offset,
-                            priceInfo,
-                            priceId,
-                            prevPublishTime
-                        ) = extractPriceInfoFromMerkleProof(
-                            digest,
-                            encoded,
-                            offset
-                        );
-                        {
-                            // check whether caller requested for this data
-                            uint k = findIndexOfPriceId(priceIds, priceId);
-
-                            // If priceFeed[k].id != 0 then it means that there was a valid
-                            // update for priceIds[k] and we don't need to process this one.
-                            if (k == priceIds.length || priceFeeds[k].id != 0) {
-                                continue;
-                            }
-
-                            uint publishTime = uint(priceInfo.publishTime);
-                            // Check the publish time of the price is within the given range
-                            // and only fill the priceFeedsInfo if it is.
-                            // If is not, default id value of 0 will still be set and
-                            // this will allow other updates for this price id to be processed.
-                            if (
-                                publishTime >= config.minPublishTime &&
-                                publishTime <= config.maxPublishTime &&
-                                (!config.checkUniqueness ||
-                                    config.minPublishTime > prevPublishTime)
-                            ) {
-                                fillPriceFeedFromPriceInfo(
-                                    priceFeeds,
-                                    k,
-                                    priceId,
-                                    priceInfo,
-                                    publishTime
-                                );
-                            }
-                        }
-                    }
-                    if (offset != encoded.length)
-                        revert PythErrors.InvalidUpdateData();
-                } else {
-                    revert PythErrors.InvalidUpdateData();
-                }
+        unchecked {
+            // Process each update, passing the context struct
+            for (uint i = 0; i < updateData.length; i++) {
+                _processSingleUpdateDataBlob(updateData[i], context);
             }
+        }
 
-            for (uint k = 0; k < priceIds.length; k++) {
-                if (priceFeeds[k].id == 0) {
-                    revert PythErrors.PriceFeedNotFoundWithinRange();
-                }
+        // Check all price feeds were found
+        for (uint k = 0; k < priceIds.length; k++) {
+            if (context.priceFeeds[k].id == 0) {
+                revert PythErrors.PriceFeedNotFoundWithinRange();
             }
         }
-    }
 
+        // Return results
+        return (context.priceFeeds, context.slots);
+    }
     function parsePriceFeedUpdates(
         bytes[] calldata updateData,
         bytes32[] calldata priceIds,
@@ -294,6 +357,33 @@ abstract contract Pyth is
         payable
         override
         returns (PythStructs.PriceFeed[] memory priceFeeds)
+    {
+        (priceFeeds, ) = parsePriceFeedUpdatesInternal(
+            updateData,
+            priceIds,
+            PythInternalStructs.ParseConfig(
+                minPublishTime,
+                maxPublishTime,
+                false
+            )
+        );
+    }
+
+    /// @dev Same as `parsePriceFeedUpdates`, but also returns the Pythnet slot
+    /// associated with each price update.
+    function parsePriceFeedUpdatesWithSlots(
+        bytes[] calldata updateData,
+        bytes32[] calldata priceIds,
+        uint64 minPublishTime,
+        uint64 maxPublishTime
+    )
+        external
+        payable
+        override
+        returns (
+            PythStructs.PriceFeed[] memory priceFeeds,
+            uint64[] memory slots
+        )
     {
         return
             parsePriceFeedUpdatesInternal(
@@ -339,8 +429,10 @@ abstract contract Pyth is
             offset,
             digest,
             numUpdates,
-            encoded
-        ) = extractWormholeMerkleHeaderDigestAndNumUpdatesAndEncodedFromAccumulatorUpdate(
+            encoded,
+            // slot ignored
+
+        ) = extractWormholeMerkleHeaderDigestAndNumUpdatesAndEncodedAndSlotFromAccumulatorUpdate(
             updateData,
             offset
         );
@@ -477,16 +569,15 @@ abstract contract Pyth is
         override
         returns (PythStructs.PriceFeed[] memory priceFeeds)
     {
-        return
-            parsePriceFeedUpdatesInternal(
-                updateData,
-                priceIds,
-                PythInternalStructs.ParseConfig(
-                    minPublishTime,
-                    maxPublishTime,
-                    true
-                )
-            );
+        (priceFeeds, ) = parsePriceFeedUpdatesInternal(
+            updateData,
+            priceIds,
+            PythInternalStructs.ParseConfig(
+                minPublishTime,
+                maxPublishTime,
+                true
+            )
+        );
     }
 
     function getTotalFee(
@@ -514,7 +605,9 @@ abstract contract Pyth is
         uint k,
         bytes32 priceId,
         PythInternalStructs.PriceInfo memory info,
-        uint publishTime
+        uint publishTime,
+        uint64[] memory slots,
+        uint64 slot
     ) private pure {
         priceFeeds[k].id = priceId;
         priceFeeds[k].price.price = info.price;
@@ -525,6 +618,7 @@ abstract contract Pyth is
         priceFeeds[k].emaPrice.conf = info.emaConf;
         priceFeeds[k].emaPrice.expo = info.expo;
         priceFeeds[k].emaPrice.publishTime = publishTime;
+        slots[k] = slot;
     }
 
     function queryPriceFeed(
@@ -555,7 +649,7 @@ abstract contract Pyth is
     }
 
     function version() public pure returns (string memory) {
-        return "1.4.4-alpha.4";
+        return "1.4.4-alpha.5";
     }
 
     function calculateTwap(