fix size in collection config

Author: crypt0miester

programs/core-attribute-voter/README.md

@@ -12,7 +12,7 @@ Core Attribute Voter allows DAOs to use NFT collections for governance voting wh
 
 Each configured collection specifies:
 - A **weight attribute key** (e.g. `"voting_power"`, `"tier"`) — the attribute name to read from each NFT
-- A **max weight** — a ceiling that caps any single NFT's voting power
+- A **max weight** — a ceiling that caps any single NFT's voting power and represents the collection's max governance weight
 - An **expected attribute authority** — the trusted authority that set the attributes
 
 When a voter submits their NFTs, the program:
@@ -32,10 +32,39 @@ When a voter submits their NFTs, the program:
 The maximum possible voting power across all configured collections:
 
 ```
-max_voter_weight = Σ (collection.size × collection.max_weight)
+max_voter_weight = Σ collection.max_weight
 ```
 
-This is used by SPL Governance to calculate quorum thresholds.
+This is used by SPL Governance to calculate quorum thresholds. Unlike the nft-voter and core-voter plugins (where max weight = `collection_size × weight_per_nft`), attribute-based voting has variable per-NFT weights, so `max_weight` must be set by the realm authority to reflect the expected total voting power of each collection.
+
+#### Setting `max_weight` correctly
+
+`max_weight` plays a dual role — it caps individual NFT weights **and** feeds into the quorum denominator. Getting it right matters:
+
+**Example 1 — Well-calibrated:**
+A collection of 50 NFTs where attributes range from 1–10, totalling ~200 across the collection.
+Setting `max_weight = 200` means:
+- Individual NFTs are capped at 200 (effectively uncapped since max attribute is 10)
+- Quorum denominator reflects the true total voting power
+- A 60% quorum requires 120 voting power to pass
+
+**Example 2 — Set too low:**
+Same collection, but `max_weight = 50`.
+- Individual NFTs with attribute > 50 get capped (unlikely here, but enforced)
+- Quorum denominator is only 50, so just 30 voting power (60% quorum) passes a proposal
+- Risk: a small minority of NFT holders can pass proposals
+
+**Example 3 — Set too high:**
+Same collection, but `max_weight = 10000`.
+- No individual capping (attributes are far below 10000)
+- Quorum denominator is 10000, so 6000 voting power needed for 60% quorum
+- Risk: quorum becomes unreachable since the collection only holds ~200 total power
+
+**Example 4 — Multiple collections:**
+Collection A: `max_weight = 500`, Collection B: `max_weight = 300`.
+- `max_voter_weight = 500 + 300 = 800`
+- A voter holding NFTs from both collections accumulates weight across them
+- 60% quorum requires 480 total voting power
 
 ## Architecture
 
@@ -133,7 +162,7 @@ relinquish_nft_vote()
 
 | Parameter | Type | Constraints | Description |
 |---|---|---|---|
-| `max_weight` | `u64` | Any value | Per-NFT weight ceiling |
+| `max_weight` | `u64` | > 0 | Max governance weight for the collection. Caps individual NFT weights and is summed across collections for quorum calculation. Should reflect the expected total voting power of the collection. |
 | `weight_attribute_key` | `String` | 1–32 characters | Attribute name to read from NFTs |
 | `expected_attribute_authority` | `PluginAuthority` | Must match plugin | Trusted authority for attribute validation |
 

programs/core-attribute-voter/src/error.rs

@@ -9,8 +9,8 @@ pub enum CoreNftAttributeVoterError {
     #[msg("Invalid Realm for Registrar")]
     InvalidRealmForRegistrar,
 
-    #[msg("Invalid Collection Size")]
-    InvalidCollectionSize,
+    #[msg("Invalid max weight, must be greater than 0")]
+    InvalidMaxWeight,
 
     #[msg("Invalid MaxVoterWeightRecord Realm")]
     InvalidMaxVoterWeightRecordRealm,

programs/core-attribute-voter/src/instructions/configure_collection.rs

@@ -52,6 +52,7 @@ pub fn configure_collection(
     weight_attribute_key: String,
     expected_attribute_authority: PluginAuthority,
 ) -> Result<()> {
+    let collection_key = ctx.accounts.collection.key();
     let registrar = &mut ctx.accounts.registrar;
 
     let realm = realm::get_realm_data_for_governing_token_mint(
@@ -65,33 +66,29 @@ pub fn configure_collection(
         CoreNftAttributeVoterError::InvalidRealmAuthority
     );
 
+    require!(
+        max_weight > 0,
+        CoreNftAttributeVoterError::InvalidMaxWeight
+    );
+
     // Validate weight_attribute_key
     require!(
         !weight_attribute_key.is_empty() && weight_attribute_key.len() <= 32,
         CoreNftAttributeVoterError::InvalidWeightAttributeKey
     );
 
-    let collection = &ctx.accounts.collection;
-
-    let size = collection.current_size;
-
-    msg!("Collection size: {}", size);
-
-    require!(size > 0, CoreNftAttributeVoterError::InvalidCollectionSize);
-
     let collection_config = CollectionConfig {
-        collection: collection.key(),
+        collection: collection_key,
         max_weight,
         weight_attribute_key,
         expected_attribute_authority,
         reserved: [0; 8],
-        size,
     };
 
     let collection_idx = registrar
         .collection_configs
         .iter()
-        .position(|cc| cc.collection == collection.key());
+        .position(|cc| cc.collection == collection_key);
 
     if let Some(collection_idx) = collection_idx {
         registrar.collection_configs[collection_idx] = collection_config;

programs/core-attribute-voter/src/state/collection_config.rs

@@ -1,19 +1,17 @@
 use anchor_lang::prelude::*;
 use mpl_core::types::PluginAuthority;
 
-use crate::error::CoreNftAttributeVoterError;
-
 /// Configuration of an NFT collection used for attribute-based governance power
 #[derive(AnchorSerialize, AnchorDeserialize, Debug, Clone, PartialEq)]
 pub struct CollectionConfig {
     /// The NFT collection used for governance
     pub collection: Pubkey,
 
-    /// The size of the NFT collection used to calculate max voter weight
-    pub size: u32,
-
-    /// Maximum governance power weight of the collection (ceiling for max voter weight calculation)
-    /// Note: The weight is scaled accordingly to the governing_token_mint decimals
+    /// Maximum governance power weight of the collection
+    /// Serves as both the per-NFT weight cap and the quorum denominator contribution
+    /// (i.e. it is summed across collections to produce MaxVoterWeightRecord.max_voter_weight)
+    /// Should be set to the expected total voting power of the collection,
+    /// in the same unit/scale as the attribute values stored on the NFTs
     pub max_weight: u64,
 
     /// The attribute key to read the voting weight from on each NFT
@@ -29,21 +27,15 @@ pub struct CollectionConfig {
 }
 
 impl CollectionConfig {
-    /// Borsh serialized size: 32 (Pubkey) + 4 (u32) + 8 (u64) + 4+32 (String with max 32 chars) + 33 (PluginAuthority) + 8 (reserved)
-    pub const SERIALIZED_SIZE: usize = 32 + 4 + 8 + 36 + 33 + 8;
+    /// Borsh serialized size: 32 (Pubkey) + 8 (u64) + 4+32 (String with max 32 chars) + 33 (PluginAuthority) + 8 (reserved)
+    pub const SERIALIZED_SIZE: usize = 32 + 8 + 36 + 33 + 8;
 
-    pub fn get_max_weight(&self) -> Result<u64> {
-        (self.size as u64)
-            .checked_mul(self.max_weight)
-            .ok_or_else(|| CoreNftAttributeVoterError::ArithmeticOverflow.into())
-    }
 }
 
 impl Default for CollectionConfig {
     fn default() -> Self {
         Self {
             collection: Pubkey::default(),
-            size: 0,
             max_weight: 0,
             // Default to a 32-byte zero-padded string for deterministic sizing
             weight_attribute_key: "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0".to_string(),

programs/core-attribute-voter/src/state/registrar.rs

@@ -68,8 +68,7 @@ impl Registrar {
         self.collection_configs
             .iter()
             .try_fold(0u64, |sum, cc| {
-                let weight = cc.get_max_weight()?;
-                sum.checked_add(weight)
+                sum.checked_add(cc.max_weight)
                     .ok_or_else(|| CoreNftAttributeVoterError::ArithmeticOverflow.into())
             })
     }

programs/core-attribute-voter/tests/configure_collection.rs

@@ -62,8 +62,7 @@ async fn test_configure_collection() -> Result<(), TransportError> {
     assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None);
     assert_eq!(
         max_voter_weight_record.max_voter_weight,
-        (registrar.collection_configs[0].max_weight as u32 * registrar.collection_configs[0].size)
-            as u64
+        registrar.collection_configs[0].max_weight
     );
 
     Ok(())
@@ -132,7 +131,7 @@ async fn test_configure_multiple_collections() -> Result<(), TransportError> {
         .await;
 
     assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None);
-    assert_eq!(max_voter_weight_record.max_voter_weight, 25);
+    assert_eq!(max_voter_weight_record.max_voter_weight, 3);
 
     Ok(())
 }
@@ -182,7 +181,7 @@ async fn test_configure_max_collections() -> Result<(), TransportError> {
         .await;
 
     assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None);
-    assert_eq!(max_voter_weight_record.max_voter_weight, 30);
+    assert_eq!(max_voter_weight_record.max_voter_weight, 10);
 
     Ok(())
 }
@@ -237,7 +236,7 @@ async fn test_configure_existing_collection() -> Result<(), TransportError> {
         .await;
 
     assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None);
-    assert_eq!(max_voter_weight_record.max_voter_weight, 20);
+    assert_eq!(max_voter_weight_record.max_voter_weight, 2);
 
     Ok(())
 }

programs/core-attribute-voter/tests/program_test/core_voter_test.rs

@@ -553,13 +553,8 @@ impl CoreVoterTest {
             .process_transaction(&[configure_collection_ix], Some(signers))
             .await?;
 
-        let collection_account = self
-            .get_collection_account(&collection_cookie.collection)
-            .await;
-
         let collection_config = CollectionConfig {
             collection: collection_cookie.collection,
-            size: collection_account.current_size,
             max_weight: args.max_weight,
             weight_attribute_key: args.weight_attribute_key,
             expected_attribute_authority: args.expected_attribute_authority,

programs/core-attribute-voter/tests/relinquish_nft_vote.rs

@@ -38,7 +38,7 @@ async fn test_relinquish_nft_vote() -> Result<(), TransportError> {
             &registrar_cookie,
             &collection_cookie,
             &max_voter_weight_record_cookie,
-            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // Set Size == 1 to complete voting with just one vote
+            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // max_weight == 1 to complete voting with just one vote
         )
         .await?;
 
@@ -239,8 +239,7 @@ async fn test_relinquish_nft_vote_for_proposal_in_voting_state_and_vote_record_e
             &registrar_cookie,
             &collection_cookie,
             &max_voter_weight_record_cookie,
-            None
-            
+            Some(ConfigureCollectionArgs { max_weight: 5, ..Default::default() }), // max_weight > vote weight so proposal stays in Voting
         )
         .await?;
 
@@ -285,8 +284,6 @@ async fn test_relinquish_nft_vote_for_proposal_in_voting_state_and_vote_record_e
         .err()
         .unwrap();
 
-    println!("{:?}", err);
-
     // Assert
     assert_nft_voter_err(err, CoreNftAttributeVoterError::VoteRecordMustBeWithdrawn);
 
@@ -323,7 +320,7 @@ async fn test_relinquish_nft_vote_with_invalid_voter_error() -> Result<(), Trans
             &registrar_cookie,
             &collection_cookie,
             &max_voter_weight_record_cookie,
-            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // Set Size == 1 to complete voting with just one vote
+            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // max_weight == 1 to complete voting with just one vote
         )
         .await?;
 
@@ -591,7 +588,7 @@ async fn test_relinquish_nft_vote_using_delegate() -> Result<(), TransportError>
             &registrar_cookie,
             &collection_cookie,
             &max_voter_weight_record_cookie,
-            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // Set Size == 1 to complete voting with just one vote
+            Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), // max_weight == 1 to complete voting with just one vote
         )
         .await?;
 

programs/core-attribute-voter/tests/update_max_voter_weight_record.rs

@@ -83,8 +83,7 @@ async fn test_update_collection_config_invalidates_max_voter_weight_record_expir
     let _clock = core_voter_test.bench.get_clock().await;
 
     // Assert
-    let max_voter_weight_total =
-        (collection_1_weight * collection_1_size) + (collection_2_weight * collection_2_size);
+    let max_voter_weight_total = collection_1_weight + collection_2_weight;
 
     assert!(registrar.collection_configs.len() == 2);
     assert!(max_voter_weight_record.max_voter_weight_expiry.is_none());
@@ -181,8 +180,7 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result<
         .await;
 
     // Assert
-    let max_voter_weight_total =
-        (collection_1_weight * collection_1_size) + (collection_2_weight * collection_2_size);
+    let max_voter_weight_total = collection_1_weight + collection_2_weight;
 
     assert!(registrar.collection_configs.len() == 2);
     assert!(max_voter_weight_record.max_voter_weight == max_voter_weight_total as u64);