new governance functions added into GovernanceAction enum

Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>

pallets/exodus/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-exodus"
-version = "0.1.2"
+version = "0.1.3"
 description = "Threshold signature generation with DKG included"
 license.workspace = true
 authors.workspace = true

pallets/exodus/src/tests.rs

@@ -1002,12 +1002,18 @@ fn test_all_validators_can_execute_dkg() {
         let withdraw = GovernanceAction::Withdraw { token: dummy_address, amount: 420 };
         let audit = GovernanceAction::AuditReserves;
 
+        let set_router_index = GovernanceAction::SetRouterRegistryIndex { index: 420 };
+        let token_approve = GovernanceAction::Approve { spender: dummy_address, value: 1337 };
+
         Exodus::do_register_evm_governance(network_id, dummy_address, enable).unwrap();
         Exodus::do_register_evm_governance(network_id, dummy_address, disable).unwrap();
         Exodus::do_register_evm_governance(network_id, dummy_address, forfeit).unwrap();
         Exodus::do_register_evm_governance(network_id, dummy_address, redeem).unwrap();
         Exodus::do_register_evm_governance(network_id, dummy_address, withdraw).unwrap();
         Exodus::do_register_evm_governance(network_id, dummy_address, audit).unwrap();
+
+        Exodus::do_register_evm_governance(network_id, dummy_address, set_router_index).unwrap();
+        Exodus::do_register_evm_governance(network_id, dummy_address, token_approve).unwrap();
     });
 
     ext.execute_with(|| {
@@ -1038,7 +1044,7 @@ fn test_all_validators_can_execute_dkg() {
 
     assert_eq!(rotations_count, 3);
     assert_eq!(bridges_count, 2);
-    assert_eq!(governances_count, 15);
+    assert_eq!(governances_count, 17);
     assert_eq!(pending_exodus_requests, 0);
 }
 

pallets/exodus/src/types/exodus_request.rs

@@ -174,6 +174,7 @@ pub enum GovernanceStatus {
 
 #[derive(Encode, Decode, Clone, Copy, PartialEq, TypeInfo, RuntimeDebug)]
 pub enum GovernanceAction {
+    SetRouterRegistryIndex { index: u128 },
     SetDistributor { distributor: EvmAddress },
     SetWarmupPeriod { warmup_period: u128 },
     UpdateGatekeeperAddress { new_gatekeeper: EvmAddress },
@@ -199,6 +200,8 @@ pub enum GovernanceAction {
         intervals: [u32; 2],
         booleans: [bool; 2],
     },
+
+    Approve { spender: EvmAddress, value: u128, },
 }
 
 impl GovernanceAction {
@@ -207,6 +210,13 @@ impl GovernanceAction {
         message_buffer: &'a mut [u8; MAX_MESSAGE_SIZE as usize],
     ) -> Option<&'a [u8]> {
         match &self {
+            Self::SetRouterRegistryIndex { index } => {
+                abi_encode_evm_message!(
+                    message_buffer,
+                    "setRouterRegistryIndex(uint256)",
+                    [index]
+                )
+            },
             Self::SetDistributor { distributor } => {
                 abi_encode_evm_message!(
                     message_buffer,
@@ -312,6 +322,13 @@ impl GovernanceAction {
                     [market, terms, token, intervals, &booleans_u8]
                 )
             },
+            Self::Approve { spender, value } => {
+                abi_encode_evm_message!(
+                    message_buffer,
+                    "approve(address,uint256)",
+                    [spender, value]
+                )
+            },
         }
     }
 }
@@ -681,6 +698,12 @@ mod tests {
             assert_eq!((message.len() - 4) % 32, 0);
 
             match action_clone {
+                GovernanceAction::SetRouterRegistryIndex { index } => {
+                    let hash = keccak_256("setRouterRegistryIndex(uint256)".as_bytes());
+                    assert_eq!(inner_payload[0..4], hash[0..4]);
+                    let decoded_warmup = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
+                    assert_eq!(decoded_warmup, index as u32);
+                },
                 GovernanceAction::SetDistributor { distributor } => {
                     let hash = keccak_256("setDistributor(address)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
@@ -794,6 +817,13 @@ mod tests {
 
                     assert_eq!(inner_payload[323], booleans[0] as u8);
                     assert_eq!(inner_payload[355], booleans[1] as u8);
+                },
+                GovernanceAction::Approve { spender, value } => {
+                    let hash = keccak_256("approve(address,uint256)".as_bytes());
+                    assert_eq!(inner_payload[0..4], hash[0..4]);
+                    assert_eq!(&inner_payload[16..36], spender.as_ref());
+                    let decoded_amount = u32::from_be_bytes(inner_payload[64..68].try_into().unwrap());
+                    assert_eq!(decoded_amount, value as u32);
                 }
             }
         }