chore(evm) Add combine Pricefeeds

Author: aditya520

target_chains/ethereum/contracts/forge-test/utils/PythTestUtils.t.sol

@@ -399,4 +399,66 @@ contract PythUtilsTest is Test, WormholeTestUtils, PythTestUtils, IPythEvents {
         // 0.00001 and we are targetDecimals is 2.
         assertEq(PythUtils.convertToUint(100, -5, 2), 0);
     }
+
+    function testCombinePrices() public {
+        // Test case 1: Basic price combination (ETH/USD / BTC/USD = ETH/BTC)
+        PythStructs.Price memory ethUsd = PythStructs.Price({
+            price: 99875005,  
+            conf: 10,
+            expo: -8,    
+            publishTime: block.timestamp
+        });
+        
+        PythStructs.Price memory btcUsd = PythStructs.Price({
+            price: 206362333702,
+            conf: 100,
+            expo: -8,     
+            publishTime: block.timestamp
+        });
+
+        (int64 price, int32 expo) = PythUtils.combinePrices(ethUsd, btcUsd);
+        assertApproxEqRel(price, 2016367433623696, 9e17); 
+        assertEq(expo, -18);
+
+        // // Test case 2: Different exponents
+        // PythStructs.Price memory smallPrice = PythStructs.Price({
+        //     price: 100,   // $0.01
+        //     conf: 1,
+        //     expo: -4,     // 4 decimals
+        //     publishTime: block.timestamp
+        // });
+
+        // PythStructs.Price memory largePrice = PythStructs.Price({
+        //     price: 1000,  // $10
+        //     conf: 10,
+        //     expo: -2,     // 2 decimals
+        //     publishTime: block.timestamp
+        // });
+
+        // (price, expo) = PythUtils.combinePrices(smallPrice, largePrice, -2);
+        // assertEq(price, 1);    // 0.01
+        // assertEq(expo, -2);
+
+        // // Test case 3: Revert on negative prices
+        // PythStructs.Price memory negativePrice = PythStructs.Price({
+        //     price: -100,
+        //     conf: 10,
+        //     expo: -2,
+        //     publishTime: block.timestamp
+        // });
+
+        // vm.expectRevert();
+        // PythUtils.combinePrices(negativePrice, btcUsd, -2);
+
+        // // Test case 4: Revert on positive exponents
+        // PythStructs.Price memory invalidExpo = PythStructs.Price({
+        //     price: 100,
+        //     conf: 10,
+        //     expo: 2,
+        //     publishTime: block.timestamp
+        // });
+
+        // vm.expectRevert();
+        // PythUtils.combinePrices(ethUsd, invalidExpo, -2);
+    }
 }

target_chains/ethereum/sdk/solidity/PythUtils.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "./PythStructs.sol";
-
+import "forge-std/console.sol";
 library PythUtils {
     /// @notice Converts a Pyth price to a uint256 with a target number of decimals
     /// @param price The Pyth price
@@ -33,4 +33,51 @@ library PythUtils {
                 10 ** uint32(priceDecimals - targetDecimals);
         }
     }
+
+    /// @notice Combines two prices to get a cross-rate
+    /// @param price1 The first price (a/b)
+    /// @param price2 The second price (c/b)
+    /// @return combinedPrice The combined price (a/c)
+    /// @return expo The exponent of the combined price
+    /// @dev This function will revert if either price is negative or if the exponents are invalid
+    function combinePrices(
+        PythStructs.Price memory price1,
+        PythStructs.Price memory price2
+    ) public pure returns (int64 combinedPrice, int32 expo) {
+        if (price1.price < 0 || price2.price < 0 || price1.expo > 0 || price2.expo > 0 || price1.expo < -255 || price2.expo < -255) {
+            revert();
+        }
+
+        uint8 p1Decimals = uint8(uint32(-1 * price1.expo));
+        uint8 p2Decimals = uint8(uint32(-1 * price2.expo));
+
+        uint256 p1;
+        uint256 p2;
+
+        if (p1Decimals >= p2Decimals) {
+            p2 = convertToUint(price2.price, price2.expo, p1Decimals);
+            p1 = uint256(uint64(price1.price));
+        } else {
+            p1 = convertToUint(price1.price, price1.expo, p2Decimals);
+            p2 = uint256(uint64(price2.price));
+        }
+
+
+        console.log("p1", p1);
+        console.log("p2", p2);
+
+
+        // Calculate the combined price
+        uint256 combined = (p1 * 10**18) / p2;  // Multiply by 10^18 to maintain precision
+        console.log("combined", combined);
+        // Calculate the new exponent
+        int32 newExpo = -18;  
+        console.log("newExpo", newExpo);
+        // Check if the combined price fits in int64
+        if (combined > uint256(uint64(type(int64).max))) {
+            revert();
+        }
+
+        return (int64(uint64(combined)), newExpo);
+    }
 }