cleaned initialize and sorted out stylus storage type issue for now. also added wormhole integration temporarily

Author: ayushboss

target_chains/stylus/Cargo.lock

@@ -14,8 +14,11 @@ alloy-sol-types = "=0.8.20"
 stylus-sdk = "0.9.0"
 hex = { version = "0.4", default-features = false }
 pythnet-sdk = { path = "../../../../pythnet/pythnet_sdk" }
+pyth-types = { path = "../pyth-types" }
+wormhole-vaas = "0.1.1"
 wormhole-contract = { path = "../../contracts/wormhole" }
 
+
 [dev-dependencies]
 alloy-primitives = { version = "=0.8.20", features = ["sha3-keccak"] }
 tokio = { version = "1.12.0", features = ["full"] }

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

@@ -9,18 +9,19 @@ mod structs;
 mod error;
 
 use alloc::vec::Vec;
-use stylus_sdk::{alloy_primitives::{U16, U32, U256, U64, I32, I64, FixedBytes, Bytes, Address},
+use stylus_sdk::{alloy_primitives::{U16, U32, U256, U64, I32, I64, FixedBytes, Address},
                 prelude::*, 
-                storage::{StorageAddress, StorageVec, StorageMap, StorageUint, StorageBool, StorageU256, StorageU16, StorageFixedBytes},
+                storage::{StorageGuardMut, StorageAddress, StorageVec, StorageMap, StorageUint, StorageBool, StorageU256, StorageU16, StorageFixedBytes},
                 call::Call};
 
-use structs::{PriceInfoReturn, PriceInfoStorage, DataSourceStorage};
+use structs::{PriceInfoReturn, PriceInfoStorage, DataSourceStorage, DataSource};
 use error::{PythReceiverError};
 use pythnet_sdk::{wire::{v1::{
             AccumulatorUpdateData, Proof,
         },
     },
 };
+use wormhole_vaas::{Readable, Vaa, VaaBody, VaaHeader};
 
 sol_interface! {
     interface IWormholeContract {
@@ -36,7 +37,7 @@ sol_interface! {
 pub struct PythReceiver {
     pub wormhole: StorageAddress,
     pub valid_data_sources: StorageVec<DataSourceStorage>,
-    pub is_valid_data_source: StorageMap<FixedBytes<32>, StorageBool>,
+    pub is_valid_data_source: StorageMap<DataSource, StorageBool>,
     pub single_update_fee_in_wei: StorageU256,
     pub valid_time_period_seconds: StorageU256,
     pub governance_data_source_chain_id: StorageU16,
@@ -71,9 +72,15 @@ impl PythReceiver {
             let mut data_source = self.valid_data_sources.grow();
             data_source.chain_id.set(U16::from(*chain_id));
             data_source.emitter_address.set(emitter_address);
+
+            let data_source_key = DataSource {
+                chain_id: U16::from(*chain_id),
+                emitter_address: emitter_address,
+            };
 
+
             self.is_valid_data_source
-                .setter(emitter_address)
+                .setter(data_source_key)
                 .set(true);
         }
     }
@@ -121,15 +128,18 @@ impl PythReceiver {
             Proof::WormholeMerkle { vaa, updates } => {
                 let wormhole: IWormholeContract = IWormholeContract::new(self.wormhole.get());
                 let config = Call::new_in(self);
-                let _parsed_vaa = wormhole.parse_and_verify_vm(config, Bytes::from(Vec::from(vaa))).map_err(|_| PythReceiverError::PriceUnavailable).unwrap();
-
-                if !self.is_valid_data_source.entry(_parsed_vaa.data_source()).read() {
-                    panic!("Update data source is not a valid data source.");
-                }
+                let parsed_vaa = wormhole.parse_and_verify_vm(config, Vec::from(vaa)).map_err(|_| PythReceiverError::PriceUnavailable).unwrap();
+                let vaa = Vaa::read(&mut parsed_vaa.as_slice()).unwrap();
 
                 for update in updates {
                     // fill in update processing logic.
                     // update is a merkle price update
+
+                    // pub struct MerklePriceUpdate {
+                    //     pub message: PrefixedVec<u16, u8>,
+                    //     pub proof: MerklePath<Keccak160>,
+                    // }
+
                     let message = update.message;
                     let proof = update.proof;
 

target_chains/stylus/contracts/pyth-receiver/src/lib.rs

@@ -1,30 +1,71 @@
 use alloc::vec::Vec;
-use stylus_sdk::{prelude::*, storage::{StorageU64, StorageI32, StorageI64, StorageU16, StorageFixedBytes}};
-use stylus_sdk::alloy_primitives::{U64, I32, I64, U16, FixedBytes};
-use wormhole_contract::types::VerifiedVM;
+use stylus_sdk::{
+    prelude::*,
+    storage::{
+        StorageU64, StorageI32, StorageI64, StorageU16, StorageFixedBytes, StorageKey
+    }
+};
+use stylus_sdk::alloy_primitives::{U16, FixedBytes,U64, I32, I64, B256, U256, keccak256};
 
+#[derive(Debug)]
 #[storage]
 pub struct DataSourceStorage {
     pub chain_id: StorageU16,
     pub emitter_address: StorageFixedBytes<32>,
 }
 
-pub trait GetDataSource {
-    fn data_source(&self) -> DataSourceStorage;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DataSource {
+    pub chain_id: U16,
+    pub emitter_address: FixedBytes<32>,
+}
+
+impl StorageKey for DataSourceStorage {
+    fn to_slot(&self, root: B256) -> U256 {
+        let mut bytes = [0u8; 34];
+
+        let chain_id: u16 = self.chain_id.get().to::<u16>();
+        // now you can use `chain_id` as a regular u16
+        let chain_id_bytes = chain_id.to_be_bytes();
+        
+        bytes[0..2].copy_from_slice(&chain_id_bytes);
+        bytes[2..].copy_from_slice(self.emitter_address.get().as_slice());
+
+        keccak256(bytes).to_slot(root)
+    }
 }
 
-impl GetDataSource for VerifiedVM {
-    fn data_source(&self) -> DataSourceStorage {
-        let mut ds = DataSourceStorage {
-            chain_id: StorageU16::default(),
-            emitter_address: StorageFixedBytes::<32>::default(),
-        };
-        ds.chain_id.set(U16::from(self.emitter_chain_id));
-        ds.emitter_address.set(self.emitter_address);
-        ds
+impl StorageKey for DataSource {
+    fn to_slot(&self, root: B256) -> U256 {
+        let mut bytes = [0u8; 34];
+
+        let chain_id: u16 = self.chain_id.to::<u16>();
+        // now you can use `chain_id` as a regular u16
+        let chain_id_bytes = chain_id.to_be_bytes();
+        
+        bytes[0..2].copy_from_slice(&chain_id_bytes);
+        bytes[2..].copy_from_slice(self.emitter_address.as_slice());
+
+        keccak256(bytes).to_slot(root)
     }
 }
 
+// pub trait GetDataSource {
+//     fn data_source(&self) -> DataSourceStorage;
+// }
+
+// impl GetDataSource for VerifiedVM {
+//     fn data_source(&self) -> DataSourceStorage {
+//         let mut ds = DataSourceStorage {
+//             chain_id: StorageU16::new(storage_key!("chain_id")),
+//             emitter_address: StorageFixedBytes::<32>::new(storage_key!("emitter_address")),
+//         };
+//         ds.chain_id.set(self.emitter_chain_id.into());
+//         ds.emitter_address.set(self.emitter_address);
+//         ds
+//     }
+// }
+
 // PriceInfo struct storing price information
 #[storage]
 pub struct PriceInfoStorage {