Governance: Max voter weight addin (#2815)

* chore: change voter-weight-addin to mock

* chore: fix tests

* chore: add action, target and expiry validation tests

* chore: add full target test checks

* feat: add max community voter weight adding structures

* chore: move payer to last account position

* wip: update max_community_voter_weight_addin

* chore: simplify logic to update realm config

* wip: setup addins when realm is created

* wip: setup voter weights accounts

* chore: make clippy happy

* core: fix merge

* chore: remove old readme

* chore: add SetupMaxVoterWeightRecord to addin mock

* chore: test_create_realm_with_max_voter_weight_addin test

* chore: add SetRealmConfigArgs and refactor tests

* chore: update max voter weight tests

* chore: setup cast_vote_with_max_voter_weight_addin test

* wip: get max voter weight from plugin

* chore: update comments and make clippy happy

* wip: use max voter weight to tip proposals

* chore: rename get_max_voter_weight

* chore: load addins using different ids

* chore: add tests with all addins

* fix: coerce max vote weight when cast votes are higher

* chore: add tests with all adins being used

* chore: add test for expired max voter weight record

* chore: simplify addin mock

* wip: Create addin api crate

* chore: use native build order and dependency

* chore: fix build

* feat: add reserved space to addin records

* chore: bump versions

* fix: use [u8; 8] discriminator for addin account types

* chore: update instruction comments

* chore: use saturating_sub instead of checked_sub

Co-authored-by: Jon Cinque

Author: SebastianBor

Cargo.lock

@@ -11,6 +11,7 @@ members = [
   "feature-proposal/program",
   "feature-proposal/cli",
   "governance/addin-mock/program",
+  "governance/addin-api",
   "governance/program",
   "governance/test-sdk",
   "governance/tools",

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "spl-governance-addin-api"
+version = "0.1.0"
+description = "Solana Program Library Governance Addin Api"
+authors = ["Solana Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2018"
+
+[dependencies]
+borsh = "0.9.1"
+spl-governance-tools= { version = "0.1.1", path ="../tools"}
+solana-program = "1.9.5"
+

governance/addin-api/Cargo.toml

@@ -0,0 +1,3 @@
+# Governance Addin Api
+
+Governance Addin Api interface

governance/addin-api/README.md

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

governance/addin-api/src/lib.rs

@@ -0,0 +1,50 @@
+//! MaxVoterWeight Addin interface
+
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use solana_program::{clock::Slot, program_pack::IsInitialized, pubkey::Pubkey};
+use spl_governance_tools::account::AccountMaxSize;
+
+/// MaxVoterWeightRecord account
+/// The account is used as an api interface to provide max voting power to the governance program from external addin contracts
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub struct MaxVoterWeightRecord {
+    /// VoterWeightRecord discriminator sha256("account:MaxVoterWeightRecord")[..8]
+    /// Note: The discriminator size must match the addin implementing program discriminator size
+    /// to ensure it's stored in the private space of the account data and it's unique
+    pub account_discriminator: [u8; 8],
+
+    /// The Realm the MaxVoterWeightRecord belongs to
+    pub realm: Pubkey,
+
+    /// Governing Token Mint the MaxVoterWeightRecord 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,
+
+    /// Max voter weight
+    /// The max voter weight provided by the addin for the given realm and governing_token_mint
+    pub max_voter_weight: u64,
+
+    /// The slot when the max voting weight expires
+    /// It should be set to None if the weight never expires
+    /// If the max vote weight decays with time, for example for time locked based weights, then the expiry must be set
+    /// As a pattern Revise instruction to update the max 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 max_voter_weight_expiry: Option<Slot>,
+
+    /// Reserved space for future versions
+    pub reserved: [u8; 8],
+}
+
+impl AccountMaxSize for MaxVoterWeightRecord {}
+
+impl MaxVoterWeightRecord {
+    /// sha256("account:MaxVoterWeightRecord")[..8]
+    pub const ACCOUNT_DISCRIMINATOR: [u8; 8] = *b"9d5ff297";
+}
+
+impl IsInitialized for MaxVoterWeightRecord {
+    fn is_initialized(&self) -> bool {
+        self.account_discriminator == MaxVoterWeightRecord::ACCOUNT_DISCRIMINATOR
+    }
+}

governance/addin-api/src/max_voter_weight.rs

@@ -0,0 +1,81 @@
+//! VoterWeight Addin interface
+
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use solana_program::{clock::Slot, program_pack::IsInitialized, pubkey::Pubkey};
+use spl_governance_tools::account::AccountMaxSize;
+
+/// The governance action VoterWeight is evaluated for
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub enum VoterWeightAction {
+    /// Cast vote for a proposal. Target: Proposal
+    CastVote,
+
+    /// Comment a proposal. Target: Proposal
+    CommentProposal,
+
+    /// Create Governance within a realm. Target: Realm
+    CreateGovernance,
+
+    /// Create a proposal for a governance. Target: Governance
+    CreateProposal,
+}
+
+/// VoterWeightRecord account
+/// The account is used as an api interface to provide voting power to the governance program from external addin contracts
+#[derive(Clone, Debug, PartialEq, BorshDeserialize, BorshSerialize, BorshSchema)]
+pub struct VoterWeightRecord {
+    /// VoterWeightRecord discriminator sha256("account:VoterWeightRecord")[..8]
+    /// Note: The discriminator size must match the addin implementing program discriminator size
+    /// to ensure it's stored in the private space of the account data and it's unique
+    pub account_discriminator: [u8; 8],
+
+    /// 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
+    /// This is the actual owner (voter) and corresponds to TokenOwnerRecord.governing_token_owner
+    pub governing_token_owner: Pubkey,
+
+    /// Voter's weight
+    /// The weight of the voter provided by the addin for the given realm, governing_token_mint and governing_token_owner (voter)
+    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>,
+
+    /// The governance action the voter's weight pertains to
+    /// It allows to provided voter's weight specific to the particular action the weight is evaluated for
+    /// When the action is provided then the governance program asserts the executing action is the same as specified by the addin
+    pub weight_action: Option<VoterWeightAction>,
+
+    /// The target the voter's weight  action pertains to
+    /// It allows to provided voter's weight specific to the target the weight is evaluated for
+    /// For example when addin supplies weight to vote on a particular proposal then it must specify the proposal as the action target
+    /// When the target is provided then the governance program asserts the target is the same as specified by the addin
+    pub weight_action_target: Option<Pubkey>,
+
+    /// Reserved space for future versions
+    pub reserved: [u8; 8],
+}
+
+impl VoterWeightRecord {
+    /// sha256("account:VoterWeightRecord")[..8]
+    pub const ACCOUNT_DISCRIMINATOR: [u8; 8] = *b"2ef99b4b";
+}
+
+impl AccountMaxSize for VoterWeightRecord {}
+
+impl IsInitialized for VoterWeightRecord {
+    fn is_initialized(&self) -> bool {
+        self.account_discriminator == VoterWeightRecord::ACCOUNT_DISCRIMINATOR
+    }
+}

governance/addin-api/src/voter_weight.rs

@@ -21,8 +21,8 @@ serde = "1.0.127"
 serde_derive = "1.0.103"
 solana-program = "1.9.5"
 spl-token = { version = "3.3", path = "../../../token/program", features = [ "no-entrypoint" ] }
-spl-governance= { version = "2.1.2", path ="../../program", features = [ "no-entrypoint" ]}
-spl-governance-tools= { version = "0.1.0", path ="../../tools"}
+spl-governance-addin-api= { version = "0.1.0", path ="../../addin-api"}
+spl-governance-tools= { version = "0.1.1", path ="../../tools"}
 thiserror = "1.0"
 
 
@@ -32,7 +32,7 @@ base64 = "0.13"
 proptest = "1.0"
 solana-program-test = "1.9.5"
 solana-sdk = "1.9.5"
-spl-governance-test-sdk = { version = "0.1.0", path ="../../test-sdk"}
+spl-governance-test-sdk = { version = "0.1.1", path ="../../test-sdk"}
 
 
 [lib]

governance/addin-mock/program/Cargo.toml

@@ -14,7 +14,7 @@ pub enum VoterWeightAddinError {}
 
 impl PrintProgramError for VoterWeightAddinError {
     fn print<E>(&self) {
-        msg!("VOTER-WEIGHT-ADDIN-ERROR: {}", &self.to_string());
+        msg!("GOVERNANCE-ADDIN-MOCK-ERROR: {}", &self.to_string());
     }
 }
 
@@ -26,6 +26,6 @@ impl From<VoterWeightAddinError> for ProgramError {
 
 impl<T> DecodeError<T> for VoterWeightAddinError {
     fn type_of() -> &'static str {
-        "Voter Weight Addin Error"
+        "Governance Addin Mock Error"
     }
 }

governance/addin-mock/program/src/error.rs

@@ -7,7 +7,7 @@ use solana_program::{
     pubkey::Pubkey,
     system_program,
 };
-use spl_governance::addins::voter_weight::VoterWeightAction;
+use spl_governance_addin_api::voter_weight::VoterWeightAction;
 
 /// Instructions supported by the VoterWeight addin program
 /// This program is a mock program used by spl-governance for testing and not real addin
@@ -19,7 +19,7 @@ pub enum VoterWeightAddinInstruction {
     /// 0. `[]` Governance Program Id
     /// 1. `[]` Realm account
     /// 2. `[]` Governing Token mint
-    /// 3. `[]` TokenOwnerRecord
+    /// 3. `[]` Governing token owner
     /// 4. `[writable]` VoterWeightRecord
     /// 5. `[signer]` Payer
     /// 6. `[]` System
@@ -40,17 +40,32 @@ pub enum VoterWeightAddinInstruction {
         #[allow(dead_code)]
         weight_action_target: Option<Pubkey>,
     },
+    /// Sets up MaxVoterWeightRecord owned by the program
+    ///
+    /// 0. `[]` Realm account
+    /// 1. `[]` Governing Token mint
+    /// 2. `[writable]` MaxVoterWeightRecord
+    /// 3. `[signer]` Payer
+    /// 4. `[]` System
+    SetupMaxVoterWeightRecord {
+        /// Max Voter weight
+        #[allow(dead_code)]
+        max_voter_weight: u64,
+
+        /// Voter weight expiry
+        #[allow(dead_code)]
+        max_voter_weight_expiry: Option<Slot>,
+    },
 }
 
 /// Creates SetupVoterWeightRecord instruction
 #[allow(clippy::too_many_arguments)]
 pub fn setup_voter_weight_record(
     program_id: &Pubkey,
     // Accounts
-    governance_program_id: &Pubkey,
     realm: &Pubkey,
     governing_token_mint: &Pubkey,
-    token_owner_record: &Pubkey,
+    governing_token_owner: &Pubkey,
     voter_weight_record: &Pubkey,
     payer: &Pubkey,
     // Args
@@ -60,10 +75,9 @@ pub fn setup_voter_weight_record(
     weight_action_target: Option<Pubkey>,
 ) -> Instruction {
     let accounts = vec![
-        AccountMeta::new_readonly(*governance_program_id, false),
         AccountMeta::new_readonly(*realm, false),
         AccountMeta::new_readonly(*governing_token_mint, false),
-        AccountMeta::new_readonly(*token_owner_record, false),
+        AccountMeta::new_readonly(*governing_token_owner, false),
         AccountMeta::new(*voter_weight_record, true),
         AccountMeta::new_readonly(*payer, true),
         AccountMeta::new_readonly(system_program::id(), false),
@@ -82,3 +96,36 @@ pub fn setup_voter_weight_record(
         data: instruction.try_to_vec().unwrap(),
     }
 }
+
+/// Creates SetupMaxVoterWeightRecord instruction
+#[allow(clippy::too_many_arguments)]
+pub fn setup_max_voter_weight_record(
+    program_id: &Pubkey,
+    // Accounts
+    realm: &Pubkey,
+    governing_token_mint: &Pubkey,
+    max_voter_weight_record: &Pubkey,
+    payer: &Pubkey,
+    // Args
+    max_voter_weight: u64,
+    max_voter_weight_expiry: Option<Slot>,
+) -> Instruction {
+    let accounts = vec![
+        AccountMeta::new_readonly(*realm, false),
+        AccountMeta::new_readonly(*governing_token_mint, false),
+        AccountMeta::new(*max_voter_weight_record, true),
+        AccountMeta::new_readonly(*payer, true),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+
+    let instruction = VoterWeightAddinInstruction::SetupMaxVoterWeightRecord {
+        max_voter_weight,
+        max_voter_weight_expiry,
+    };
+
+    Instruction {
+        program_id: *program_id,
+        accounts,
+        data: instruction.try_to_vec().unwrap(),
+    }
+}