Governance: Maintenance update (#3832)

* chore: Add comment to unused Governance account

* chore: fix typos

* chore: Update comments

Author: SebastianBor

governance/program/src/processor/process_create_realm.rs

@@ -88,7 +88,7 @@ pub fn process_create_realm(
         None
     };
 
-    // Create and serialzie RealmConfig
+    // Create and serialize RealmConfig
     let realm_config_info = next_account_info(account_info_iter)?; // 10
 
     // 11, 12

governance/program/src/processor/process_set_governance_config.rs

@@ -30,7 +30,7 @@ pub fn process_set_governance_config(
 
     let mut governance_data = get_governance_data(program_id, governance_info)?;
 
-    // Until we have Veto implemented it's better to allow config change as the defence of last resort against governance attacks
+    // Until we have Veto implemented it's better to allow config change as the defense of last resort against governance attacks
     // Note: Config change leaves voting proposals in unpredictable state and it's DAOs responsibility
     // to ensure the changes are made when there are no proposals in voting state
     // For example changing approval quorum could accidentally make proposals to succeed which would otherwise be defeated

governance/program/src/processor/process_set_realm_config.rs

@@ -39,7 +39,7 @@ pub fn process_set_realm_config(
         return Err(GovernanceError::RealmAuthorityMustSign.into());
     }
 
-    // Until we have Veto implemented it's better to allow config change as the defence of last resort against governance attacks
+    // Until we have Veto implemented it's better to allow config change as the defense of last resort against governance attacks
     // Note: Config change leaves voting proposals in unpredictable state and it's DAOs responsibility
     // to ensure the changes are made when there are no proposals in voting state
     // For example changing voter-weight or max-voter-weight addin could accidentally make proposals to succeed which would otherwise be defeated

governance/program/src/processor/process_sign_off_proposal.rs

@@ -29,6 +29,9 @@ pub fn process_sign_off_proposal(program_id: &Pubkey, accounts: &[AccountInfo])
 
     let mut realm_data = get_realm_data(program_id, realm_info)?;
 
+    // Governance account data is no longer used in the current version but we still have to load it to validate Realm -> Governance -> Proposal relationship
+    // It could be replaced with PDA check but the account is going to be needed in future versions once we support mandatory signatories
+    // and hence keeping it as it is
     let _governance_data =
         get_governance_data_for_realm(program_id, governance_info, realm_info.key)?;
 

governance/program/src/state/realm.rs

@@ -65,15 +65,15 @@ pub struct GoverningTokenConfigArgs {
     pub token_type: GoverningTokenType,
 }
 
-/// Realm Config instruction args with account parametres
+/// Realm Config instruction args with account parameters
 #[derive(Clone, Debug, PartialEq, Eq, BorshDeserialize, BorshSerialize, BorshSchema, Default)]
 pub struct GoverningTokenConfigAccountArgs {
     /// Specifies an external plugin program which should be used to provide voters weights
-    /// for the given goventing token
+    /// for the given governing token
     pub voter_weight_addin: Option<Pubkey>,
 
     /// Specifies an external an external plugin program should be used to provide max voters weight
-    /// for the given goventing token
+    /// for the given governing token
     pub max_voter_weight_addin: Option<Pubkey>,
 
     /// Governing token type defines how the token is used for governance power
@@ -99,12 +99,12 @@ pub enum SetRealmAuthorityAction {
 /// Realm Config defining Realm parameters.
 #[derive(Clone, Debug, PartialEq, Eq, BorshDeserialize, BorshSerialize, BorshSchema)]
 pub struct RealmConfig {
-    /// Legacy field introdcued and used in V2 as use_community_voter_weight_addin: bool
+    /// Legacy field introduced and used in V2 as use_community_voter_weight_addin: bool
     /// If the field is going to be reused in future version it must be taken under consideration
     /// that for some Realms it might be already set to 1
     pub legacy1: u8,
 
-    /// Legacy field introdcued and used in V2 as use_max_community_voter_weight_addin: bool
+    /// Legacy field introduced and used in V2 as use_max_community_voter_weight_addin: bool
     /// If the field is going to be reused in future version it must be taken under consideration
     /// that for some Realms it might be already set to 1
     pub legacy2: u8,

governance/program/src/state/realm_config.rs

@@ -30,15 +30,15 @@ pub enum GoverningTokenType {
 
     /// Membership token is a token controlled by Realm authority
     /// Deposit - Yes, membership tokens can be deposited to gain governance power
-    ///           The membership tokens are conventionally minted into the holding account to keep them out of members possesion  
+    ///           The membership tokens are conventionally minted into the holding account to keep them out of members possession  
     /// Withdraw - No, after membership tokens are deposited they are no longer transferable and can't be withdrawn
     /// Revoke - Yes, Realm authority can Revoke (burn) membership tokens
     Membership,
 
     /// Dormant token is a token which is only a placeholder and its deposits are not accepted and not used for governance power within the Realm
     ///
     /// The Dormant token type is used when only a single voting population is operational. For example a Multisig starter DAO uses Council only
-    /// and sets Community as Dormant to indicate its not utilised for any governance power.
+    /// and sets Community as Dormant to indicate its not utilized for any governance power.
     /// Once the starter DAO decides to decentralise then it can change the Community token to Liquid
     ///
     /// Note: When an external voter weight plugin which takes deposits of the token is used then the type should be set to Dormant
@@ -162,7 +162,7 @@ impl RealmConfigAccount {
         }
     }
 
-    /// Assertes the given governing token can be deposited
+    /// Asserts the given governing token can be deposited
     pub fn assert_can_deposit_governing_token(
         &self,
         realm_data: &RealmV2,
@@ -175,12 +175,12 @@ impl RealmConfigAccount {
         match governing_token_type {
             GoverningTokenType::Membership | GoverningTokenType::Liquid => Ok(()),
             // Note: Preventing deposits of the Dormant type tokens is not a direct security concern
-            // It only makes the intention of not using deposited tokens as governnace power stronger
+            // It only makes the intention of not using deposited tokens as governance power stronger
             GoverningTokenType::Dormant => Err(GovernanceError::CannotDepositDormantTokens.into()),
         }
     }
 
-    /// Assertes the given governing token can be withdrawn
+    /// Asserts the given governing token can be withdrawn
     pub fn assert_can_withdraw_governing_token(
         &self,
         realm_data: &RealmV2,
@@ -198,15 +198,15 @@ impl RealmConfigAccount {
         }
     }
 
-    /// Asserts the given RealmConfigArgs represent a valid Realm configuraiton change
+    /// Asserts the given RealmConfigArgs represent a valid Realm configuration change
     pub fn assert_can_change_config(
         &self,
         realm_config_args: &RealmConfigArgs,
     ) -> Result<(), ProgramError> {
         // Existing community token type can't be changed to Membership because it would
         // give the Realm authority the right to burn members tokens which should not be the case because the tokens belong to the members
-        // On the other had for the Council token it's acceptable and in fact desired change becuase council tokens denote memebership
-        // which should be controled by the Realm
+        // On the other had for the Council token it's acceptable and in fact desired change because council tokens denote membership
+        // which should be controlled by the Realm
         if self.community_token_config.token_type != GoverningTokenType::Membership
             && realm_config_args.community_token_config_args.token_type
                 == GoverningTokenType::Membership
@@ -226,8 +226,8 @@ pub fn get_realm_config_data(
     get_account_data::<RealmConfigAccount>(program_id, realm_config_info)
 }
 
-/// If the account exists then desrialises it into RealmConfigAccount struct and checks the owner program and the Realm it belongs to
-/// If the accoutn doesn't exist then it checks its address is derived from the given owner program and Realm and returns default RealmConfigAccount
+/// If the account exists then deserializes it into RealmConfigAccount struct and checks the owner program and the Realm it belongs to
+/// If the account doesn't exist then it checks its address is derived from the given owner program and Realm and returns default RealmConfigAccount
 pub fn get_realm_config_data_for_realm(
     program_id: &Pubkey,
     realm_config_info: &AccountInfo,
@@ -236,7 +236,7 @@ pub fn get_realm_config_data_for_realm(
     let realm_config_data = if realm_config_info.data_is_empty() {
         // If RealmConfigAccount doesn't exist yet then validate its PDA
         // PDA validation is required because RealmConfigAccount might not exist for legacy Realms
-        // and then its absense is used as default RealmConfigAccount value with no plugins and Liquid governance tokens
+        // and then its absence is used as default RealmConfigAccount value with no plugins and Liquid governance tokens
         let realm_config_address = get_realm_config_address(program_id, realm);
 
         if realm_config_address != *realm_config_info.key {

governance/program/src/state/token_owner_record.rs

@@ -125,7 +125,7 @@ impl TokenOwnerRecordV2 {
             };
 
         // If the weight threshold is set to u64::MAX then it indicates explicitly Disabled value
-        // which should prevent any possiblity of using it
+        // which should prevent any possibility of using it
         if min_weight_to_create_proposal == u64::MAX {
             return Err(GovernanceError::VoterWeightThresholdDisabled.into());
         }
@@ -160,7 +160,7 @@ impl TokenOwnerRecordV2 {
             };
 
         // If the weight threshold is set to u64::MAX then it indicates explicitly Disabled value
-        // which should prevent any possiblity of using it
+        // which should prevent any possibility of using it
         if min_weight_to_create_governance == u64::MAX {
             return Err(GovernanceError::VoterWeightThresholdDisabled.into());
         }