feat(target_chains/starknet): support SetFeeInToken instruction

target_chains/starknet/contracts/src/pyth.cairo

@@ -90,6 +90,7 @@ mod pyth {
     pub struct FeeSet {
         pub old_fee: u256,
         pub new_fee: u256,
+        pub token: ContractAddress,
     }
 
     #[derive(Drop, Clone, Debug, PartialEq, Serde, starknet::Event)]
@@ -414,11 +415,10 @@ mod pyth {
             }
             match instruction.payload {
                 GovernancePayload::SetFee(payload) => {
-                    let new_fee = apply_decimal_expo(payload.value, payload.expo);
-                    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);
+                    self.set_fee(payload.value, payload.expo, self.fee_token_address1.read());
+                },
+                GovernancePayload::SetFeeInToken(payload) => {
+                    self.set_fee(payload.value, payload.expo, payload.token);
                 },
                 GovernancePayload::SetDataSources(payload) => {
                     let new_data_sources = payload.sources;
@@ -716,6 +716,23 @@ mod pyth {
             };
             output_array
         }
+
+        fn set_fee(ref self: ContractState, value: u64, expo: u64, token: ContractAddress) {
+            let new_fee = apply_decimal_expo(value, expo);
+            let old_fee = if token == self.fee_token_address1.read() {
+                let old_fee = self.single_update_fee1.read();
+                self.single_update_fee1.write(new_fee);
+                old_fee
+            } else if token == self.fee_token_address2.read() {
+                let old_fee = self.single_update_fee2.read();
+                self.single_update_fee2.write(new_fee);
+                old_fee
+            } else {
+                panic_with_felt252(GovernanceActionError::InvalidGovernanceMessage.into())
+            };
+            let event = FeeSet { old_fee, new_fee, token };
+            self.emit(event);
+        }
     }
 
     fn apply_decimal_expo(value: u64, expo: u64) -> u256 {

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

@@ -19,6 +19,7 @@ pub enum GovernanceAction {
     SetValidPeriod,
     RequestGovernanceDataSourceTransfer,
     SetWormholeAddress,
+    SetFeeInToken,
 }
 
 impl U8TryIntoGovernanceAction of TryInto<u8, GovernanceAction> {
@@ -31,6 +32,7 @@ impl U8TryIntoGovernanceAction of TryInto<u8, GovernanceAction> {
             4 => GovernanceAction::SetValidPeriod,
             5 => GovernanceAction::RequestGovernanceDataSourceTransfer,
             6 => GovernanceAction::SetWormholeAddress,
+            7 => GovernanceAction::SetFeeInToken,
             _ => { return Option::None; }
         };
         Option::Some(v)
@@ -52,6 +54,7 @@ pub enum GovernancePayload {
     // SetValidPeriod is unsupported
     RequestGovernanceDataSourceTransfer: RequestGovernanceDataSourceTransfer,
     SetWormholeAddress: SetWormholeAddress,
+    SetFeeInToken: SetFeeInToken,
 }
 
 #[derive(Drop, Clone, Debug, PartialEq, Serde)]
@@ -60,6 +63,13 @@ pub struct SetFee {
     pub expo: u64,
 }
 
+#[derive(Drop, Clone, Debug, PartialEq, Serde)]
+pub struct SetFeeInToken {
+    pub value: u64,
+    pub expo: u64,
+    pub token: ContractAddress,
+}
+
 #[derive(Drop, Clone, Debug, PartialEq, Serde)]
 pub struct SetDataSources {
     pub sources: Array<DataSource>,
@@ -155,6 +165,22 @@ pub fn parse_instruction(payload: ByteBuffer) -> GovernanceInstruction {
             let expo = reader.read_u64();
             GovernancePayload::SetFee(SetFee { value, expo })
         },
+        GovernanceAction::SetFeeInToken => {
+            let value = reader.read_u64();
+            let expo = reader.read_u64();
+            let token_len = reader.read_u8();
+            if token_len != 32 {
+                panic_with_felt252(GovernanceActionError::InvalidGovernanceMessage.into());
+            }
+            let token: felt252 = reader
+                .read_u256()
+                .try_into()
+                .expect(GovernanceActionError::InvalidGovernanceMessage.into());
+            let token = token
+                .try_into()
+                .expect(GovernanceActionError::InvalidGovernanceMessage.into());
+            GovernancePayload::SetFeeInToken(SetFeeInToken { value, expo, token })
+        },
         GovernanceAction::SetValidPeriod => { panic_with_felt252('unimplemented') },
         GovernanceAction::SetWormholeAddress => {
             let address: felt252 = reader

target_chains/starknet/contracts/tests/data.cairo

@@ -382,6 +382,19 @@ pub fn pyth_set_fee() -> ByteBuffer {
     ByteBufferImpl::new(bytes, 23)
 }
 
+// A Pyth governance instruction to set fee signed by the test guardian #1.
+pub fn pyth_set_fee_in_token() -> ByteBuffer {
+    let bytes = array![
+        1766847064779994694408617232155063622446317599437785683244896979152308796,
+        41831183904504604246915376354509245030219494606222324288494126672855141875,
+        245200731728170526984869527586075617087934630006881191137945784647849869312,
+        49565958604199796163020368,
+        148907253456468655193350049927026865683852796092680336764850032905682767430,
+        1535109346439504966152199052711447625482878604913825938427335,
+    ];
+    ByteBufferImpl::new(bytes, 25)
+}
+
 // A Pyth governance instruction to set data sources signed by the test guardian #1.
 pub fn pyth_set_data_sources() -> ByteBuffer {
     let bytes = array![

target_chains/starknet/contracts/tests/pyth.cairo

@@ -52,7 +52,9 @@ fn decode_event(mut event: Event) -> PythEvent {
         };
         PythEvent::PriceFeedUpdated(event)
     } else if key0 == event_name_hash('FeeSet') {
-        let event = FeeSet { old_fee: event.data.pop_u256(), new_fee: event.data.pop_u256(), };
+        let event = FeeSet {
+            old_fee: event.data.pop_u256(), new_fee: event.data.pop_u256(), token: event.data.pop(),
+        };
         PythEvent::FeeSet(event)
     } else if key0 == event_name_hash('DataSourcesSet') {
         let event = DataSourcesSet {
@@ -692,11 +694,16 @@ fn test_governance_set_fee_works() {
     let (from, event) = spy.events.pop_front().unwrap();
     assert!(from == pyth.contract_address);
     let event = decode_event(event);
-    let expected = FeeSet { old_fee: 1000, new_fee: 4200, };
+    let expected = FeeSet {
+        old_fee: 1000, new_fee: 4200, token: ctx.fee_contract.contract_address
+    };
     assert!(event == PythEvent::FeeSet(expected));
 
     let fee2 = pyth.get_update_fee(data::test_price_update2(), ctx.fee_contract.contract_address);
     assert!(fee2 == 4200);
+    let fee2_alt = pyth
+        .get_update_fee(data::test_price_update2(), ctx.fee_contract2.contract_address);
+    assert!(fee2_alt == 2000);
 
     start_prank(CheatTarget::One(pyth.contract_address), user);
     pyth.update_price_feeds(data::test_price_update2());
@@ -709,6 +716,62 @@ fn test_governance_set_fee_works() {
     assert!(last_price.price == 6281522520745);
 }
 
+#[test]
+fn test_governance_set_fee_in_token_works() {
+    let ctx = deploy_test();
+    let pyth = ctx.pyth;
+    let fee_contract = ctx.fee_contract;
+    let user = ctx.user;
+
+    let fee1 = pyth.get_update_fee(data::test_price_update1(), ctx.fee_contract.contract_address);
+    assert!(fee1 == 1000);
+    ctx.approve_fee(1000);
+
+    let mut balance = fee_contract.balanceOf(user);
+    start_prank(CheatTarget::One(pyth.contract_address), user);
+    pyth.update_price_feeds(data::test_price_update1());
+    stop_prank(CheatTarget::One(pyth.contract_address));
+    let new_balance = fee_contract.balanceOf(user);
+    assert!(balance - new_balance == 1000);
+    balance = new_balance;
+    let last_price = pyth
+        .get_price_unsafe(0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43)
+        .unwrap_with_felt252();
+    assert!(last_price.price == 6281060000000);
+
+    let mut spy = spy_events(SpyOn::One(pyth.contract_address));
+
+    pyth.execute_governance_instruction(data::pyth_set_fee_in_token());
+
+    spy.fetch_events();
+    assert!(spy.events.len() == 1);
+    let (from, event) = spy.events.pop_front().unwrap();
+    assert!(from == pyth.contract_address);
+    let event = decode_event(event);
+    let expected = FeeSet {
+        old_fee: 2000, new_fee: 4200, token: ctx.fee_contract2.contract_address
+    };
+    assert!(event == PythEvent::FeeSet(expected));
+
+    let fee2 = pyth.get_update_fee(data::test_price_update2(), ctx.fee_contract.contract_address);
+    assert!(fee2 == 1000);
+    let fee2_alt = pyth
+        .get_update_fee(data::test_price_update2(), ctx.fee_contract2.contract_address);
+    assert!(fee2_alt == 4200);
+    ctx.approve_fee2(4200);
+
+    let balance2 = ctx.fee_contract2.balanceOf(user);
+    start_prank(CheatTarget::One(pyth.contract_address), user);
+    pyth.update_price_feeds(data::test_price_update2());
+    stop_prank(CheatTarget::One(pyth.contract_address));
+    let new_balance2 = ctx.fee_contract2.balanceOf(user);
+    assert!(balance2 - new_balance2 == 4200);
+    let last_price = pyth
+        .get_price_unsafe(0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43)
+        .unwrap_with_felt252();
+    assert!(last_price.price == 6281522520745);
+}
+
 #[test]
 #[fuzzer(runs: 100, seed: 0)]
 #[should_panic]
@@ -806,8 +869,8 @@ fn test_governance_set_wormhole_works() {
 
     let user = 'user'.try_into().unwrap();
     let fee_class = declare("ERC20");
-    let fee_contract = deploy_fee_contract(fee_class, user);
-    let fee_contract2 = deploy_fee_contract(fee_class, user);
+    let fee_contract = deploy_fee_contract(fee_class, fee_address1(), user);
+    let fee_contract2 = deploy_fee_contract(fee_class, fee_address2(), user);
     let pyth = deploy_pyth_default(
         wormhole.contract_address, fee_contract.contract_address, fee_contract2.contract_address
     );
@@ -892,8 +955,8 @@ fn test_rejects_set_wormhole_without_deploying() {
 
     let user = 'user'.try_into().unwrap();
     let fee_class = declare("ERC20");
-    let fee_contract = deploy_fee_contract(fee_class, user);
-    let fee_contract2 = deploy_fee_contract(fee_class, user);
+    let fee_contract = deploy_fee_contract(fee_class, fee_address1(), user);
+    let fee_contract2 = deploy_fee_contract(fee_class, fee_address2(), user);
     let pyth = deploy_pyth_default(
         wormhole.contract_address, fee_contract.contract_address, fee_contract2.contract_address
     );
@@ -912,8 +975,8 @@ fn test_rejects_set_wormhole_with_incompatible_guardians() {
 
     let user = 'user'.try_into().unwrap();
     let fee_class = declare("ERC20");
-    let fee_contract = deploy_fee_contract(fee_class, user);
-    let fee_contract2 = deploy_fee_contract(fee_class, user);
+    let fee_contract = deploy_fee_contract(fee_class, fee_address1(), user);
+    let fee_contract2 = deploy_fee_contract(fee_class, fee_address2(), user);
     let pyth = deploy_pyth_default(
         wormhole.contract_address, fee_contract.contract_address, fee_contract2.contract_address
     );
@@ -1058,8 +1121,8 @@ fn deploy_test() -> Context {
     let user = 'user'.try_into().unwrap();
     let wormhole = super::wormhole::deploy_with_test_guardian();
     let fee_class = declare("ERC20");
-    let fee_contract = deploy_fee_contract(fee_class, user);
-    let fee_contract2 = deploy_fee_contract(fee_class, user);
+    let fee_contract = deploy_fee_contract(fee_class, fee_address1(), user);
+    let fee_contract2 = deploy_fee_contract(fee_class, fee_address2(), user);
     let pyth = deploy_pyth_default(
         wormhole.contract_address, fee_contract.contract_address, fee_contract2.contract_address
     );
@@ -1070,8 +1133,8 @@ fn deploy_mainnet() -> Context {
     let user = 'user'.try_into().unwrap();
     let wormhole = super::wormhole::deploy_with_mainnet_guardians();
     let fee_class = declare("ERC20");
-    let fee_contract = deploy_fee_contract(fee_class, user);
-    let fee_contract2 = deploy_fee_contract(fee_class, user);
+    let fee_contract = deploy_fee_contract(fee_class, fee_address1(), user);
+    let fee_contract2 = deploy_fee_contract(fee_class, fee_address2(), user);
     let pyth = deploy_pyth_default(
         wormhole.contract_address, fee_contract.contract_address, fee_contract2.contract_address
     );
@@ -1125,12 +1188,21 @@ fn deploy_pyth(
     IPythDispatcher { contract_address }
 }
 
-fn deploy_fee_contract(class: ContractClass, recipient: ContractAddress) -> IERC20CamelDispatcher {
+fn fee_address1() -> ContractAddress {
+    0x1010.try_into().unwrap()
+}
+fn fee_address2() -> ContractAddress {
+    0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7.try_into().unwrap()
+}
+
+fn deploy_fee_contract(
+    class: ContractClass, at: ContractAddress, recipient: ContractAddress
+) -> IERC20CamelDispatcher {
     let mut args = array![];
     let name: ByteArray = "eth";
     let symbol: ByteArray = "eth";
     (name, symbol, 100000_u256, recipient).serialize(ref args);
-    let contract_address = match class.deploy(@args) {
+    let contract_address = match class.deploy_at(@args, at) {
         Result::Ok(v) => { v },
         Result::Err(err) => { panic(err.panic_data) },
     };

target_chains/starknet/tools/test_vaas/src/bin/generate_test_data.rs

@@ -200,6 +200,29 @@ fn main() {
         "A Pyth governance instruction to set fee signed by the test guardian #1.",
     );
 
+    let pyth_set_fee_in_token_payload = vec![
+        80, 84, 71, 77, 1, 7, 234, 147, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 2, 32, 4,
+        157, 54, 87, 13, 78, 70, 244, 142, 153, 103, 75, 211, 252, 200, 70, 68, 221, 214, 185, 111,
+        124, 116, 27, 21, 98, 184, 47, 158, 0, 77, 199,
+    ];
+    let pyth_set_fee_in_token = serialize_vaa(guardians.sign_vaa(
+        &[0],
+        VaaBody {
+            timestamp: 1,
+            nonce: 2,
+            emitter_chain: 1,
+            emitter_address: u256_to_be(41.into()).into(),
+            sequence: 1.try_into().unwrap(),
+            consistency_level: 6,
+            payload: PayloadKind::Binary(pyth_set_fee_in_token_payload.clone()),
+        },
+    ));
+    print_as_cairo_fn(
+        &pyth_set_fee_in_token,
+        "pyth_set_fee_in_token",
+        "A Pyth governance instruction to set fee signed by the test guardian #1.",
+    );
+
     let pyth_set_data_sources = serialize_vaa(guardians.sign_vaa(
         &[0],
         VaaBody {