refactor: Optional storage flag when parsing price feed updates

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

@@ -308,11 +308,14 @@ abstract contract Scheduler is IScheduler, SchedulerState, SchedulerConstants {
         (
             PythStructs.PriceFeed[] memory priceFeeds,
             uint64[] memory slots
-        ) = pyth.parsePriceFeedUpdatesWithSlotsStrict{value: pythFee}(
+        ) = pyth.parsePriceFeedUpdatesWithConfig{value: pythFee}(
                 updateData,
                 params.priceIds,
                 0, // We enforce the past max validity ourselves in _validateShouldUpdatePrices
-                curTime + FUTURE_TIMESTAMP_MAX_VALIDITY_PERIOD
+                curTime + FUTURE_TIMESTAMP_MAX_VALIDITY_PERIOD,
+                false,
+                true,
+                false
             );
 
         // Verify all price feeds have the same Pythnet slot.

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

@@ -317,34 +317,36 @@ abstract contract Pyth is
         return merkleData.numUpdates;
     }
 
-    function parsePriceFeedUpdatesInternal(
+    function parsePriceFeedUpdatesWithConfig(
         bytes[] calldata updateData,
         bytes32[] calldata priceIds,
         uint64 minAllowedPublishTime,
         uint64 maxAllowedPublishTime,
         bool checkUniqueness,
-        bool checkUpdateDataIsMinimal
+        bool checkUpdateDataIsMinimal,
+        bool storeUpdatesIfFresh
     )
-        internal
+        public
+        payable
         returns (
             PythStructs.PriceFeed[] memory priceFeeds,
             uint64[] memory slots
         )
     {
-        {
-            uint requiredFee = getUpdateFee(updateData);
-            if (msg.value < requiredFee) revert PythErrors.InsufficientFee();
-        }
+        if (msg.value < getUpdateFee(updateData))
+            revert PythErrors.InsufficientFee();
 
         // Create the context struct that holds all shared parameters
-        PythInternalStructs.UpdateParseContext memory context;
-        context.priceIds = priceIds;
-        context.minAllowedPublishTime = minAllowedPublishTime;
-        context.maxAllowedPublishTime = maxAllowedPublishTime;
-        context.checkUniqueness = checkUniqueness;
-        context.checkUpdateDataIsMinimal = checkUpdateDataIsMinimal;
-        context.priceFeeds = new PythStructs.PriceFeed[](priceIds.length);
-        context.slots = new uint64[](priceIds.length);
+        PythInternalStructs.UpdateParseContext
+            memory context = PythInternalStructs.UpdateParseContext({
+                priceIds: priceIds,
+                minAllowedPublishTime: minAllowedPublishTime,
+                maxAllowedPublishTime: maxAllowedPublishTime,
+                checkUniqueness: checkUniqueness,
+                checkUpdateDataIsMinimal: checkUpdateDataIsMinimal,
+                priceFeeds: new PythStructs.PriceFeed[](priceIds.length),
+                slots: new uint64[](priceIds.length)
+            });
 
         // Track total updates for minimal update data check
         uint64 totalUpdatesAcrossBlobs = 0;
@@ -358,6 +360,23 @@ abstract contract Pyth is
                     context
                 );
             }
+
+            for (uint j = 0; j < priceIds.length; j++) {
+                PythStructs.PriceFeed memory pf = context.priceFeeds[j];
+                if (storeUpdatesIfFresh && pf.id != 0) {
+                    updateLatestPriceIfNecessary(
+                        priceIds[j],
+                        PythInternalStructs.PriceInfo({
+                            publishTime: uint64(pf.price.publishTime),
+                            expo: pf.price.expo,
+                            price: pf.price.price,
+                            conf: pf.price.conf,
+                            emaPrice: pf.emaPrice.price,
+                            emaConf: pf.emaPrice.conf
+                        })
+                    );
+                }
+            }
         }
 
         // In minimal update data mode, revert if we have more or less updates than price IDs
@@ -378,6 +397,7 @@ abstract contract Pyth is
         // Return results
         return (context.priceFeeds, context.slots);
     }
+
     function parsePriceFeedUpdates(
         bytes[] calldata updateData,
         bytes32[] calldata priceIds,
@@ -389,41 +409,17 @@ abstract contract Pyth is
         override
         returns (PythStructs.PriceFeed[] memory priceFeeds)
     {
-        (priceFeeds, ) = parsePriceFeedUpdatesInternal(
+        (priceFeeds, ) = parsePriceFeedUpdatesWithConfig(
             updateData,
             priceIds,
             minPublishTime,
             maxPublishTime,
             false,
+            false,
             false
         );
     }
 
-    function parsePriceFeedUpdatesWithSlotsStrict(
-        bytes[] calldata updateData,
-        bytes32[] calldata priceIds,
-        uint64 minPublishTime,
-        uint64 maxPublishTime
-    )
-        external
-        payable
-        override
-        returns (
-            PythStructs.PriceFeed[] memory priceFeeds,
-            uint64[] memory slots
-        )
-    {
-        return
-            parsePriceFeedUpdatesInternal(
-                updateData,
-                priceIds,
-                minPublishTime,
-                maxPublishTime,
-                false,
-                true
-            );
-    }
-
     function extractTwapPriceInfos(
         bytes calldata updateData
     )
@@ -624,12 +620,13 @@ abstract contract Pyth is
         override
         returns (PythStructs.PriceFeed[] memory priceFeeds)
     {
-        (priceFeeds, ) = parsePriceFeedUpdatesInternal(
+        (priceFeeds, ) = parsePriceFeedUpdatesWithConfig(
             updateData,
             priceIds,
             minPublishTime,
             maxPublishTime,
             true,
+            false,
             false
         );
     }
@@ -703,7 +700,7 @@ abstract contract Pyth is
     }
 
     function version() public pure returns (string memory) {
-        return "1.4.5";
+        return "1.4.5-alpha.1";
     }
 
     /// @notice Calculates TWAP from two price points

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

@@ -240,6 +240,36 @@ contract GasBenchmark is Test, WormholeTestUtils, PythTestUtils {
         );
     }
 
+    function testBenchmarkParsePriceFeedUpdatesWithConfigTrue() public {
+        bytes32[] memory ids = new bytes32[](1);
+        ids[0] = priceIds[0];
+
+        pyth.parsePriceFeedUpdatesWithConfig{value: freshPricesUpdateFee[0]}(
+            freshPricesUpdateData[0],
+            ids,
+            0,
+            50,
+            false,
+            true, // check minimal
+            false
+        );
+    }
+
+    function testBenchmarkParsePriceFeedUpdatesWithConfigFalse() public {
+        bytes32[] memory ids = new bytes32[](1);
+        ids[0] = priceIds[0];
+
+        pyth.parsePriceFeedUpdatesWithConfig{value: freshPricesUpdateFee[0]}(
+            freshPricesUpdateData[0], // contains only priceIds[0]
+            ids,
+            0,
+            50,
+            false,
+            true, // check minimal
+            false
+        );
+    }
+
     function testBenchmarkParsePriceFeedUpdatesUniqueFor() public {
         bytes32[] memory ids = new bytes32[](1);
         ids[0] = priceIds[0];

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

@@ -278,7 +278,92 @@ contract PythTest is Test, WormholeTestUtils, PythTestUtils {
         }
     }
 
-    function testParsePriceFeedUpdatesWithSlotsStrictWorks(uint seed) public {
+    function testParsePriceFeedUpdatesWithConfigIfStorageTrue(
+        uint seed
+    ) public {
+        setRandSeed(seed);
+        uint numMessages = 1 + (getRandUint() % 10);
+        (
+            bytes32[] memory priceIds,
+            PriceFeedMessage[] memory messages
+        ) = generateRandomPriceMessages(numMessages);
+
+        (
+            bytes[] memory updateData,
+            uint updateFee
+        ) = createBatchedUpdateDataFromMessages(messages);
+
+        (PythStructs.PriceFeed[] memory priceFeeds, ) = pyth
+            .parsePriceFeedUpdatesWithConfig{value: updateFee}(
+            updateData,
+            priceIds,
+            0,
+            MAX_UINT64,
+            false,
+            true,
+            true
+        );
+
+        for (uint i = 0; i < numMessages; i++) {
+            // Validating that returned priceIds are equal
+            assertEq(priceFeeds[i].id, priceIds[i]);
+            assertEq(priceFeeds[i].price.price, messages[i].price);
+            assertEq(priceFeeds[i].price.conf, messages[i].conf);
+            assertEq(priceFeeds[i].price.expo, messages[i].expo);
+            assertEq(priceFeeds[i].price.publishTime, messages[i].publishTime);
+            assertEq(priceFeeds[i].emaPrice.price, messages[i].emaPrice);
+            assertEq(priceFeeds[i].emaPrice.conf, messages[i].emaConf);
+            assertEq(priceFeeds[i].emaPrice.expo, messages[i].expo);
+            assertEq(
+                priceFeeds[i].emaPrice.publishTime,
+                messages[i].publishTime
+            );
+
+            // Validating that prices are stored on chain
+            PythStructs.Price memory curPrice = pyth.getPriceUnsafe(
+                messages[i].priceId
+            );
+
+            assertEq(priceFeeds[i].price.price, curPrice.price);
+            assertEq(priceFeeds[i].price.conf, curPrice.conf);
+            assertEq(priceFeeds[i].price.expo, curPrice.expo);
+            assertEq(priceFeeds[i].price.publishTime, curPrice.publishTime);
+        }
+    }
+
+    function testParsePriceFeedUpdatesWithConfigIfStorageFalse(
+        uint seed
+    ) public {
+        setRandSeed(seed);
+        uint numMessages = 1 + (getRandUint() % 10);
+        (
+            bytes32[] memory priceIds,
+            PriceFeedMessage[] memory messages
+        ) = generateRandomPriceMessages(numMessages);
+
+        (
+            bytes[] memory updateData,
+            uint updateFee
+        ) = createBatchedUpdateDataFromMessages(messages);
+
+        pyth.parsePriceFeedUpdatesWithConfig{value: updateFee}(
+            updateData,
+            priceIds,
+            0,
+            MAX_UINT64,
+            false,
+            true,
+            false
+        );
+
+        // validate that stored prices of each priceId are still unpopulated
+        for (uint i = 0; i < numMessages; i++) {
+            vm.expectRevert(PythErrors.PriceFeedNotFound.selector);
+            pyth.getPriceUnsafe(priceIds[i]);
+        }
+    }
+
+    function testParsePriceFeedUpdatesWithConfigWorks(uint seed) public {
         setRandSeed(seed);
         uint numMessages = 1 + (getRandUint() % 10);
         (
@@ -293,11 +378,14 @@ contract PythTest is Test, WormholeTestUtils, PythTestUtils {
         (
             PythStructs.PriceFeed[] memory priceFeeds,
             uint64[] memory slots
-        ) = pyth.parsePriceFeedUpdatesWithSlotsStrict{value: updateFee}(
+        ) = pyth.parsePriceFeedUpdatesWithConfig{value: updateFee}(
                 updateData,
                 priceIds,
                 0,
-                MAX_UINT64
+                MAX_UINT64,
+                false,
+                true,
+                false
             );
 
         assertEq(priceFeeds.length, numMessages);
@@ -434,7 +522,7 @@ contract PythTest is Test, WormholeTestUtils, PythTestUtils {
         );
     }
 
-    function testParsePriceFeedUpdatesWithSlotsStrictRevertsWithExcessUpdateData()
+    function testParsePriceFeedUpdatesWithConfigRevertsWithExcessUpdateData()
         public
     {
         // Create a price update with more price updates than requested price IDs
@@ -459,15 +547,18 @@ contract PythTest is Test, WormholeTestUtils, PythTestUtils {
 
         // Should revert in strict mode
         vm.expectRevert(PythErrors.InvalidArgument.selector);
-        pyth.parsePriceFeedUpdatesWithSlotsStrict{value: updateFee}(
+        pyth.parsePriceFeedUpdatesWithConfig{value: updateFee}(
             updateData,
             requestedPriceIds,
             0,
-            MAX_UINT64
+            MAX_UINT64,
+            false,
+            true,
+            false
         );
     }
 
-    function testParsePriceFeedUpdatesWithSlotsStrictRevertsWithFewerUpdateData()
+    function testParsePriceFeedUpdatesWithConfigRevertsWithFewerUpdateData()
         public
     {
         // Create a price update with fewer price updates than requested price IDs
@@ -496,11 +587,14 @@ contract PythTest is Test, WormholeTestUtils, PythTestUtils {
 
         // Should revert in strict mode because we have fewer updates than price IDs
         vm.expectRevert(PythErrors.InvalidArgument.selector);
-        pyth.parsePriceFeedUpdatesWithSlotsStrict{value: updateFee}(
+        pyth.parsePriceFeedUpdatesWithConfig{value: updateFee}(
             updateData,
             requestedPriceIds,
             0,
-            MAX_UINT64
+            MAX_UINT64,
+            false,
+            true,
+            false
         );
     }
 

target_chains/ethereum/contracts/forge-test/utils/MockPriceFeedTestUtils.sol

@@ -187,7 +187,7 @@ abstract contract MockPriceFeedTestUtils is Test {
             pyth,
             expectedFee,
             abi.encodeWithSelector(
-                IPyth.parsePriceFeedUpdatesWithSlotsStrict.selector
+                IPyth.parsePriceFeedUpdatesWithConfig.selector
             ),
             abi.encode(priceFeeds, slots)
         );

target_chains/ethereum/sdk/solidity/AbstractPyth.sol

@@ -136,21 +136,6 @@ abstract contract AbstractPyth is IPyth {
         override
         returns (PythStructs.PriceFeed[] memory priceFeeds);
 
-    function parsePriceFeedUpdatesWithSlotsStrict(
-        bytes[] calldata updateData,
-        bytes32[] calldata priceIds,
-        uint64 minPublishTime,
-        uint64 maxPublishTime
-    )
-        external
-        payable
-        virtual
-        override
-        returns (
-            PythStructs.PriceFeed[] memory priceFeeds,
-            uint64[] memory slots
-        );
-
     function parseTwapPriceFeedUpdates(
         bytes[] calldata updateData,
         bytes32[] calldata priceIds