feat(target_chains/starknet): support two fee tokens (#1644)

* feat(target_chains/starknet): support two fee tokens

* fix(target_chains/starknet): use second fee if first fee balance is insufficient

* refactor(target_chains/starknet): rename fee_token_address1 and single_update_fee1

Author: Riateche

target_chains/starknet/contracts/deploy/local_deploy

@@ -65,6 +65,8 @@ pyth_address=$(starkli deploy "${pyth_hash}" \
     "${wormhole_address}" \
     "${fee_token_address}" \
     1000 0 `# fee amount` \
+    "${fee_token_address}" `# there is only one pre-deployed token on katana so we use it again` \
+    1000 0 `# fee amount` \
     1 `# num_data_sources` \
     26 `# emitter_chain_id` \
     58051393581875729396504816158954007153 299086580781278228892874716333010393740 `# emitter_address` \

target_chains/starknet/contracts/src/pyth.cairo

@@ -11,7 +11,7 @@ pub use pyth::{
 };
 pub use errors::{
     GetPriceUnsafeError, GovernanceActionError, UpdatePriceFeedsError, GetPriceNoOlderThanError,
-    UpdatePriceFeedsIfNecessaryError, ParsePriceFeedsError,
+    UpdatePriceFeedsIfNecessaryError, ParsePriceFeedsError, GetSingleUpdateFeeError,
 };
 pub use interface::{
     IPyth, IPythDispatcher, IPythDispatcherTrait, DataSource, Price, PriceFeedPublishTime, PriceFeed
@@ -36,7 +36,7 @@ mod pyth {
     use super::{
         DataSource, UpdatePriceFeedsError, GovernanceActionError, Price, GetPriceUnsafeError,
         IPythDispatcher, IPythDispatcherTrait, PriceFeedPublishTime, GetPriceNoOlderThanError,
-        UpdatePriceFeedsIfNecessaryError, PriceFeed, ParsePriceFeedsError,
+        UpdatePriceFeedsIfNecessaryError, PriceFeed, ParsePriceFeedsError, GetSingleUpdateFeeError,
     };
     use super::governance;
     use super::governance::GovernancePayload;
@@ -97,8 +97,10 @@ mod pyth {
     #[storage]
     struct Storage {
         wormhole_address: ContractAddress,
-        fee_token_address: ContractAddress,
-        single_update_fee: u256,
+        fee_token_address1: ContractAddress,
+        fee_token_address2: ContractAddress,
+        single_update_fee1: u256,
+        single_update_fee2: u256,
         data_sources: LegacyMap<usize, DataSource>,
         num_data_sources: usize,
         // For fast validation.
@@ -115,29 +117,36 @@ mod pyth {
     ///
     /// `wormhole_address` is the address of the deployed Wormhole contract implemented in the `wormhole` module.
     ///
-    /// `fee_token_address` is the address of the ERC20 token used to pay fees to Pyth
+    /// `fee_token_address1` is the address of the ERC20 token used to pay fees to Pyth
     /// for price updates. There is no native token on Starknet so an ERC20 contract has to be used.
     /// On Katana, an ETH fee contract is pre-deployed. On Starknet testnet, ETH and STRK fee tokens are
     /// available. Any other ERC20-compatible token can also be used.
     /// In a Starknet Forge testing environment, a fee contract must be deployed manually.
     ///
-    /// `single_update_fee` is the number of tokens of `fee_token_address` charged for a single price update.
+    /// `single_update_fee1` is the number of tokens of `fee_token_address1` charged for a single price update.
+    ///
+    /// `fee_token_address2` and `single_update_fee2` specify the secondary fee contract and fee rate
+    /// that can be used instead of the main fee token.
     ///
     /// `data_sources` is the list of Wormhole data sources accepted by this contract.
     #[constructor]
     fn constructor(
         ref self: ContractState,
         wormhole_address: ContractAddress,
-        fee_token_address: ContractAddress,
-        single_update_fee: u256,
+        fee_token_address1: ContractAddress,
+        single_update_fee1: u256,
+        fee_token_address2: ContractAddress,
+        single_update_fee2: u256,
         data_sources: Array<DataSource>,
         governance_emitter_chain_id: u16,
         governance_emitter_address: u256,
         governance_initial_sequence: u64,
     ) {
         self.wormhole_address.write(wormhole_address);
-        self.fee_token_address.write(fee_token_address);
-        self.single_update_fee.write(single_update_fee);
+        self.fee_token_address1.write(fee_token_address1);
+        self.single_update_fee1.write(single_update_fee1);
+        self.fee_token_address2.write(fee_token_address2);
+        self.single_update_fee2.write(single_update_fee2);
         self.write_data_sources(@data_sources);
         self
             .governance_data_source
@@ -253,13 +262,21 @@ mod pyth {
             self.update_price_feeds_internal(data, array![], 0, 0, false);
         }
 
-        fn get_update_fee(self: @ContractState, data: ByteArray) -> u256 {
+        fn get_update_fee(self: @ContractState, data: ByteArray, token: ContractAddress) -> u256 {
+            let single_update_fee = if token == self.fee_token_address1.read() {
+                self.single_update_fee1.read()
+            } else if token == self.fee_token_address2.read() {
+                self.single_update_fee2.read()
+            } else {
+                panic_with_felt252(GetSingleUpdateFeeError::UnsupportedToken.into())
+            };
+
             let mut reader = ReaderImpl::new(data);
             read_and_verify_header(ref reader);
             let wormhole_proof_size = reader.read_u16();
             reader.skip(wormhole_proof_size.into());
             let num_updates = reader.read_u8();
-            self.get_total_fee(num_updates)
+            single_update_fee * num_updates.into()
         }
 
         fn update_price_feeds_if_necessary(
@@ -314,12 +331,18 @@ mod pyth {
             self.wormhole_address.read()
         }
 
-        fn fee_token_address(self: @ContractState) -> ContractAddress {
-            self.fee_token_address.read()
+        fn fee_token_addresses(self: @ContractState) -> Array<ContractAddress> {
+            array![self.fee_token_address1.read(), self.fee_token_address2.read()]
         }
 
-        fn get_single_update_fee(self: @ContractState) -> u256 {
-            self.single_update_fee.read()
+        fn get_single_update_fee(self: @ContractState, token: ContractAddress) -> u256 {
+            if token == self.fee_token_address1.read() {
+                self.single_update_fee1.read()
+            } else if token == self.fee_token_address2.read() {
+                self.single_update_fee2.read()
+            } else {
+                panic_with_felt252(GetSingleUpdateFeeError::UnsupportedToken.into())
+            }
         }
 
         fn valid_data_sources(self: @ContractState) -> Array<DataSource> {
@@ -370,8 +393,8 @@ mod pyth {
             match instruction.payload {
                 GovernancePayload::SetFee(payload) => {
                     let new_fee = apply_decimal_expo(payload.value, payload.expo);
-                    let old_fee = self.single_update_fee.read();
-                    self.single_update_fee.write(new_fee);
+                    let old_fee = self.single_update_fee1.read();
+                    self.single_update_fee1.write(new_fee);
                     let event = FeeSet { old_fee, new_fee };
                     self.emit(event);
                 },
@@ -468,10 +491,6 @@ mod pyth {
             }
         }
 
-        fn get_total_fee(self: @ContractState, num_updates: u8) -> u256 {
-            self.single_update_fee.read() * num_updates.into()
-        }
-
         fn verify_governance_vm(ref self: ContractState, vm: @VerifiedVM) {
             let governance_data_source = self.governance_data_source.read();
             if governance_data_source.emitter_chain_id != *vm.emitter_chain_id {
@@ -611,18 +630,27 @@ mod pyth {
             let root_digest = parse_wormhole_proof(vm.payload);
 
             let num_updates = reader.read_u8();
-            let total_fee = self.get_total_fee(num_updates);
-            let fee_contract = IERC20CamelDispatcher {
-                contract_address: self.fee_token_address.read()
-            };
             let execution_info = get_execution_info().unbox();
             let caller = execution_info.caller_address;
             let contract = execution_info.contract_address;
-            if fee_contract.allowance(caller, contract) < total_fee {
-                panic_with_felt252(UpdatePriceFeedsError::InsufficientFeeAllowance.into());
-            }
-            if !fee_contract.transferFrom(caller, contract, total_fee) {
-                panic_with_felt252(UpdatePriceFeedsError::InsufficientFeeAllowance.into());
+            let fee1_transfered = transfer_fee(
+                num_updates,
+                caller,
+                contract,
+                self.fee_token_address1.read(),
+                self.single_update_fee1.read(),
+            );
+            if !fee1_transfered {
+                let fee2_transfered = transfer_fee(
+                    num_updates,
+                    caller,
+                    contract,
+                    self.fee_token_address2.read(),
+                    self.single_update_fee2.read(),
+                );
+                if !fee2_transfered {
+                    panic_with_felt252(UpdatePriceFeedsError::InsufficientFeeAllowance.into());
+                }
             }
 
             let mut i = 0;
@@ -708,4 +736,25 @@ mod pyth {
             Option::Some(i)
         }
     }
+
+    fn transfer_fee(
+        num_updates: u8,
+        caller: ContractAddress,
+        contract: ContractAddress,
+        fee_token: ContractAddress,
+        single_update_fee1: u256,
+    ) -> bool {
+        let total_fee = single_update_fee1 * num_updates.into();
+        let fee_contract = IERC20CamelDispatcher { contract_address: fee_token };
+        if fee_contract.allowance(caller, contract) < total_fee {
+            return false;
+        }
+        if fee_contract.balanceOf(caller) < total_fee {
+            return false;
+        }
+        if !fee_contract.transferFrom(caller, contract, total_fee) {
+            return false;
+        }
+        true
+    }
 }

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

@@ -113,3 +113,16 @@ impl ParsePriceFeedsErrorIntoFelt252 of Into<ParsePriceFeedsError, felt252> {
         }
     }
 }
+
+#[derive(Copy, Drop, Debug, Serde, PartialEq)]
+pub enum GetSingleUpdateFeeError {
+    UnsupportedToken,
+}
+
+impl GetSingleUpdateFeeErrorIntoFelt252 of Into<GetSingleUpdateFeeError, felt252> {
+    fn into(self: GetSingleUpdateFeeError) -> felt252 {
+        match self {
+            GetSingleUpdateFeeError::UnsupportedToken => 'unsupported token',
+        }
+    }
+}

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

@@ -33,10 +33,10 @@ pub trait IPyth<T> {
     fn parse_unique_price_feed_updates(
         ref self: T, data: ByteArray, price_ids: Array<u256>, publish_time: u64, max_staleness: u64,
     ) -> Array<PriceFeed>;
-    fn get_update_fee(self: @T, data: ByteArray) -> u256;
+    fn get_update_fee(self: @T, data: ByteArray, token: ContractAddress) -> u256;
     fn wormhole_address(self: @T) -> ContractAddress;
-    fn fee_token_address(self: @T) -> ContractAddress;
-    fn get_single_update_fee(self: @T) -> u256;
+    fn fee_token_addresses(self: @T) -> Array<ContractAddress>;
+    fn get_single_update_fee(self: @T, token: ContractAddress) -> u256;
     fn valid_data_sources(self: @T) -> Array<DataSource>;
     fn is_valid_data_source(self: @T, source: DataSource) -> bool;
     fn governance_data_source(self: @T) -> DataSource;