refactor(target_chains/starknet): cleanup and GetDataSources trait (#1664)

Author: Riateche

target_chains/starknet/contracts/src/pyth.cairo

@@ -14,7 +14,8 @@ pub use errors::{
     UpdatePriceFeedsIfNecessaryError, ParsePriceFeedsError, GetSingleUpdateFeeError,
 };
 pub use interface::{
-    IPyth, IPythDispatcher, IPythDispatcherTrait, DataSource, Price, PriceFeedPublishTime, PriceFeed
+    IPyth, IPythDispatcher, IPythDispatcherTrait, DataSource, GetDataSource, Price,
+    PriceFeedPublishTime, PriceFeed
 };
 
 #[starknet::contract]
@@ -34,9 +35,10 @@ mod pyth {
     use core::starknet::syscalls::replace_class_syscall;
     use pyth::wormhole::{IWormholeDispatcher, IWormholeDispatcherTrait, VerifiedVM};
     use super::{
-        DataSource, UpdatePriceFeedsError, GovernanceActionError, Price, GetPriceUnsafeError,
-        IPythDispatcher, IPythDispatcherTrait, PriceFeedPublishTime, GetPriceNoOlderThanError,
-        UpdatePriceFeedsIfNecessaryError, PriceFeed, ParsePriceFeedsError, GetSingleUpdateFeeError,
+        DataSource, GetDataSource, UpdatePriceFeedsError, GovernanceActionError, Price,
+        GetPriceUnsafeError, IPythDispatcher, IPythDispatcherTrait, PriceFeedPublishTime,
+        GetPriceNoOlderThanError, UpdatePriceFeedsIfNecessaryError, PriceFeed, ParsePriceFeedsError,
+        GetSingleUpdateFeeError,
     };
     use super::governance;
     use super::governance::GovernancePayload;
@@ -547,7 +549,7 @@ mod pyth {
             let wormhole = IWormholeDispatcher { contract_address: self.wormhole_address.read() };
             let claim_vm = wormhole.parse_and_verify_vm(claim_vaa.clone());
             // Note: no verify_governance_vm() because claim_vaa is signed by the new data source
-            let instruction = governance::parse_instruction(claim_vm.payload);
+            let instruction = governance::parse_instruction(claim_vm.payload.clone());
             if instruction.target_chain_id != 0
                 && instruction.target_chain_id != wormhole.chain_id() {
                 panic_with_felt252(GovernanceActionError::InvalidGovernanceTarget.into());
@@ -565,10 +567,7 @@ mod pyth {
             }
             self.governance_data_source_index.write(request_payload.governance_data_source_index);
             let old_data_source = self.governance_data_source.read();
-            let new_data_source = DataSource {
-                emitter_chain_id: claim_vm.emitter_chain_id,
-                emitter_address: claim_vm.emitter_address,
-            };
+            let new_data_source = claim_vm.data_source();
             self.governance_data_source.write(new_data_source);
             // Setting the last executed governance to the claimVaa sequence to avoid
             // using older sequences.
@@ -620,10 +619,7 @@ mod pyth {
             let wormhole = IWormholeDispatcher { contract_address: self.wormhole_address.read() };
             let vm = wormhole.parse_and_verify_vm(wormhole_proof);
 
-            let source = DataSource {
-                emitter_chain_id: vm.emitter_chain_id, emitter_address: vm.emitter_address
-            };
-            if !self.is_valid_data_source.read(source) {
+            if !self.is_valid_data_source.read(vm.data_source()) {
                 panic_with_felt252(UpdatePriceFeedsError::InvalidUpdateDataSource.into());
             }
 

target_chains/starknet/contracts/src/pyth/errors.cairo

@@ -38,7 +38,6 @@ impl GetPriceUnsafeErrorIntoGetPriceNoOlderThanError of Into<
 
 #[derive(Copy, Drop, Debug, Serde, PartialEq)]
 pub enum GovernanceActionError {
-    AccessDenied,
     Wormhole: pyth::wormhole::ParseAndVerifyVmError,
     InvalidGovernanceDataSource,
     OldGovernanceMessage,
@@ -50,7 +49,6 @@ pub enum GovernanceActionError {
 impl GovernanceActionErrorIntoFelt252 of Into<GovernanceActionError, felt252> {
     fn into(self: GovernanceActionError) -> felt252 {
         match self {
-            GovernanceActionError::AccessDenied => 'access denied',
             GovernanceActionError::Wormhole(err) => err.into(),
             GovernanceActionError::InvalidGovernanceDataSource => 'invalid governance data source',
             GovernanceActionError::OldGovernanceMessage => 'old governance message',

target_chains/starknet/contracts/src/pyth/interface.cairo

@@ -1,5 +1,6 @@
 use super::{GetPriceUnsafeError, GetPriceNoOlderThanError};
 use pyth::byte_array::ByteArray;
+use pyth::wormhole::VerifiedVM;
 use core::starknet::ContractAddress;
 
 #[starknet::interface]
@@ -56,6 +57,18 @@ pub struct DataSource {
     pub emitter_address: u256,
 }
 
+pub trait GetDataSource<T> {
+    fn data_source(self: @T) -> DataSource;
+}
+
+impl GetDataSourceFromVerifiedVM of GetDataSource<VerifiedVM> {
+    fn data_source(self: @VerifiedVM) -> DataSource {
+        DataSource {
+            emitter_chain_id: *self.emitter_chain_id, emitter_address: *self.emitter_address
+        }
+    }
+}
+
 #[derive(Drop, Copy, PartialEq, Serde)]
 pub struct Price {
     pub price: i64,

target_chains/starknet/contracts/tests/pyth.cairo

@@ -1120,10 +1120,7 @@ fn deploy_pyth(
     let contract = declare("pyth");
     let contract_address = match contract.deploy(@args) {
         Result::Ok(v) => { v },
-        Result::Err(err) => {
-            panic(err.panic_data);
-            0.try_into().unwrap()
-        },
+        Result::Err(err) => { panic(err.panic_data) },
     };
     IPythDispatcher { contract_address }
 }
@@ -1135,10 +1132,7 @@ fn deploy_fee_contract(class: ContractClass, recipient: ContractAddress) -> IERC
     (name, symbol, 100000_u256, recipient).serialize(ref args);
     let contract_address = match class.deploy(@args) {
         Result::Ok(v) => { v },
-        Result::Err(err) => {
-            panic(err.panic_data);
-            0.try_into().unwrap()
-        },
+        Result::Err(err) => { panic(err.panic_data) },
     };
     IERC20CamelDispatcher { contract_address }
 }

target_chains/starknet/contracts/tests/wormhole.cairo

@@ -261,10 +261,7 @@ pub fn deploy_declared_at(
     };
     let contract_address = match result {
         Result::Ok(v) => { v },
-        Result::Err(err) => {
-            panic(err.panic_data);
-            0.try_into().unwrap()
-        },
+        Result::Err(err) => { panic(err.panic_data) },
     };
     IWormholeDispatcher { contract_address }
 }