Merge branch 'pyth-stylus-update-and-initialize' into pyth-stylus-parse-updates

Author: ayushboss

target_chains/stylus/Cargo.lock

@@ -26,6 +26,7 @@ stylus-sdk = { version = "0.9.0", features = ["stylus-test"] }
 dotenv = "0.15.0"
 motsu = "0.9.0"
 wormhole-contract = { path = "../wormhole" }
+mock_instant = "0.6.0"
 
 [features]
 default = ["mini-alloc"]

target_chains/stylus/contracts/pyth-receiver/Cargo.toml

@@ -1,23 +1,19 @@
 #[cfg(test)]
 mod test {
     use crate::error::PythReceiverError;
-    use crate::test_data;
+    use crate::test_data::*;
     use crate::PythReceiver;
-    use alloy_primitives::{address, Address, I32, I64, U256, U64};
+    use alloy_primitives::{Address, U256};
+    use mock_instant::global::MockClock;
     use motsu::prelude::*;
     use pythnet_sdk::wire::v1::{AccumulatorUpdateData, Proof};
+    use std::time::Duration;
     use wormhole_contract::WormholeContract;
     const TEST_PRICE_ID: [u8; 32] = [
         0xe6, 0x2d, 0xf6, 0xc8, 0xb4, 0xa8, 0x5f, 0xe1, 0xa6, 0x7d, 0xb4, 0x4d, 0xc1, 0x2d, 0xe5,
         0xdb, 0x33, 0x0f, 0x7a, 0xc6, 0x6b, 0x72, 0xdc, 0x65, 0x8a, 0xfe, 0xdf, 0x0f, 0x4a, 0x41,
         0x5b, 0x43,
     ];
-    const TEST_PUBLISH_TIME: u64 = 1751563000;
-    const TEST_PRICE: i64 = 10967241867779;
-    const TEST_CONF: u64 = 4971244966;
-    const TEST_EXPO: i32 = -8;
-    const TEST_EMA_PRICE: i64 = 10942391100000;
-    const TEST_EMA_CONF: u64 = 4398561400;
 
     const PYTHNET_CHAIN_ID: u16 = 26;
     const PYTHNET_EMITTER_ADDRESS: [u8; 32] = [
@@ -31,44 +27,29 @@ mod test {
     const GOVERNANCE_CONTRACT: U256 = U256::from_limbs([4, 0, 0, 0]);
 
     const SINGLE_UPDATE_FEE_IN_WEI: U256 = U256::from_limbs([100, 0, 0, 0]);
+    const TRANSACTION_FEE_IN_WEI: U256 = U256::from_limbs([32, 0, 0, 0]);
 
     #[cfg(test)]
-    fn current_guardians() -> Vec<Address> {
-        vec![
-            address!("0x5893B5A76c3f739645648885bDCcC06cd70a3Cd3"), // Rockaway
-            address!("0xfF6CB952589BDE862c25Ef4392132fb9D4A42157"), // Staked
-            address!("0x114De8460193bdf3A2fCf81f86a09765F4762fD1"), // Figment
-            address!("0x107A0086b32d7A0977926A205131d8731D39cbEB"), // ChainodeTech
-            address!("0x8C82B2fd82FaeD2711d59AF0F2499D16e726f6b2"), // Inotel
-            address!("0x11b39756C042441BE6D8650b69b54EbE715E2343"), // HashKey Cloud
-            address!("0x54Ce5B4D348fb74B958e8966e2ec3dBd4958a7cd"), // ChainLayer
-            address!("0x15e7cAF07C4e3DC8e7C469f92C8Cd88FB8005a20"), // xLabs
-            address!("0x74a3bf913953D695260D88BC1aA25A4eeE363ef0"), // Forbole
-            address!("0x000aC0076727b35FBea2dAc28fEE5cCB0fEA768e"), // Staking Fund
-            address!("0xAF45Ced136b9D9e24903464AE889F5C8a723FC14"), // Moonlet Wallet
-            address!("0xf93124b7c738843CBB89E864c862c38cddCccF95"), // P2P Validator
-            address!("0xD2CC37A4dc036a8D232b48f62cDD4731412f4890"), // 01node
-            address!("0xDA798F6896A3331F64b48c12D1D57Fd9cbe70811"), // MCF
-            address!("0x71AA1BE1D36CaFE3867910F99C09e347899C19C3"), // Everstake
-            address!("0x8192b6E7387CCd768277c17DAb1b7a5027c0b3Cf"), // Chorus One
-            address!("0x178e21ad2E77AE06711549CFBB1f9c7a9d8096e8"), // Syncnode
-            address!("0x5E1487F35515d02A92753504a8D75471b9f49EdB"), // Triton
-            address!("0x6FbEBc898F403E4773E95feB15E80C9A99c8348d"), // Staking Facilities
-        ]
-    }
-
-    #[cfg(test)]
-    fn mock_get_update_fee(update_data: Vec<u8>) -> Result<U256, PythReceiverError> {
-        let update_data_array: &[u8] = &update_data;
-        let accumulator_update = AccumulatorUpdateData::try_from_slice(&update_data_array)
-            .map_err(|_| PythReceiverError::InvalidAccumulatorMessage)?;
-        match accumulator_update.proof {
-            Proof::WormholeMerkle { vaa: _, updates } => {
-                let num_updates =
-                    u8::try_from(updates.len()).map_err(|_| PythReceiverError::TooManyUpdates)?;
-                Ok(U256::from(num_updates).saturating_mul(SINGLE_UPDATE_FEE_IN_WEI))
+    fn mock_get_update_fee(update_data: Vec<Vec<u8>>) -> Result<U256, PythReceiverError> {
+        let mut total_num_updates: u64 = 0;
+        for data in &update_data {
+            let update_data_array: &[u8] = &data;
+            let accumulator_update = AccumulatorUpdateData::try_from_slice(&update_data_array)
+                .map_err(|_| PythReceiverError::InvalidAccumulatorMessage)?;
+            match accumulator_update.proof {
+                Proof::WormholeMerkle { vaa: _, updates } => {
+                    let num_updates = u64::try_from(updates.len())
+                        .map_err(|_| PythReceiverError::TooManyUpdates)?;
+                    total_num_updates += num_updates;
+                }
             }
         }
+        Ok(get_total_fee(total_num_updates))
+    }
+
+    fn get_total_fee(total_num_updates: u64) -> U256 {
+        U256::from(total_num_updates).saturating_mul(SINGLE_UPDATE_FEE_IN_WEI)
+            + TRANSACTION_FEE_IN_WEI
     }
 
     #[cfg(test)]
@@ -123,29 +104,19 @@ mod test {
     ) {
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
-        alice.fund(U256::from(200));
-
-        let update_data = test_data::good_update1();
+        let update_data = good_update1();
         let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
 
+        alice.fund(update_fee);
+
         let result = pyth_contract
             .sender_and_value(alice, update_fee)
             .update_price_feeds(update_data);
         assert!(result.is_ok());
 
         let price_result = pyth_contract.sender(alice).get_price_unsafe(TEST_PRICE_ID);
         assert!(price_result.is_ok());
-        assert_eq!(
-            price_result.unwrap(),
-            (
-                U64::from(TEST_PUBLISH_TIME),
-                I32::from_le_bytes(TEST_EXPO.to_le_bytes()),
-                I64::from_le_bytes(TEST_PRICE.to_le_bytes()),
-                U64::from(TEST_CONF),
-                I64::from_le_bytes(TEST_EMA_PRICE.to_le_bytes()),
-                U64::from(TEST_EMA_CONF)
-            )
-        );
+        assert_eq!(price_result.unwrap(), good_update1_results());
     }
 
     #[motsu::test]
@@ -158,7 +129,7 @@ mod test {
 
         alice.fund(U256::from(200));
 
-        let update_data = test_data::good_update1();
+        let update_data = good_update1();
         let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
         let small_update_fee = update_fee / U256::from(2);
 
@@ -170,43 +141,34 @@ mod test {
     }
 
     #[motsu::test]
-    fn test_get_price_after_multiple_updates_returns_recent_price(
+    fn test_get_price_after_multiple_different_updates_returns_recent_price(
         pyth_contract: Contract<PythReceiver>,
         wormhole_contract: Contract<WormholeContract>,
         alice: Address,
     ) {
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
-        alice.fund(U256::from(200));
-
-        let update_data1 = test_data::good_update1();
+        let update_data1 = good_update1();
         let update_fee1 = mock_get_update_fee(update_data1.clone()).unwrap();
+
+        let update_data2 = good_update2();
+        let update_fee2 = mock_get_update_fee(update_data2.clone()).unwrap();
+
+        alice.fund(update_fee1 + update_fee2);
+
         let result1 = pyth_contract
             .sender_and_value(alice, update_fee1)
             .update_price_feeds(update_data1);
         assert!(result1.is_ok());
 
-        let update_data2 = test_data::good_update2();
-        let update_fee2 = mock_get_update_fee(update_data2.clone()).unwrap();
-
         let result2 = pyth_contract
             .sender_and_value(alice, update_fee2)
             .update_price_feeds(update_data2);
         assert!(result2.is_ok());
 
         let price_result = pyth_contract.sender(alice).get_price_unsafe(TEST_PRICE_ID);
         assert!(price_result.is_ok());
-        assert_eq!(
-            price_result.unwrap(),
-            (
-                U64::from(1751573860u64),
-                I32::from_le_bytes((-8i32).to_le_bytes()),
-                I64::from_le_bytes(10985663592646i64.to_le_bytes()),
-                U64::from(4569386330u64),
-                I64::from_le_bytes(10977795800000i64.to_le_bytes()),
-                U64::from(3919318300u64)
-            )
-        );
+        assert_eq!(price_result.unwrap(), good_update2_results());
     }
 
     #[motsu::test]
@@ -231,6 +193,7 @@ mod test {
         wormhole_contract: Contract<WormholeContract>,
         alice: Address,
     ) {
+        MockClock::set_time(Duration::from_secs(1761573860));
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
         let random_id: [u8; 32] = [
@@ -255,13 +218,14 @@ mod test {
         wormhole_contract: Contract<WormholeContract>,
         alice: Address,
     ) {
+        MockClock::set_time(Duration::from_secs(1761573860));
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
-        alice.fund(U256::from(200));
-
-        let update_data = test_data::good_update2();
+        let update_data = good_update2();
         let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
 
+        alice.fund(update_fee);
+
         let result = pyth_contract
             .sender_and_value(alice, update_fee)
             .update_price_feeds(update_data);
@@ -271,17 +235,7 @@ mod test {
             .sender(alice)
             .get_price_no_older_than(TEST_PRICE_ID, u64::MAX);
         assert!(price_result.is_ok());
-        assert_eq!(
-            price_result.unwrap(),
-            (
-                U64::from(1751573860u64),
-                I32::from_le_bytes((-8i32).to_le_bytes()),
-                I64::from_le_bytes(10985663592646i64.to_le_bytes()),
-                U64::from(4569386330u64),
-                I64::from_le_bytes(10977795800000i64.to_le_bytes()),
-                U64::from(3919318300u64)
-            )
-        );
+        assert_eq!(price_result.unwrap(), good_update2_results());
     }
 
     #[motsu::test]
@@ -290,13 +244,14 @@ mod test {
         wormhole_contract: Contract<WormholeContract>,
         alice: Address,
     ) {
+        MockClock::set_time(Duration::from_secs(1761573860));
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
-        alice.fund(U256::from(200));
-
-        let update_data = test_data::good_update2();
+        let update_data = good_update2();
         let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
 
+        alice.fund(update_fee);
+
         let result = pyth_contract
             .sender_and_value(alice, update_fee)
             .update_price_feeds(update_data);
@@ -313,18 +268,18 @@ mod test {
     }
 
     #[motsu::test]
-    fn test_multiple_updates_different_ids_updates_both(
+    fn test_multiple_updates_in_same_vaa_different_ids_updates_both(
         pyth_contract: Contract<PythReceiver>,
         wormhole_contract: Contract<WormholeContract>,
         alice: Address,
     ) {
         pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
 
-        alice.fund(U256::from(200));
-
-        let update_data = test_data::multiple_updates();
+        let update_data = multiple_updates_same_vaa();
         let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
 
+        alice.fund(update_fee);
+
         let result = pyth_contract
             .sender_and_value(alice, update_fee)
             .update_price_feeds(update_data);
@@ -341,32 +296,52 @@ mod test {
             0x34, 0xfd, 0x0a, 0xce,
         ];
 
+        let first_price_result = pyth_contract.sender(alice).get_price_unsafe(first_id);
+        assert!(first_price_result.is_ok());
+        assert_eq!(first_price_result.unwrap(), multiple_updates_results()[0]);
+
+        let second_price_result = pyth_contract.sender(alice).get_price_unsafe(second_id);
+        assert!(second_price_result.is_ok());
+        assert_eq!(second_price_result.unwrap(), multiple_updates_results()[1]);
+    }
+
+    #[motsu::test]
+    fn test_multiple_updates_different_ids_updates_both(
+        pyth_contract: Contract<PythReceiver>,
+        wormhole_contract: Contract<WormholeContract>,
+        alice: Address,
+    ) {
+        pyth_wormhole_init(&pyth_contract, &wormhole_contract, &alice);
+
+        let update_data = multiple_updates_diff_vaa();
+        let update_fee = mock_get_update_fee(update_data.clone()).unwrap();
+
+        alice.fund(update_fee);
+
+        let result = pyth_contract
+            .sender_and_value(alice, update_fee)
+            .update_price_feeds(update_data);
+        assert!(result.is_ok());
+
+        let first_id: [u8; 32] = [
+            0x3f, 0xa4, 0x25, 0x28, 0x48, 0xf9, 0xf0, 0xa1, 0x48, 0x0b, 0xe6, 0x27, 0x45, 0xa4,
+            0x62, 0x9d, 0x9e, 0xb1, 0x32, 0x2a, 0xeb, 0xab, 0x8a, 0x79, 0x1e, 0x34, 0x4b, 0x3b,
+            0x9c, 0x1a, 0xdc, 0xf5,
+        ];
+        let second_id: [u8; 32] = TEST_PRICE_ID;
+
         let first_price_result = pyth_contract.sender(alice).get_price_unsafe(first_id);
         assert!(first_price_result.is_ok());
         assert_eq!(
             first_price_result.unwrap(),
-            (
-                U64::from(1751573123u64),
-                I32::from_le_bytes((-8i32).to_le_bytes()),
-                I64::from_le_bytes(10990356724259i64.to_le_bytes()),
-                U64::from(3891724259u64),
-                I64::from_le_bytes(10974970400000i64.to_le_bytes()),
-                U64::from(3918344000u64)
-            )
+            multiple_updates_diff_vaa_results()[0]
         );
 
         let second_price_result = pyth_contract.sender(alice).get_price_unsafe(second_id);
         assert!(second_price_result.is_ok());
         assert_eq!(
             second_price_result.unwrap(),
-            (
-                U64::from(1751573123u64),
-                I32::from_le_bytes((-8i32).to_le_bytes()),
-                I64::from_le_bytes(258906787480i64.to_le_bytes()),
-                U64::from(158498649u64),
-                I64::from_le_bytes(258597182000i64.to_le_bytes()),
-                U64::from(131285914u64)
-            )
+            multiple_updates_diff_vaa_results()[1]
         );
     }