Governance: Rename AccountGovernance to Governance (#2836)

* chore: rename AccountGovernance to Governance

* chore: make governed_account optional

* chore: rename account_governance to governance

Author: SebastianBor

governance/chat/program/tests/program_test/mod.rs

@@ -6,12 +6,12 @@ use solana_program_test::{processor, ProgramTest};
 use solana_sdk::{signature::Keypair, signer::Signer};
 use spl_governance::{
     instruction::{
-        create_account_governance, create_proposal, create_realm, create_token_owner_record,
+        create_governance, create_proposal, create_realm, create_token_owner_record,
         deposit_governing_tokens,
     },
     state::{
         enums::{MintMaxVoteWeightSource, VoteThresholdPercentage},
-        governance::{get_account_governance_address, GovernanceConfig},
+        governance::{get_governance_address, GovernanceConfig},
         proposal::{get_proposal_address, VoteType},
         realm::get_realm_address,
         token_owner_record::get_token_owner_record_address,
@@ -220,7 +220,7 @@ impl GovernanceChatProgramTest {
             None
         };
 
-        let create_account_governance_ix = create_account_governance(
+        let create_governance_ix = create_governance(
             &self.governance_program_id,
             &realm_address,
             &governed_account_address,
@@ -232,13 +232,13 @@ impl GovernanceChatProgramTest {
         );
 
         self.bench
-            .process_transaction(&[create_account_governance_ix], Some(&[&token_owner]))
+            .process_transaction(&[create_governance_ix], Some(&[&token_owner]))
             .await
             .unwrap();
 
         // Create Proposal
 
-        let governance_address = get_account_governance_address(
+        let governance_address = get_governance_address(
             &self.governance_program_id,
             &realm_address,
             &governed_account_address,

governance/program/src/instruction.rs

@@ -4,8 +4,8 @@ use crate::{
     state::{
         enums::MintMaxVoteWeightSource,
         governance::{
-            get_account_governance_address, get_mint_governance_address,
-            get_program_governance_address, get_token_governance_address, GovernanceConfig,
+            get_governance_address, get_mint_governance_address, get_program_governance_address,
+            get_token_governance_address, GovernanceConfig,
         },
         native_treasury::get_native_treasury_address,
         program_metadata::get_program_metadata_address,
@@ -107,19 +107,20 @@ pub enum GovernanceInstruction {
         new_governance_delegate: Option<Pubkey>,
     },
 
-    /// Creates Account Governance account which can be used to govern an arbitrary account
+    /// Creates Governance account which can be used to govern any arbitrary Solana account or asset
     ///
     ///   0. `[]` Realm account the created Governance belongs to
     ///   1. `[writable]` Account Governance account. PDA seeds: ['account-governance', realm, governed_account]
     ///   2. `[]` Account governed by this Governance
+    ///       Note: The account doesn't have to exist and can be only used as a unique identifier for the Governance account  
     ///   3. `[]` Governing TokenOwnerRecord account (Used only if not signed by RealmAuthority)
     ///   4. `[signer]` Payer
     ///   5. `[]` System program
     ///   6. `[]` Sysvar Rent
     ///   7. `[signer]` Governance authority
     ///   8. `[]` Realm Config
     ///   9. `[]` Optional Voter Weight Record
-    CreateAccountGovernance {
+    CreateGovernance {
         /// Governance config
         #[allow(dead_code)]
         config: GovernanceConfig,
@@ -682,27 +683,33 @@ pub fn set_governance_delegate(
     }
 }
 
-/// Creates CreateAccountGovernance instruction using optional voter weight addin
+/// Creates CreateGovernance instruction using optional voter weight addin
 #[allow(clippy::too_many_arguments)]
-pub fn create_account_governance(
+pub fn create_governance(
     program_id: &Pubkey,
     // Accounts
     realm: &Pubkey,
-    governed_account: &Pubkey,
+    governed_account: Option<&Pubkey>,
     token_owner_record: &Pubkey,
     payer: &Pubkey,
     create_authority: &Pubkey,
     voter_weight_record: Option<Pubkey>,
     // Args
     config: GovernanceConfig,
 ) -> Instruction {
-    let account_governance_address =
-        get_account_governance_address(program_id, realm, governed_account);
+    let governed_account_address = if let Some(governed_account) = governed_account {
+        *governed_account
+    } else {
+        // If the governed account is not provided then generate a unique identifier for the Governance account
+        Pubkey::new_unique()
+    };
+
+    let governance_address = get_governance_address(program_id, realm, &governed_account_address);
 
     let mut accounts = vec![
         AccountMeta::new_readonly(*realm, false),
-        AccountMeta::new(account_governance_address, false),
-        AccountMeta::new_readonly(*governed_account, false),
+        AccountMeta::new(governance_address, false),
+        AccountMeta::new_readonly(governed_account_address, false),
         AccountMeta::new_readonly(*token_owner_record, false),
         AccountMeta::new(*payer, true),
         AccountMeta::new_readonly(system_program::id(), false),
@@ -712,7 +719,7 @@ pub fn create_account_governance(
 
     with_realm_config_accounts(program_id, &mut accounts, realm, voter_weight_record, None);
 
-    let instruction = GovernanceInstruction::CreateAccountGovernance { config };
+    let instruction = GovernanceInstruction::CreateGovernance { config };
 
     Instruction {
         program_id: *program_id,

governance/program/src/processor/mod.rs

@@ -3,7 +3,7 @@
 mod process_add_signatory;
 mod process_cancel_proposal;
 mod process_cast_vote;
-mod process_create_account_governance;
+mod process_create_governance;
 mod process_create_mint_governance;
 mod process_create_native_treasury;
 mod process_create_program_governance;
@@ -32,7 +32,7 @@ use crate::instruction::GovernanceInstruction;
 use process_add_signatory::*;
 use process_cancel_proposal::*;
 use process_cast_vote::*;
-use process_create_account_governance::*;
+use process_create_governance::*;
 use process_create_mint_governance::*;
 use process_create_native_treasury::*;
 use process_create_program_governance::*;
@@ -134,8 +134,8 @@ pub fn process_instruction(
             transfer_account_authorities,
         ),
 
-        GovernanceInstruction::CreateAccountGovernance { config } => {
-            process_create_account_governance(program_id, accounts, config)
+        GovernanceInstruction::CreateGovernance { config } => {
+            process_create_governance(program_id, accounts, config)
         }
 
         GovernanceInstruction::CreateProposal {

governance/program/src/processor/process_create_account_governance.rs renamed to governance/program/src/processor/process_create_governance.rs

@@ -3,7 +3,7 @@
 use crate::state::{
     enums::GovernanceAccountType,
     governance::{
-        assert_valid_create_governance_args, get_account_governance_address_seeds, Governance,
+        assert_valid_create_governance_args, get_governance_address_seeds, Governance,
         GovernanceConfig,
     },
     realm::get_realm_data,
@@ -18,16 +18,16 @@ use solana_program::{
 
 use spl_governance_tools::account::create_and_serialize_account_signed;
 
-/// Processes CreateAccountGovernance instruction
-pub fn process_create_account_governance(
+/// Processes CreateGovernance instruction
+pub fn process_create_governance(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
     config: GovernanceConfig,
 ) -> ProgramResult {
     let account_info_iter = &mut accounts.iter();
 
     let realm_info = next_account_info(account_info_iter)?; // 0
-    let account_governance_info = next_account_info(account_info_iter)?; // 1
+    let governance_info = next_account_info(account_info_iter)?; // 1
     let governed_account_info = next_account_info(account_info_iter)?; // 2
 
     let token_owner_record_info = next_account_info(account_info_iter)?; // 3
@@ -52,8 +52,8 @@ pub fn process_create_account_governance(
         account_info_iter, // 8, 9
     )?;
 
-    let account_governance_data = Governance {
-        account_type: GovernanceAccountType::AccountGovernance,
+    let governance_data = Governance {
+        account_type: GovernanceAccountType::Governance,
         realm: *realm_info.key,
         governed_account: *governed_account_info.key,
         config,
@@ -63,9 +63,9 @@ pub fn process_create_account_governance(
 
     create_and_serialize_account_signed::<Governance>(
         payer_info,
-        account_governance_info,
-        &account_governance_data,
-        &get_account_governance_address_seeds(realm_info.key, governed_account_info.key),
+        governance_info,
+        &governance_data,
+        &get_governance_address_seeds(realm_info.key, governed_account_info.key),
         program_id,
         system_info,
         rent,

governance/program/src/state/enums.rs

@@ -15,8 +15,8 @@ pub enum GovernanceAccountType {
     /// Token Owner Record for given governing token owner within a Realm
     TokenOwnerRecord,
 
-    /// Generic Account Governance account
-    AccountGovernance,
+    /// Governance account
+    Governance,
 
     /// Program Governance account
     ProgramGovernance,

governance/program/src/state/governance.rs

@@ -50,7 +50,7 @@ pub struct GovernanceConfig {
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
 pub struct Governance {
-    /// Account type. It can be Uninitialized, AccountGovernance or ProgramGovernance
+    /// Account type. It can be Uninitialized, Governance, ProgramGovernance, TokenGovernance or MintGovernance
     pub account_type: GovernanceAccountType,
 
     /// Governance Realm
@@ -81,7 +81,7 @@ impl AccountMaxSize for Governance {}
 
 impl IsInitialized for Governance {
     fn is_initialized(&self) -> bool {
-        self.account_type == GovernanceAccountType::AccountGovernance
+        self.account_type == GovernanceAccountType::Governance
             || self.account_type == GovernanceAccountType::ProgramGovernance
             || self.account_type == GovernanceAccountType::MintGovernance
             || self.account_type == GovernanceAccountType::TokenGovernance
@@ -92,8 +92,8 @@ impl Governance {
     /// Returns Governance PDA seeds
     pub fn get_governance_address_seeds(&self) -> Result<[&[u8]; 3], ProgramError> {
         let seeds = match self.account_type {
-            GovernanceAccountType::AccountGovernance => {
-                get_account_governance_address_seeds(&self.realm, &self.governed_account)
+            GovernanceAccountType::Governance => {
+                get_governance_address_seeds(&self.realm, &self.governed_account)
             }
             GovernanceAccountType::ProgramGovernance => {
                 get_program_governance_address_seeds(&self.realm, &self.governed_account)
@@ -217,8 +217,8 @@ pub fn get_token_governance_address<'a>(
     .0
 }
 
-/// Returns AccountGovernance PDA seeds
-pub fn get_account_governance_address_seeds<'a>(
+/// Returns Governance PDA seeds
+pub fn get_governance_address_seeds<'a>(
     realm: &'a Pubkey,
     governed_account: &'a Pubkey,
 ) -> [&'a [u8]; 3] {
@@ -229,14 +229,14 @@ pub fn get_account_governance_address_seeds<'a>(
     ]
 }
 
-/// Returns AccountGovernance PDA address
-pub fn get_account_governance_address<'a>(
+/// Returns Governance PDA address
+pub fn get_governance_address<'a>(
     program_id: &Pubkey,
     realm: &'a Pubkey,
     governed_account: &'a Pubkey,
 ) -> Pubkey {
     Pubkey::find_program_address(
-        &get_account_governance_address_seeds(realm, governed_account),
+        &get_governance_address_seeds(realm, governed_account),
         program_id,
     )
     .0
@@ -250,7 +250,7 @@ pub fn assert_is_valid_governance(
     assert_is_valid_account2(
         governance_info,
         &[
-            GovernanceAccountType::AccountGovernance,
+            GovernanceAccountType::Governance,
             GovernanceAccountType::ProgramGovernance,
             GovernanceAccountType::TokenGovernance,
             GovernanceAccountType::MintGovernance,

governance/program/tests/process_add_signatory.rs

@@ -21,8 +21,8 @@ async fn test_add_signatory() {
         .await
         .unwrap();
 
-    let mut account_governance_cookie = governance_test
-        .with_account_governance(
+    let mut governance_cookie = governance_test
+        .with_governance(
             &realm_cookie,
             &governed_account_cookie,
             &token_owner_record_cookie,
@@ -31,7 +31,7 @@ async fn test_add_signatory() {
         .unwrap();
 
     let proposal_cookie = governance_test
-        .with_proposal(&token_owner_record_cookie, &mut account_governance_cookie)
+        .with_proposal(&token_owner_record_cookie, &mut governance_cookie)
         .await
         .unwrap();
 
@@ -68,8 +68,8 @@ async fn test_add_signatory_with_owner_or_delegate_must_sign_error() {
         .await
         .unwrap();
 
-    let mut account_governance_cookie = governance_test
-        .with_account_governance(
+    let mut governance_cookie = governance_test
+        .with_governance(
             &realm_cookie,
             &governed_account_cookie,
             &token_owner_record_cookie,
@@ -78,7 +78,7 @@ async fn test_add_signatory_with_owner_or_delegate_must_sign_error() {
         .unwrap();
 
     let proposal_cookie = governance_test
-        .with_proposal(&token_owner_record_cookie, &mut account_governance_cookie)
+        .with_proposal(&token_owner_record_cookie, &mut governance_cookie)
         .await
         .unwrap();
 
@@ -116,8 +116,8 @@ async fn test_add_signatory_with_invalid_proposal_owner_error() {
         .await
         .unwrap();
 
-    let mut account_governance_cookie = governance_test
-        .with_account_governance(
+    let mut governance_cookie = governance_test
+        .with_governance(
             &realm_cookie,
             &governed_account_cookie,
             &token_owner_record_cookie,
@@ -126,7 +126,7 @@ async fn test_add_signatory_with_invalid_proposal_owner_error() {
         .unwrap();
 
     let proposal_cookie = governance_test
-        .with_proposal(&token_owner_record_cookie, &mut account_governance_cookie)
+        .with_proposal(&token_owner_record_cookie, &mut governance_cookie)
         .await
         .unwrap();