Governance: voters weights add-in

Cargo.toml

@@ -10,6 +10,7 @@ members = [
   "examples/rust/transfer-lamports",
   "feature-proposal/program",
   "feature-proposal/cli",
+  "governance/voter-weight-addin/program",
   "governance/program",
   "governance/test-sdk",
   "governance/chat/program",

governance/chat/program/Cargo.toml

@@ -21,7 +21,7 @@ serde = "1.0.127"
 serde_derive = "1.0.103"
 solana-program = "1.7.11"
 spl-token = { version = "3.2", path = "../../../token/program", features = [ "no-entrypoint" ] }
-spl-governance= { version = "1.1.0", path ="../../program", features = [ "no-entrypoint" ]}
+spl-governance= { version = "2.1.0", path ="../../program", features = [ "no-entrypoint" ]}
 thiserror = "1.0"
 
 

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

@@ -87,6 +87,7 @@ impl GovernanceChatProgramTest {
             &governing_token_mint_keypair.pubkey(),
             &self.bench.payer.pubkey(),
             None,
+            None,
             name.clone(),
             1,
             MintMaxVoteWeightSource::FULL_SUPPLY_FRACTION,
@@ -155,11 +156,13 @@ impl GovernanceChatProgramTest {
             &governed_account_address,
             &token_owner_record_address,
             &self.bench.payer.pubkey(),
+            &token_owner.pubkey(),
+            None,
             governance_config,
         );
 
         self.bench
-            .process_transaction(&[create_account_governance_ix], None)
+            .process_transaction(&[create_account_governance_ix], Some(&[&token_owner]))
             .await
             .unwrap();
 
@@ -173,14 +176,15 @@ impl GovernanceChatProgramTest {
 
         let proposal_name = "Proposal #1".to_string();
         let description_link = "Proposal Description".to_string();
-        let proposal_index = 0;
+        let proposal_index: u32 = 0;
 
         let create_proposal_ix = create_proposal(
             &self.governance_program_id,
             &governance_address,
             &token_owner_record_address,
             &token_owner.pubkey(),
             &self.bench.payer.pubkey(),
+            None,
             &realm_address,
             proposal_name,
             description_link.clone(),

governance/program/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spl-governance"
-version = "1.1.1"
+version = "2.1.1"
 description = "Solana Program Library Governance Program"
 authors = ["Solana Maintainers <maintainers@solana.foundation>"]
 repository = "https://github.com/solana-labs/solana-program-library"
@@ -30,6 +30,8 @@ proptest = "1.0"
 solana-program-test = "1.7.11"
 solana-sdk = "1.7.11"
 spl-governance-test-sdk = { version = "0.1.0", path ="../test-sdk"}
+spl-governance-v1 = {package="spl-governance", version = "1.1.1", features = [ "no-entrypoint" ] }
+
 
 [lib]
 crate-type = ["cdylib", "lib"]

governance/program/src/addins/mod.rs

@@ -0,0 +1,2 @@
+//! Governance add-ins interfaces
+pub mod voter_weight;

governance/program/src/addins/voter_weight.rs

@@ -0,0 +1,110 @@
+//! VoterWeight Addin interface
+
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use solana_program::{
+    account_info::AccountInfo,
+    clock::{Clock, Slot},
+    program_error::ProgramError,
+    program_pack::IsInitialized,
+    pubkey::Pubkey,
+    sysvar::Sysvar,
+};
+
+use crate::{
+    error::GovernanceError,
+    state::token_owner_record::TokenOwnerRecord,
+    tools::account::{get_account_data, AccountMaxSize},
+};
+
+/// VoterWeight account type
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub enum VoterWeightAccountType {
+    /// Default uninitialized account state
+    Uninitialized,
+
+    /// Voter Weight Record
+    VoterWeightRecord,
+}
+
+/// VoterWeight Record account
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub struct VoterWeightRecord {
+    /// VoterWeightRecord account type
+    pub account_type: VoterWeightAccountType,
+
+    /// The Realm the VoterWeightRecord belongs to
+    pub realm: Pubkey,
+
+    /// Governing Token Mint the VoterWeightRecord is associated with
+    /// Note: The addin can take deposits of any tokens and is not restricted to the community or council tokens only
+    // The mint here is to link the record to either community or council mint of the realm
+    pub governing_token_mint: Pubkey,
+
+    /// The owner of the governing token and voter
+    pub governing_token_owner: Pubkey,
+
+    /// Voter's weight
+    pub voter_weight: u64,
+
+    /// The slot when the voting weight expires
+    /// It should be set to None if the weight never expires
+    /// If the voter weight decays with time, for example for time locked based weights, then the expiry must be set
+    /// As a common pattern Revise instruction to update the weight should be invoked before governance instruction within the same transaction
+    /// and the expiry set to the current slot to provide up to date weight
+    pub voter_weight_expiry: Option<Slot>,
+}
+
+impl AccountMaxSize for VoterWeightRecord {}
+
+impl IsInitialized for VoterWeightRecord {
+    fn is_initialized(&self) -> bool {
+        self.account_type == VoterWeightAccountType::VoterWeightRecord
+    }
+}
+
+impl VoterWeightRecord {
+    /// Asserts the VoterWeightRecord hasn't expired
+    pub fn assert_is_up_to_date(&self) -> Result<(), ProgramError> {
+        if let Some(voter_weight_expiry) = self.voter_weight_expiry {
+            let slot = Clock::get().unwrap().slot;
+
+            if slot > voter_weight_expiry {
+                return Err(GovernanceError::VoterWeightRecordExpired.into());
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Deserializes VoterWeightRecord account and checks owner program
+pub fn get_voter_weight_record_data(
+    program_id: &Pubkey,
+    voter_weight_record_info: &AccountInfo,
+) -> Result<VoterWeightRecord, ProgramError> {
+    get_account_data::<VoterWeightRecord>(voter_weight_record_info, program_id)
+}
+
+/// Deserializes VoterWeightRecord account, checks owner program and asserts it's for the same realm, mint and token owner as the provided TokenOwnerRecord
+pub fn get_voter_weight_record_data_for_token_owner_record(
+    program_id: &Pubkey,
+    voter_weight_record_info: &AccountInfo,
+    token_owner_record: &TokenOwnerRecord,
+) -> Result<VoterWeightRecord, ProgramError> {
+    let voter_weight_record_data =
+        get_voter_weight_record_data(program_id, voter_weight_record_info)?;
+
+    if voter_weight_record_data.realm != token_owner_record.realm {
+        return Err(GovernanceError::InvalidVoterWeightRecordForRealm.into());
+    }
+
+    if voter_weight_record_data.governing_token_mint != token_owner_record.governing_token_mint {
+        return Err(GovernanceError::InvalidVoterWeightRecordForGoverningTokenMint.into());
+    }
+
+    if voter_weight_record_data.governing_token_owner != token_owner_record.governing_token_owner {
+        return Err(GovernanceError::InvalidVoterWeightRecordForTokenOwner.into());
+    }
+
+    Ok(voter_weight_record_data)
+}

governance/program/src/error.rs

@@ -323,6 +323,30 @@ pub enum GovernanceError {
     /// All proposals must be finalized to withdraw governing tokens
     #[error("All proposals must be finalized to withdraw governing tokens")]
     AllProposalsMustBeFinalisedToWithdrawGoverningTokens,
+
+    /// Invalid VoterWeightRecord for Realm
+    #[error("Invalid VoterWeightRecord for Realm")]
+    InvalidVoterWeightRecordForRealm,
+
+    /// Invalid VoterWeightRecord for GoverningTokenMint
+    #[error("Invalid VoterWeightRecord for GoverningTokenMint")]
+    InvalidVoterWeightRecordForGoverningTokenMint,
+
+    /// Invalid VoterWeightRecord for TokenOwner
+    #[error("Invalid VoterWeightRecord for TokenOwner")]
+    InvalidVoterWeightRecordForTokenOwner,
+
+    /// VoterWeightRecord expired
+    #[error("VoterWeightRecord expired")]
+    VoterWeightRecordExpired,
+
+    /// Invalid RealmConfig for Realm
+    #[error("Invalid RealmConfig for Realm")]
+    InvalidRealmConfigForRealm,
+
+    /// TokenOwnerRecord already exists
+    #[error("TokenOwnerRecord already exists")]
+    TokenOwnerRecordAlreadyExists,
 }
 
 impl PrintProgramError for GovernanceError {