From a31675d2ae80a69a505a2d9e78c2b108d52453fc Mon Sep 17 00:00:00 2001 From: crypt0miester Date: Wed, 4 Mar 2026 02:41:30 +0400 Subject: [PATCH 1/3] initial core-attribute-voter plugin --- Anchor.toml | 1 + Cargo.lock | 19 + Cargo.toml | 1 + programs/core-attribute-voter/Cargo.toml | 38 + programs/core-attribute-voter/README.md | 167 ++ programs/core-attribute-voter/Xargo.toml | 2 + programs/core-attribute-voter/src/error.rs | 103 ++ .../src/instructions/cast_nft_vote.rs | 162 ++ .../src/instructions/configure_collection.rs | 113 ++ .../create_max_voter_weight_record.rs | 57 + .../src/instructions/create_registrar.rs | 81 + .../create_voter_weight_record.rs | 63 + .../src/instructions/mod.rs | 23 + .../src/instructions/relinquish_nft_vote.rs | 157 ++ .../update_max_voter_weight_record.rs | 38 + .../update_voter_weight_record.rs | 97 ++ programs/core-attribute-voter/src/lib.rs | 73 + .../src/state/collection_config.rs | 54 + .../src/state/idl_types.rs | 17 + .../src/state/max_voter_weight_record.rs | 96 ++ .../core-attribute-voter/src/state/mod.rs | 15 + .../src/state/nft_vote_record.rs | 84 + .../src/state/registrar.rs | 219 +++ .../src/state/voter_weight_record.rs | 110 ++ .../core-attribute-voter/src/tools/anchor.rs | 1 + .../src/tools/governance.rs | 19 + .../core-attribute-voter/src/tools/mod.rs | 2 + .../tests/cast_nft_vote.rs | 1505 +++++++++++++++++ .../tests/configure_collection.rs | 544 ++++++ .../tests/create_max_voter_weight_record.rs | 127 ++ .../tests/create_registrar.rs | 156 ++ .../tests/create_voter_weight_record.rs | 127 ++ .../tests/fixtures/mpl_core.so | Bin 0 -> 848320 bytes .../tests/fixtures/spl_governance.so | Bin 0 -> 1319856 bytes .../tests/program_test/core_test.rs | 209 +++ .../tests/program_test/core_voter_test.rs | 697 ++++++++ .../tests/program_test/governance_test.rs | 435 +++++ .../tests/program_test/mod.rs | 5 + .../tests/program_test/program_test_bench.rs | 326 ++++ .../tests/program_test/tools.rs | 98 ++ .../tests/relinquish_nft_vote.rs | 670 ++++++++ .../tests/update_max_voter_weight_record.rs | 192 +++ .../tests/update_voter_weight_record.rs | 414 +++++ 43 files changed, 7317 insertions(+) create mode 100644 programs/core-attribute-voter/Cargo.toml create mode 100644 programs/core-attribute-voter/README.md create mode 100644 programs/core-attribute-voter/Xargo.toml create mode 100644 programs/core-attribute-voter/src/error.rs create mode 100644 programs/core-attribute-voter/src/instructions/cast_nft_vote.rs create mode 100644 programs/core-attribute-voter/src/instructions/configure_collection.rs create mode 100644 programs/core-attribute-voter/src/instructions/create_max_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/instructions/create_registrar.rs create mode 100644 programs/core-attribute-voter/src/instructions/create_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/instructions/mod.rs create mode 100644 programs/core-attribute-voter/src/instructions/relinquish_nft_vote.rs create mode 100644 programs/core-attribute-voter/src/instructions/update_max_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/instructions/update_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/lib.rs create mode 100644 programs/core-attribute-voter/src/state/collection_config.rs create mode 100644 programs/core-attribute-voter/src/state/idl_types.rs create mode 100644 programs/core-attribute-voter/src/state/max_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/state/mod.rs create mode 100644 programs/core-attribute-voter/src/state/nft_vote_record.rs create mode 100644 programs/core-attribute-voter/src/state/registrar.rs create mode 100644 programs/core-attribute-voter/src/state/voter_weight_record.rs create mode 100644 programs/core-attribute-voter/src/tools/anchor.rs create mode 100644 programs/core-attribute-voter/src/tools/governance.rs create mode 100644 programs/core-attribute-voter/src/tools/mod.rs create mode 100644 programs/core-attribute-voter/tests/cast_nft_vote.rs create mode 100644 programs/core-attribute-voter/tests/configure_collection.rs create mode 100644 programs/core-attribute-voter/tests/create_max_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/tests/create_registrar.rs create mode 100644 programs/core-attribute-voter/tests/create_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/tests/fixtures/mpl_core.so create mode 100755 programs/core-attribute-voter/tests/fixtures/spl_governance.so create mode 100644 programs/core-attribute-voter/tests/program_test/core_test.rs create mode 100644 programs/core-attribute-voter/tests/program_test/core_voter_test.rs create mode 100644 programs/core-attribute-voter/tests/program_test/governance_test.rs create mode 100644 programs/core-attribute-voter/tests/program_test/mod.rs create mode 100644 programs/core-attribute-voter/tests/program_test/program_test_bench.rs create mode 100644 programs/core-attribute-voter/tests/program_test/tools.rs create mode 100644 programs/core-attribute-voter/tests/relinquish_nft_vote.rs create mode 100644 programs/core-attribute-voter/tests/update_max_voter_weight_record.rs create mode 100644 programs/core-attribute-voter/tests/update_voter_weight_record.rs diff --git a/Anchor.toml b/Anchor.toml index e2ec4b1..389b790 100644 --- a/Anchor.toml +++ b/Anchor.toml @@ -7,6 +7,7 @@ seeds = false [programs.localnet] # gateway = "GgathUhdrCWRHowoRKACjgWhYHfxCEdBi5ViqYN6HVxk" // deprecated support due to original program being not upgraded to latest solana version core-voter = "cNFTHBQuERFVrbmks1UzqFQPBHzquRmoLbmgpHBbczF" +core-attribute-voter = "HmdGe7Sp7pcCr8bEmk4V35QTz5mWdDwV8pTRnWjDXaFA" nft_voter = "GnftV5kLjd67tvHpNGyodwWveEKivz3ZWvvE3Z4xi2iw" quadratic = "quadCSapU8nTdLg73KHDnmdxKnJQsh7GUbu5tZfnRRr" solana-gateway = "gatem74V238djXdzWnJf94Wo1DcnuGkfijbf3AuBhfs" diff --git a/Cargo.lock b/Cargo.lock index f3e83b2..d76799b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1891,6 +1891,25 @@ dependencies = [ "spinning_top", ] +[[package]] +name = "gpl-core-attribute-voter" +version = "0.1.0" +dependencies = [ + "anchor-lang", + "anchor-spl", + "arrayref", + "borsh 0.10.4", + "borsh 1.6.0", + "itertools 0.12.1", + "mpl-core", + "solana-program", + "solana-program-test", + "solana-sdk", + "spl-governance-mythic", + "spl-governance-tools-mythic", + "spl-token 6.0.0", +] + [[package]] name = "gpl-core-voter" version = "0.2.2" diff --git a/Cargo.toml b/Cargo.toml index 0c770f8..bd73440 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "programs/bonk-plugin", "programs/token-haver", "programs/core-voter", + "programs/core-attribute-voter", "programs/token-voter" ] diff --git a/programs/core-attribute-voter/Cargo.toml b/programs/core-attribute-voter/Cargo.toml new file mode 100644 index 0000000..9c185e5 --- /dev/null +++ b/programs/core-attribute-voter/Cargo.toml @@ -0,0 +1,38 @@ +[package] +name = "gpl-core-attribute-voter" +version = "0.1.0" +description = "SPL Governance addin implementing Metaplex Core NFT Asset attribute-based governance" +license = "Apache-2.0" +edition = "2018" + +[lib] +crate-type = ["cdylib", "lib"] +name = "gpl_core_attribute_voter" + +[features] +no-entrypoint = [] +no-idl = [] +no-log-ix-name = [] +cpi = ["no-entrypoint"] +default = [] +idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"] + +[dependencies] +arrayref = { workspace = true } +anchor-lang = { workspace = true, features = ["init-if-needed"] } +anchor-spl = { workspace = true, features = ["token"] } +itertools = { workspace = true } +mpl-core = { workspace = true, features = ["anchor"] } +spl-governance = { workspace = true, features = ["no-entrypoint"] } +spl-governance-tools = { workspace = true } +spl-token = { workspace = true, features = ["no-entrypoint"] } +borsh_1 = { workspace = true } + +[dev-dependencies] +borsh = { workspace = true } +solana-program = { workspace = true } +solana-sdk = { workspace = true } +solana-program-test = { workspace = true } + +[lints] +workspace = true diff --git a/programs/core-attribute-voter/README.md b/programs/core-attribute-voter/README.md new file mode 100644 index 0000000..186d216 --- /dev/null +++ b/programs/core-attribute-voter/README.md @@ -0,0 +1,167 @@ +# Core Attribute Voter + +An SPL Governance voter weight addin that enables attribute-based governance voting using [Metaplex Core](https://developers.metaplex.com/core) NFT assets. + +## Overview + +Core Attribute Voter allows DAOs to use NFT collections for governance voting where each NFT's voting power is determined dynamically from its on-chain attributes. Different NFTs within the same collection can carry different voting power based on traits, tiers, or any other attribute stored in the Metaplex Core Attributes plugin. + +## How It Works + +### Weight Calculation + +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 +- An **expected attribute authority** — the trusted authority that set the attributes + +When a voter submits their NFTs, the program: +1. Reads the Attributes plugin from the Metaplex Core asset +2. Verifies the plugin authority matches the expected authority +3. Finds the attribute matching the configured key +4. Parses the value as a `u64` +5. Caps it to `min(attribute_value, max_weight)` + +**Example:** A collection configured with `max_weight = 100` and `weight_attribute_key = "voting_power"`: +- NFT with `voting_power: "75"` → weight = 75 +- NFT with `voting_power: "150"` → weight = 100 (capped) +- Voter holding both → total weight = 175 + +### Max Voter Weight + +The maximum possible voting power across all configured collections: + +``` +max_voter_weight = Σ (collection.size × collection.max_weight) +``` + +This is used by SPL Governance to calculate quorum thresholds. + +## Architecture + +### Accounts + +| Account | Seeds | Purpose | +|---|---|---| +| **Registrar** | `["registrar", realm, governing_token_mint]` | Stores collection configs for a realm | +| **VoterWeightRecord** | `["voter-weight-record", realm, governing_token_mint, governing_token_owner]` | Per-voter weight used by SPL Governance | +| **MaxVoterWeightRecord** | `["max-voter-weight-record", realm, governing_token_mint]` | Maximum possible weight for quorum | +| **AssetVoteRecord** | `["nft-vote-record", proposal, asset_mint]` | Prevents same NFT from voting twice on a proposal | + +### Instructions + +| Instruction | Signer | Description | +|---|---|---| +| `create_registrar` | Realm authority | Creates the registrar for a realm, pre-allocates collection slots | +| `configure_collection` | Realm authority | Adds or updates an NFT collection config on the registrar | +| `create_max_voter_weight_record` | Payer | Creates the max voter weight record for a realm | +| `update_max_voter_weight_record` | Anyone | Refreshes max voter weight from current collection configs | +| `create_voter_weight_record` | Payer | Creates a voter's weight record | +| `update_voter_weight_record` | Voter | Updates weight for non-voting actions (CreateProposal, CreateGovernance, etc.) | +| `cast_nft_vote` | Voter | Casts a vote on a proposal using NFTs, creates AssetVoteRecords | +| `relinquish_nft_vote` | Voter | Cleans up AssetVoteRecords after voting ends, recovers rent | + +## Usage Flow + +### 1. Setup (Realm Authority) + +``` +create_registrar(max_collections: 3) + → Registrar PDA created + +create_max_voter_weight_record() + → MaxVoterWeightRecord PDA created + +configure_collection( + max_weight: 100, + weight_attribute_key: "voting_power", + expected_attribute_authority: UpdateAuthority +) + → Collection added to Registrar + → MaxVoterWeightRecord updated +``` + +### 2. Voter Registration + +``` +create_voter_weight_record(governing_token_owner) + → VoterWeightRecord PDA created (expired, weight = 0) +``` + +### 3. Non-Voting Actions (CreateProposal, CreateGovernance, etc.) + +``` +update_voter_weight_record(action: CreateProposal) + → Reads NFTs from remaining_accounts (up to 5 per tx) + → Calculates weight from attributes + → Sets expiry to current slot + +[same tx] spl_governance::create_proposal(...) + → Governance reads VoterWeightRecord +``` + +### 4. Casting Votes + +`cast_nft_vote` can be called multiple times per proposal to accumulate weight across transactions (useful when a voter holds more NFTs than fit in a single transaction). + +``` +cast_nft_vote() + → remaining_accounts: [nft1, vote_record1, nft2, vote_record2, ...] + → For each NFT: validate ownership, read weight, create AssetVoteRecord + → Accumulates weight in VoterWeightRecord + → Sets action = CastVote, target = proposal + +[final tx] spl_governance::cast_vote(...) + → Governance reads VoterWeightRecord + → Vote recorded +``` + +### 5. Relinquishing Votes + +After the proposal's voting period ends or the voter withdraws their vote: + +``` +relinquish_nft_vote() + → remaining_accounts: [asset_vote_record1, asset_vote_record2, ...] + → Disposes AssetVoteRecords, recovers rent + → Resets VoterWeightRecord weight to 0 +``` + +## Configuration + +### Collection Config Parameters + +| Parameter | Type | Constraints | Description | +|---|---|---|---| +| `max_weight` | `u64` | Any value | Per-NFT weight ceiling | +| `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 | + +### Limits + +| Limit | Value | Reason | +|---|---|---| +| Collections per registrar | Up to 255 (`u8`) | Set at registrar creation | +| Weight attribute key length | 1–32 chars | Enforced in `configure_collection` | +| NFTs per `update_voter_weight_record` | ~5 | Solana transaction size limit | +| NFTs per `cast_nft_vote` | Unlimited | Call multiple times to accumulate | + +## Security Considerations + +- **Attribute authority validation** — The program verifies that the Attributes plugin authority on each NFT matches the `expected_attribute_authority` configured for the collection. This prevents anyone from setting arbitrary weight attributes. +- **Double-vote prevention** — `AssetVoteRecord` PDAs (seeded by proposal + asset) ensure the same NFT cannot vote twice on the same proposal. +- **Expiry enforcement** — `VoterWeightRecord` expires at the slot it was set, so it can only be consumed in the same transaction. This prevents stale weights from being reused. +- **Checked arithmetic** — All weight calculations use checked math to prevent overflow panics. +- **Relinquish guards** — Votes can only be relinquished after the voting period ends or the spl-gov VoteRecord is withdrawn, and only when the VoterWeightRecord is expired (prevents front-running attacks with stacked voter-weight plugins). + +## Building + +```sh +anchor build -p gpl_core_attribute_voter +``` + +## Testing + +```sh +cargo test-sbf -p gpl-core-attribute-voter +``` diff --git a/programs/core-attribute-voter/Xargo.toml b/programs/core-attribute-voter/Xargo.toml new file mode 100644 index 0000000..475fb71 --- /dev/null +++ b/programs/core-attribute-voter/Xargo.toml @@ -0,0 +1,2 @@ +[target.bpfel-unknown-unknown.dependencies.std] +features = [] diff --git a/programs/core-attribute-voter/src/error.rs b/programs/core-attribute-voter/src/error.rs new file mode 100644 index 0000000..6f3303d --- /dev/null +++ b/programs/core-attribute-voter/src/error.rs @@ -0,0 +1,103 @@ +use anchor_lang::prelude::*; + +#[error_code] +pub enum CoreNftAttributeVoterError { + // 0 + #[msg("Invalid Realm Authority")] + InvalidRealmAuthority, + + #[msg("Invalid Realm for Registrar")] + InvalidRealmForRegistrar, + + #[msg("Invalid Collection Size")] + InvalidCollectionSize, + + #[msg("Invalid MaxVoterWeightRecord Realm")] + InvalidMaxVoterWeightRecordRealm, + + #[msg("Invalid MaxVoterWeightRecord Mint")] + InvalidMaxVoterWeightRecordMint, + + #[msg("CastVote Is Not Allowed")] + CastVoteIsNotAllowed, + + #[msg("Invalid VoterWeightRecord Realm")] + InvalidVoterWeightRecordRealm, + + #[msg("Invalid VoterWeightRecord Mint")] + InvalidVoterWeightRecordMint, + + #[msg("Invalid TokenOwner for VoterWeightRecord")] + InvalidTokenOwnerForVoterWeightRecord, + + #[msg("Collection must be verified")] + CollectionMustBeVerified, + + //10 + #[msg("Voter does not own NFT")] + VoterDoesNotOwnNft, + + #[msg("Collection not found")] + CollectionNotFound, + + #[msg("Missing Metadata collection")] + MissingMetadataCollection, + + #[msg("Token Metadata doesn't match")] + TokenMetadataDoesNotMatch, + + #[msg("Invalid account owner")] + InvalidAccountOwner, + + #[msg("Invalid token metadata account")] + InvalidTokenMetadataAccount, + + #[msg("Duplicated NFT detected")] + DuplicatedNftDetected, + + #[msg("Invalid NFT amount")] + InvalidNftAmount, + + #[msg("NFT already voted")] + NftAlreadyVoted, + + #[msg("Invalid Proposal for NftVoteRecord")] + InvalidProposalForNftVoteRecord, + + // 20 + #[msg("Invalid TokenOwner for NftVoteRecord")] + InvalidTokenOwnerForNftVoteRecord, + + #[msg("VoteRecord must be withdrawn")] + VoteRecordMustBeWithdrawn, + + #[msg("Invalid VoteRecord for NftVoteRecord")] + InvalidVoteRecordForNftVoteRecord, + + #[msg("VoterWeightRecord must be expired")] + VoterWeightRecordMustBeExpired, + + #[msg("Invalid NFT collection")] + InvalidNftCollection, + + #[msg("Proposal is not in voting state")] + InvalidProposalState, + + #[msg("Attribute not found on asset")] + AttributeNotFound, + + #[msg("Invalid attribute value, must be a valid u64")] + InvalidAttributeValue, + + #[msg("Invalid weight attribute key")] + InvalidWeightAttributeKey, + + #[msg("Attribute plugin authority mismatch")] + AttributeAuthorityMismatch, + + #[msg("Arithmetic overflow")] + ArithmeticOverflow, + + #[msg("Failed to borrow VoteRecord data")] + VoteRecordBorrowFailed, +} diff --git a/programs/core-attribute-voter/src/instructions/cast_nft_vote.rs b/programs/core-attribute-voter/src/instructions/cast_nft_vote.rs new file mode 100644 index 0000000..3fe69e1 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/cast_nft_vote.rs @@ -0,0 +1,162 @@ +use crate::error::CoreNftAttributeVoterError; +use crate::{id, state::*}; +use anchor_lang::prelude::*; +use anchor_lang::Accounts; +use itertools::Itertools; +use mpl_core::accounts::BaseAssetV1; +use spl_governance_tools::account::create_and_serialize_account_signed; + +/// Casts NFT vote. The NFTs used for voting are tracked using NftVoteRecord accounts +/// This instruction updates VoterWeightRecord which is valid for the current Slot and the target Proposal only +/// and hance the instruction has to be executed inside the same transaction as spl-gov.CastVote +/// +/// CastNftVote is accumulative and can be invoked using several transactions if voter owns more than 5 NFTs to calculate total voter_weight +/// In this scenario only the last CastNftVote should be bundled with spl-gov.CastVote in the same transaction +/// +/// CastNftVote instruction and NftVoteRecord are not directional. They don't record vote choice (ex Yes/No) +/// VoteChoice is recorded by spl-gov in VoteRecord and this CastNftVote only tracks voting NFTs +/// +#[derive(Accounts)] +pub struct CastNftVote<'info> { + /// The NFT voting registrar + pub registrar: Account<'info, Registrar>, + + #[account( + mut, + constraint = voter_weight_record.realm == registrar.realm + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordRealm, + + constraint = voter_weight_record.governing_token_mint == registrar.governing_token_mint + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordMint, + )] + pub voter_weight_record: Account<'info, VoterWeightRecord>, + + /// TokenOwnerRecord of the voter who casts the vote + #[account( + owner = registrar.governance_program_id + )] + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + voter_token_owner_record: UncheckedAccount<'info>, + + /// Authority of the voter who casts the vote + /// It can be either governing_token_owner or its delegate and must sign this instruction + pub voter_authority: Signer<'info>, + + /// CHECK: The account is validated in the instruction + #[account( + owner = registrar.governance_program_id + )] + proposal: UncheckedAccount<'info>, + + /// The account which pays for the transaction + #[account(mut)] + pub payer: Signer<'info>, + + pub system_program: Program<'info, System>, +} + +/// Casts vote with the NFT +pub fn cast_nft_vote<'a, 'b, 'c, 'info>( + ctx: Context<'a, 'b, 'c, 'info, CastNftVote<'info>> +) -> Result<()> { + let registrar = &ctx.accounts.registrar; + let proposal = &ctx.accounts.proposal; + let voter_weight_record = &mut ctx.accounts.voter_weight_record; + + let governing_token_owner = resolve_governing_token_owner( + registrar, + &ctx.accounts.voter_token_owner_record, + &ctx.accounts.voter_authority, + voter_weight_record, + )?; + + let proposal_key = resolve_proposal_account( + registrar, + proposal, + )?; + + let mut voter_weight = 0u64; + + // Ensure all voting nfts in the batch are unique + let mut unique_asset_mints = vec![]; + + let rent = Rent::get()?; + + for (asset, asset_vote_record_info) in + ctx.remaining_accounts.iter().tuples() + { + if asset.owner != &mpl_core::ID { + return Err(CoreNftAttributeVoterError::InvalidAccountOwner.into()); + } + + let (asset_vote_weight, asset_mint) = resolve_nft_vote_weight_and_mint( + registrar, + &governing_token_owner, + *asset.key, + &BaseAssetV1::from_bytes(&asset.data.borrow()) + .map_err(|_| CoreNftAttributeVoterError::InvalidAccountOwner)?, + asset, + &mut unique_asset_mints, + )?; + + voter_weight = voter_weight.checked_add(asset_vote_weight) + .ok_or(CoreNftAttributeVoterError::InvalidNftAmount)?; + + // Create NFT vote record to ensure the same NFT hasn't been already used for voting + // Note: The correct PDA of the NftVoteRecord is validated in create_and_serialize_account_signed + // It ensures the NftVoteRecord is for ('nft-vote-record',proposal,nft_mint) seeds + require!( + asset_vote_record_info.data_is_empty(), + CoreNftAttributeVoterError::NftAlreadyVoted + ); + + // Note: proposal.governing_token_mint must match voter_weight_record.governing_token_mint + // We don't verify it here because spl-gov does the check in cast_vote + // and it would reject voter_weight_record if governing_token_mint doesn't match + + // Note: Once the NFT plugin is enabled the governing_token_mint is used only as identity + // for the voting population and the tokens of that mint are no longer used + let asset_vote_record = AssetVoteRecord { + account_discriminator: AssetVoteRecord::ACCOUNT_DISCRIMINATOR, + proposal: proposal_key, + asset_mint, + governing_token_owner, + reserved: [0; 8], + }; + + // Anchor doesn't natively support dynamic account creation using remaining_accounts + // and we have to take it on the manual drive + create_and_serialize_account_signed( + &ctx.accounts.payer.to_account_info(), + asset_vote_record_info, + &asset_vote_record, + &get_nft_vote_record_seeds(&proposal_key, &asset_mint), + &id(), + &ctx.accounts.system_program.to_account_info(), + &rent, + 0, + )?; + } + + if voter_weight_record.weight_action_target == Some(proposal_key) + && voter_weight_record.weight_action == Some(VoterWeightAction::CastVote) + { + // If cast_nft_vote is called for the same proposal then we keep accumulating the weight + // this way cast_nft_vote can be called multiple times in different transactions to allow voting with any number of NFTs + voter_weight_record.voter_weight = voter_weight_record + .voter_weight + .checked_add(voter_weight) + .ok_or(CoreNftAttributeVoterError::InvalidNftAmount)?; + } else { + voter_weight_record.voter_weight = voter_weight; + } + + // The record is only valid as of the current slot + voter_weight_record.voter_weight_expiry = Some(Clock::get()?.slot); + + // The record is only valid for casting vote on the given Proposal + voter_weight_record.weight_action = Some(VoterWeightAction::CastVote); + voter_weight_record.weight_action_target = Some(proposal_key); + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/configure_collection.rs b/programs/core-attribute-voter/src/instructions/configure_collection.rs new file mode 100644 index 0000000..5017010 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/configure_collection.rs @@ -0,0 +1,113 @@ +use anchor_lang::{ + account, + prelude::{Context, Signer}, + Accounts, +}; + +use anchor_lang::prelude::*; +use mpl_core::accounts::BaseCollectionV1; +use mpl_core::types::PluginAuthority; +use spl_governance::state::realm; + +use crate::error::CoreNftAttributeVoterError; +use crate::state::{max_voter_weight_record::MaxVoterWeightRecord, CollectionConfig, Registrar}; + +/// Configures NFT voting collection which defines what NFTs can be used for governances +/// and what weight they have (read from per-NFT attributes) +/// The instruction updates MaxVoterWeightRecord which is used by spl-gov to determine max voting power +/// used to calculate voting quorum +#[derive(Accounts)] +pub struct ConfigureCollection<'info> { + /// Registrar for which we configure this Collection + #[account(mut)] + pub registrar: Account<'info, Registrar>, + + #[account( + address = registrar.realm @ CoreNftAttributeVoterError::InvalidRealmForRegistrar, + owner = registrar.governance_program_id + )] + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + pub realm: UncheckedAccount<'info>, + + /// Authority of the Realm must sign and match Realm.authority + pub realm_authority: Signer<'info>, + + // Collection which is going to be used for voting + pub collection: Account<'info, BaseCollectionV1>, + + #[account( + mut, + constraint = max_voter_weight_record.realm == registrar.realm + @ CoreNftAttributeVoterError::InvalidMaxVoterWeightRecordRealm, + + constraint = max_voter_weight_record.governing_token_mint == registrar.governing_token_mint + @ CoreNftAttributeVoterError::InvalidMaxVoterWeightRecordMint, + )] + pub max_voter_weight_record: Account<'info, MaxVoterWeightRecord>, +} + +pub fn configure_collection( + ctx: Context, + max_weight: u64, + weight_attribute_key: String, + expected_attribute_authority: PluginAuthority, +) -> Result<()> { + let registrar = &mut ctx.accounts.registrar; + + let realm = realm::get_realm_data_for_governing_token_mint( + ®istrar.governance_program_id, + &ctx.accounts.realm, + ®istrar.governing_token_mint, + )?; + + require!( + realm.authority == Some(ctx.accounts.realm_authority.key()), + CoreNftAttributeVoterError::InvalidRealmAuthority + ); + + // 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(), + 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()); + + if let Some(collection_idx) = collection_idx { + registrar.collection_configs[collection_idx] = collection_config; + } else { + // Note: In the current runtime version push() would throw an error if we exceed + // max_collections specified when the Registrar was created + registrar.collection_configs.push(collection_config); + } + + // Update MaxVoterWeightRecord based on max voting power of the collections + let max_voter_weight_record = &mut ctx.accounts.max_voter_weight_record; + + max_voter_weight_record.max_voter_weight = registrar.max_voter_weight()?; + + // The weight never expires and only changes when collections are configured + max_voter_weight_record.max_voter_weight_expiry = None; + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/create_max_voter_weight_record.rs b/programs/core-attribute-voter/src/instructions/create_max_voter_weight_record.rs new file mode 100644 index 0000000..0749fd4 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/create_max_voter_weight_record.rs @@ -0,0 +1,57 @@ +use anchor_lang::prelude::*; +use anchor_spl::token::Mint; +use spl_governance::state::realm; + +use crate::state::max_voter_weight_record::MaxVoterWeightRecord; + +/// Creates MaxVoterWeightRecord used by spl-gov +/// This instruction should only be executed once per realm/governing_token_mint to create the account +#[derive(Accounts)] +pub struct CreateMaxVoterWeightRecord<'info> { + #[account( + init, + seeds = [ b"max-voter-weight-record".as_ref(), + realm.key().as_ref(), + realm_governing_token_mint.key().as_ref()], + bump, + payer = payer, + space = MaxVoterWeightRecord::get_space() + )] + pub max_voter_weight_record: Account<'info, MaxVoterWeightRecord>, + + /// The program id of the spl-governance program the realm belongs to + /// CHECK: Can be any instance of spl-governance and it's not known at the compilation time + #[account(executable)] + pub governance_program_id: UncheckedAccount<'info>, + + #[account(owner = governance_program_id.key())] + /// CHECK: Owned by spl-governance instance specified in governance_program_id + pub realm: UncheckedAccount<'info>, + + /// Either the realm community mint or the council mint. + pub realm_governing_token_mint: Account<'info, Mint>, + + #[account(mut)] + pub payer: Signer<'info>, + + pub system_program: Program<'info, System>, +} + +pub fn create_max_voter_weight_record(ctx: Context) -> Result<()> { + // Deserialize the Realm to validate it + let _realm = realm::get_realm_data_for_governing_token_mint( + &ctx.accounts.governance_program_id.key(), + &ctx.accounts.realm, + &ctx.accounts.realm_governing_token_mint.key(), + )?; + + let max_voter_weight_record = &mut ctx.accounts.max_voter_weight_record; + + max_voter_weight_record.realm = ctx.accounts.realm.key(); + max_voter_weight_record.governing_token_mint = ctx.accounts.realm_governing_token_mint.key(); + + // Set expiry to expired + max_voter_weight_record.max_voter_weight_expiry = Some(0); + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/create_registrar.rs b/programs/core-attribute-voter/src/instructions/create_registrar.rs new file mode 100644 index 0000000..dd963d8 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/create_registrar.rs @@ -0,0 +1,81 @@ +use crate::error::CoreNftAttributeVoterError; +use crate::state::*; +use anchor_lang::prelude::*; +use anchor_spl::token::Mint; +use spl_governance::state::realm; + +/// Creates Registrar storing NFT governance configuration for spl-gov Realm +/// This instruction should only be executed once per realm/governing_token_mint to create the account +#[derive(Accounts)] +#[instruction(max_collections: u8)] +pub struct CreateRegistrar<'info> { + /// The NFT voting Registrar + /// There can only be a single registrar per governance Realm and governing mint of the Realm + #[account( + init, + seeds = [b"registrar".as_ref(),realm.key().as_ref(), governing_token_mint.key().as_ref()], + bump, + payer = payer, + space = Registrar::get_space(max_collections) + )] + pub registrar: Account<'info, Registrar>, + + /// The program id of the spl-governance program the realm belongs to + /// CHECK: Can be any instance of spl-governance and it's not known at the compilation time + #[account(executable)] + pub governance_program_id: UncheckedAccount<'info>, + + /// An spl-governance Realm + /// + /// Realm is validated in the instruction: + /// - Realm is owned by the governance_program_id + /// - governing_token_mint must be the community or council mint + /// - realm_authority is realm.authority + /// CHECK: Owned by spl-governance instance specified in governance_program_id + #[account(owner = governance_program_id.key())] + pub realm: UncheckedAccount<'info>, + + /// Either the realm community mint or the council mint. + /// It must match Realm.community_mint or Realm.config.council_mint + /// + /// Note: Once the NFT plugin is enabled the governing_token_mint is used only as identity + /// for the voting population and the tokens of that are no longer used + pub governing_token_mint: Account<'info, Mint>, + + /// realm_authority must sign and match Realm.authority + pub realm_authority: Signer<'info>, + + #[account(mut)] + pub payer: Signer<'info>, + + pub system_program: Program<'info, System>, +} + +/// Creates a new Registrar which stores NFT voting configuration for given Realm +/// +/// To use the registrar, call ConfigureCollection to register NFT collections that may be +/// used for governance +/// +/// max_collections is used allocate account size for the maximum number of governing NFT collections +/// Note: Once Solana runtime supports account resizing the max value won't be required +pub fn create_registrar(ctx: Context, _max_collections: u8) -> Result<()> { + let registrar = &mut ctx.accounts.registrar; + registrar.governance_program_id = ctx.accounts.governance_program_id.key(); + registrar.realm = ctx.accounts.realm.key(); + registrar.governing_token_mint = ctx.accounts.governing_token_mint.key(); + + // Verify that realm_authority is the expected authority of the Realm + // and that the mint matches one of the realm mints too + let realm = realm::get_realm_data_for_governing_token_mint( + ®istrar.governance_program_id, + &ctx.accounts.realm, + ®istrar.governing_token_mint, + )?; + + require!( + realm.authority == Some(ctx.accounts.realm_authority.key()), + CoreNftAttributeVoterError::InvalidRealmAuthority + ); + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/create_voter_weight_record.rs b/programs/core-attribute-voter/src/instructions/create_voter_weight_record.rs new file mode 100644 index 0000000..d1ef66d --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/create_voter_weight_record.rs @@ -0,0 +1,63 @@ +use crate::state::*; +use anchor_lang::prelude::*; +use anchor_spl::token::Mint; +use spl_governance::state::realm; + +/// Creates VoterWeightRecord used by spl-gov +/// This instruction should only be executed once per realm/governing_token_mint/governing_token_owner +/// to create the account +#[derive(Accounts)] +#[instruction(governing_token_owner: Pubkey)] +pub struct CreateVoterWeightRecord<'info> { + #[account( + init, + seeds = [ b"voter-weight-record".as_ref(), + realm.key().as_ref(), + realm_governing_token_mint.key().as_ref(), + governing_token_owner.as_ref()], + bump, + payer = payer, + space = VoterWeightRecord::get_space() + )] + pub voter_weight_record: Account<'info, VoterWeightRecord>, + + /// The program id of the spl-governance program the realm belongs to + /// CHECK: Can be any instance of spl-governance and it's not known at the compilation time + #[account(executable)] + pub governance_program_id: UncheckedAccount<'info>, + + /// CHECK: Owned by spl-governance instance specified in governance_program_id + #[account(owner = governance_program_id.key())] + pub realm: UncheckedAccount<'info>, + + /// Either the realm community mint or the council mint. + pub realm_governing_token_mint: Account<'info, Mint>, + + #[account(mut)] + pub payer: Signer<'info>, + + pub system_program: Program<'info, System>, +} + +pub fn create_voter_weight_record( + ctx: Context, + governing_token_owner: Pubkey, +) -> Result<()> { + // Deserialize the Realm to validate it + let _realm = realm::get_realm_data_for_governing_token_mint( + &ctx.accounts.governance_program_id.key(), + &ctx.accounts.realm, + &ctx.accounts.realm_governing_token_mint.key(), + )?; + + let voter_weight_record = &mut ctx.accounts.voter_weight_record; + + voter_weight_record.realm = ctx.accounts.realm.key(); + voter_weight_record.governing_token_mint = ctx.accounts.realm_governing_token_mint.key(); + voter_weight_record.governing_token_owner = governing_token_owner; + + // Set expiry to expired + voter_weight_record.voter_weight_expiry = Some(0); + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/mod.rs b/programs/core-attribute-voter/src/instructions/mod.rs new file mode 100644 index 0000000..e792652 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/mod.rs @@ -0,0 +1,23 @@ +pub use configure_collection::*; +mod configure_collection; + +pub use create_registrar::*; +mod create_registrar; + +pub use create_voter_weight_record::*; +mod create_voter_weight_record; + +pub use create_max_voter_weight_record::*; +mod create_max_voter_weight_record; + +pub use update_voter_weight_record::*; +mod update_voter_weight_record; + +pub use relinquish_nft_vote::*; +mod relinquish_nft_vote; + +pub use cast_nft_vote::*; +mod cast_nft_vote; + +pub use update_max_voter_weight_record::*; +mod update_max_voter_weight_record; diff --git a/programs/core-attribute-voter/src/instructions/relinquish_nft_vote.rs b/programs/core-attribute-voter/src/instructions/relinquish_nft_vote.rs new file mode 100644 index 0000000..d010d22 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/relinquish_nft_vote.rs @@ -0,0 +1,157 @@ +use crate::error::CoreNftAttributeVoterError; +use crate::state::*; +use crate::state::{get_nft_vote_record_data_for_proposal_and_token_owner, Registrar}; +use crate::tools::governance::get_vote_record_address; +use anchor_lang::prelude::*; +use spl_governance::state::{enums::ProposalState, governance, proposal}; +use spl_governance_tools::account::dispose_account; + +/// Disposes NftVoteRecord and recovers the rent from the accounts +/// It can only be executed when voting on the target Proposal ended or voter withdrew vote from the Proposal +/// +/// Note: If a voter votes with NFT and transfers the token then in the current version of the program the new owner can't withdraw the vote +/// In order to support that scenario a change in spl-governance is needed +/// It would have to support revoke_vote instruction which would take as input VoteWeightRecord with the following values: +/// weight_action: RevokeVote, weight_action_target: VoteRecord, voter_weight: sum(previous owner NFT weight) +/// The instruction would decrease the previous voter total VoteRecord.voter_weight by the provided VoteWeightRecord.voter_weight +/// Once the spl-governance instruction is supported then nft-voter plugin should implement revoke_nft_vote instruction +/// to supply the required VoteWeightRecord and delete relevant NftVoteRecords +#[derive(Accounts)] +pub struct RelinquishNftVote<'info> { + /// The NFT voting Registrar + pub registrar: Account<'info, Registrar>, + + #[account( + mut, + constraint = voter_weight_record.realm == registrar.realm + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordRealm, + + constraint = voter_weight_record.governing_token_mint == registrar.governing_token_mint + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordMint, + )] + pub voter_weight_record: Account<'info, VoterWeightRecord>, + + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + /// Governance account the Proposal is for + #[account(owner = registrar.governance_program_id)] + pub governance: UncheckedAccount<'info>, + + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + #[account(owner = registrar.governance_program_id)] + pub proposal: UncheckedAccount<'info>, + + /// TokenOwnerRecord of the voter who cast the original vote + #[account( + owner = registrar.governance_program_id + )] + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + voter_token_owner_record: UncheckedAccount<'info>, + + /// Authority of the voter who cast the original vote + /// It can be either governing_token_owner or its delegate and must sign this instruction + pub voter_authority: Signer<'info>, + + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + /// The account is used to validate that it doesn't exist and if it doesn't then Anchor owner check throws error + /// The check is disabled here and performed inside the instruction + /// #[account(owner = registrar.governance_program_id)] + pub vote_record: UncheckedAccount<'info>, + + /// CHECK: The beneficiary who receives lamports from the disposed NftVoterRecord accounts can be any account + #[account(mut)] + pub beneficiary: UncheckedAccount<'info>, +} + +pub fn relinquish_nft_vote(ctx: Context) -> Result<()> { + let registrar = &ctx.accounts.registrar; + let voter_weight_record = &mut ctx.accounts.voter_weight_record; + + let governing_token_owner = resolve_governing_token_owner( + registrar, + &ctx.accounts.voter_token_owner_record, + &ctx.accounts.voter_authority, + voter_weight_record, + )?; + + // Ensure the Governance belongs to Registrar.realm and is owned by Registrar.governance_program_id + let _governance = governance::get_governance_data_for_realm( + ®istrar.governance_program_id, + &ctx.accounts.governance, + ®istrar.realm, + )?; + + // Ensure the Proposal belongs to Governance from Registrar.realm and Registrar.governing_token_mint and is owned by Registrar.governance_program_id + let proposal = proposal::get_proposal_data_for_governance_and_governing_mint( + ®istrar.governance_program_id, + &ctx.accounts.proposal, + &ctx.accounts.governance.key(), + ®istrar.governing_token_mint, + )?; + + // If the Proposal is still in Voting state then we can only Relinquish the NFT votes if the Vote was withdrawn in spl-gov first + // When vote is withdrawn in spl-gov then VoteRecord is disposed and we have to assert it doesn't exist + // + // If the Proposal is in any other state then we can dispose NftVoteRecords without any additional Proposal checks + + msg!("Proposal State: {:?}", proposal.state); + + if proposal.state == ProposalState::Voting { + let vote_record_info = &ctx.accounts.vote_record.to_account_info(); + + // Ensure the given VoteRecord address matches the expected PDA + let vote_record_key = get_vote_record_address( + ®istrar.governance_program_id, + ®istrar.realm, + ®istrar.governing_token_mint, + &governing_token_owner, + &ctx.accounts.proposal.key(), + ); + + require!( + vote_record_key == vote_record_info.key(), + CoreNftAttributeVoterError::InvalidVoteRecordForNftVoteRecord + ); + + // VoteRecord doesn't exist if data is empty or account_type is 0 when the account was disposed in the same Tx + if !vote_record_info.data_is_empty() { + let data = vote_record_info + .try_borrow_data() + .map_err(|_| CoreNftAttributeVoterError::VoteRecordBorrowFailed)?; + require!( + data[0] == 0, + CoreNftAttributeVoterError::VoteRecordMustBeWithdrawn + ); + } + } + + // Prevent relinquishing NftVoteRecords within the VoterWeightRecord expiration period + // It's needed when multiple stacked voter-weight plugins are used + // Without the assertion the following vector of attack exists + // 1) nft-voter.cast_nft_vote() + // 2) voter-weight-plugin.cast_vote() + // 3) nft-voter.relinquish_nft_vote() + // 4) spl-gov.cast_vote() -> spl-gov uses VoterWeightRecord provided by voter-weight-plugin in step 2) while the nft vote is withdrawn and could be used to vote again + if voter_weight_record.voter_weight_expiry >= Some(Clock::get()?.slot) { + return err!(CoreNftAttributeVoterError::VoterWeightRecordMustBeExpired); + } + + // Dispose all NftVoteRecords + for nft_vote_record_info in ctx.remaining_accounts.iter() { + // Ensure NftVoteRecord is for the given Proposal and TokenOwner + let _nft_vote_record = get_nft_vote_record_data_for_proposal_and_token_owner( + nft_vote_record_info, + &ctx.accounts.proposal.key(), + &governing_token_owner, + )?; + + dispose_account(nft_vote_record_info, &ctx.accounts.beneficiary)?; + } + + // Reset VoterWeightRecord and set expiry to expired to prevent it from being used + voter_weight_record.voter_weight = 0; + voter_weight_record.voter_weight_expiry = Some(0); + + voter_weight_record.weight_action_target = None; + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/update_max_voter_weight_record.rs b/programs/core-attribute-voter/src/instructions/update_max_voter_weight_record.rs new file mode 100644 index 0000000..e8052d1 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/update_max_voter_weight_record.rs @@ -0,0 +1,38 @@ +use crate::error::CoreNftAttributeVoterError; +use crate::state::*; +use anchor_lang::prelude::*; +use max_voter_weight_record::MaxVoterWeightRecord; + +// Takes all collections added to `register`, iterates over them and calculates +// the max voter weight +#[derive(Accounts)] +pub struct UpdateMaxVoterWeightRecord<'info> { + /// The NFT voting Registrar + pub registrar: Account<'info, Registrar>, + + #[account( + mut, + constraint = max_voter_weight_record.realm == registrar.realm + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordRealm, + + constraint = max_voter_weight_record.governing_token_mint == registrar.governing_token_mint + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordMint, + )] + pub max_voter_weight_record: Account<'info, MaxVoterWeightRecord>, +} + +pub fn update_max_voter_weight_record(ctx: Context) -> Result<()> { + let registrar = &ctx.accounts.registrar; + + // Calculate the max voter weight by iterating over all collections and summing + // the max weight of each collection. + ctx.accounts.max_voter_weight_record.max_voter_weight = registrar.max_voter_weight()?; + + // Record is only valid as of the current slot + let slot = Clock::get()?.slot; + msg!("Clock: {:?}", slot); + + ctx.accounts.max_voter_weight_record.max_voter_weight_expiry = Some(slot); + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/instructions/update_voter_weight_record.rs b/programs/core-attribute-voter/src/instructions/update_voter_weight_record.rs new file mode 100644 index 0000000..7e2a929 --- /dev/null +++ b/programs/core-attribute-voter/src/instructions/update_voter_weight_record.rs @@ -0,0 +1,97 @@ +use crate::error::CoreNftAttributeVoterError; +use crate::state::*; +use anchor_lang::prelude::*; +use mpl_core::accounts::BaseAssetV1; + +/// Updates VoterWeightRecord to evaluate governance power for non voting use cases: CreateProposal, CreateGovernance etc... +/// This instruction updates VoterWeightRecord which is valid for the current Slot and the given target action only +/// and hance the instruction has to be executed inside the same transaction as the corresponding spl-gov instruction +/// +/// Note: UpdateVoterWeight is not cumulative the same way as CastNftVote and hence voter_weight for non voting scenarios +/// can only be used with max 5 NFTs due to Solana transaction size limit +/// It could be supported in future version by introducing bookkeeping accounts to track the NFTs +/// which were already used to calculate the total weight +#[derive(Accounts)] +#[instruction(voter_weight_action:VoterWeightAction)] +pub struct UpdateVoterWeightRecord<'info> { + /// The NFT voting Registrar + pub registrar: Account<'info, Registrar>, + + #[account( + mut, + constraint = voter_weight_record.realm == registrar.realm + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordRealm, + + constraint = voter_weight_record.governing_token_mint == registrar.governing_token_mint + @ CoreNftAttributeVoterError::InvalidVoterWeightRecordMint, + )] + pub voter_weight_record: Account<'info, VoterWeightRecord>, + + #[account( + owner = registrar.governance_program_id + )] + /// CHECK: Owned by spl-governance instance specified in registrar.governance_program_id + voter_token_owner_record: UncheckedAccount<'info>, + + pub voter_authority: Signer<'info>, +} + +pub fn update_voter_weight_record( + ctx: Context, + voter_weight_action: VoterWeightAction, +) -> Result<()> { + let registrar = &ctx.accounts.registrar; + + let governing_token_owner = resolve_governing_token_owner( + registrar, + &ctx.accounts.voter_token_owner_record, + &ctx.accounts.voter_authority, + &ctx.accounts.voter_weight_record + )?; + + match voter_weight_action { + // voter_weight for CastVote action can't be evaluated using this instruction + VoterWeightAction::CastVote => return err!(CoreNftAttributeVoterError::CastVoteIsNotAllowed), + VoterWeightAction::CommentProposal + | VoterWeightAction::CreateGovernance + | VoterWeightAction::CreateProposal + | VoterWeightAction::SignOffProposal => {} + } + + let mut voter_weight = 0u64; + + // Ensure all nfts are unique + let mut unique_nft_mints = vec![]; + + for asset in ctx.remaining_accounts.iter() { + if asset.owner != &mpl_core::ID { + return Err(CoreNftAttributeVoterError::InvalidAccountOwner.into()); + } + + let (nft_vote_weight, _) = resolve_nft_vote_weight_and_mint( + registrar, + &governing_token_owner, + *asset.key, + &BaseAssetV1::from_bytes(&asset.data.borrow()) + .map_err(|_| CoreNftAttributeVoterError::InvalidAccountOwner)?, + asset, + &mut unique_nft_mints, + )?; + + voter_weight = voter_weight.checked_add(nft_vote_weight) + .ok_or(CoreNftAttributeVoterError::InvalidNftAmount)?; + } + + let voter_weight_record = &mut ctx.accounts.voter_weight_record; + + voter_weight_record.voter_weight = voter_weight; + + // Record is only valid as of the current slot + voter_weight_record.voter_weight_expiry = Some(Clock::get()?.slot); + + // Set the action to make it specific and prevent being used for voting + voter_weight_record.weight_action = Some(voter_weight_action); + voter_weight_record.weight_action_target = None; + + Ok(()) +} diff --git a/programs/core-attribute-voter/src/lib.rs b/programs/core-attribute-voter/src/lib.rs new file mode 100644 index 0000000..fff51d7 --- /dev/null +++ b/programs/core-attribute-voter/src/lib.rs @@ -0,0 +1,73 @@ +use anchor_lang::prelude::*; + +pub mod error; + +mod instructions; +use instructions::*; + +pub mod state; + +pub mod tools; + +use crate::state::*; + +declare_id!("HmdGe7Sp7pcCr8bEmk4V35QTz5mWdDwV8pTRnWjDXaFA"); + +#[program] +pub mod core_attribute_voter { + + use crate::state::VoterWeightAction; + + use super::*; + pub fn create_registrar(ctx: Context, max_collections: u8) -> Result<()> { + log_version(); + instructions::create_registrar(ctx, max_collections) + } + pub fn create_voter_weight_record( + ctx: Context, + governing_token_owner: Pubkey, + ) -> Result<()> { + log_version(); + instructions::create_voter_weight_record(ctx, governing_token_owner) + } + pub fn create_max_voter_weight_record(ctx: Context) -> Result<()> { + log_version(); + instructions::create_max_voter_weight_record(ctx) + } + pub fn update_voter_weight_record( + ctx: Context, + voter_weight_action: VoterWeightAction, + ) -> Result<()> { + log_version(); + instructions::update_voter_weight_record(ctx, voter_weight_action) + } + pub fn update_max_voter_weight_record(ctx: Context) -> Result<()> { + log_version(); + instructions::update_max_voter_weight_record(ctx) + } + pub fn relinquish_nft_vote(ctx: Context) -> Result<()> { + log_version(); + instructions::relinquish_nft_vote(ctx) + } + pub fn configure_collection( + ctx: Context, + max_weight: u64, + weight_attribute_key: String, + expected_attribute_authority: mpl_core::types::PluginAuthority, + ) -> Result<()> { + log_version(); + instructions::configure_collection(ctx, max_weight, weight_attribute_key, expected_attribute_authority) + } + + pub fn cast_nft_vote<'a, 'b, 'c, 'info>( + ctx: Context<'a, 'b, 'c, 'info, CastNftVote<'info>>, + ) -> Result<()> { + log_version(); + instructions::cast_nft_vote(ctx) + } +} + +fn log_version() { + // TODO: Check if Anchor allows to log it before instruction is deserialized + msg!("VERSION:{:?}", env!("CARGO_PKG_VERSION")); +} diff --git a/programs/core-attribute-voter/src/state/collection_config.rs b/programs/core-attribute-voter/src/state/collection_config.rs new file mode 100644 index 0000000..a24e0f0 --- /dev/null +++ b/programs/core-attribute-voter/src/state/collection_config.rs @@ -0,0 +1,54 @@ +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 + pub max_weight: u64, + + /// The attribute key to read the voting weight from on each NFT + /// The attribute value must be a valid u64 string + pub weight_attribute_key: String, + + /// The expected plugin authority for the Attributes plugin on each NFT. + /// Only attributes set by this authority are trusted for vote weight. + pub expected_attribute_authority: PluginAuthority, + + /// Reserved for future upgrades + pub reserved: [u8; 8], +} + +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; + + pub fn get_max_weight(&self) -> Result { + (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(), + expected_attribute_authority: PluginAuthority::Address { address: Pubkey::default() }, + reserved: [0; 8], + } + } +} diff --git a/programs/core-attribute-voter/src/state/idl_types.rs b/programs/core-attribute-voter/src/state/idl_types.rs new file mode 100644 index 0000000..06a57aa --- /dev/null +++ b/programs/core-attribute-voter/src/state/idl_types.rs @@ -0,0 +1,17 @@ +//! IDL only types which are required in IDL but not exported automatically by Anchor +use anchor_lang::prelude::*; + +/// NftVoteRecord exported to IDL without account_discriminator +/// TODO: Once we can support these accounts in Anchor via remaining_accounts then it should be possible to remove it +#[account] +pub struct NftVoteRecord { + /// Proposal which was voted on + pub proposal: Pubkey, + + /// The mint of the NFT which was used for the vote + pub nft_mint: Pubkey, + + /// The voter who casted this vote + /// It's a Realm member pubkey corresponding to TokenOwnerRecord.governing_token_owner + pub governing_token_owner: Pubkey, +} diff --git a/programs/core-attribute-voter/src/state/max_voter_weight_record.rs b/programs/core-attribute-voter/src/state/max_voter_weight_record.rs new file mode 100644 index 0000000..35b215e --- /dev/null +++ b/programs/core-attribute-voter/src/state/max_voter_weight_record.rs @@ -0,0 +1,96 @@ +use crate::id; +use crate::tools::anchor::DISCRIMINATOR_SIZE; +use anchor_lang::prelude::Pubkey; +use anchor_lang::prelude::*; +use anchor_lang::solana_program::pubkey::PUBKEY_BYTES; + +/// MaxVoterWeightRecord account as defined in spl-governance-addin-api +/// It's redefined here without account_discriminator for Anchor to treat it as native account +/// +/// The account is used as an api interface to provide max voting power to the governance program from external addin contracts +#[account] +#[derive(Debug, PartialEq)] +pub struct MaxVoterWeightRecord { + /// 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, + + /// Reserved space for future versions + pub reserved: [u8; 8], +} + +impl Default for MaxVoterWeightRecord { + fn default() -> Self { + Self { + realm: Default::default(), + governing_token_mint: Default::default(), + max_voter_weight: Default::default(), + max_voter_weight_expiry: Some(0), + reserved: Default::default(), + } + } +} + +impl MaxVoterWeightRecord { + pub fn get_space() -> usize { + DISCRIMINATOR_SIZE + PUBKEY_BYTES * 2 + 8 + 1 + 8 + 8 + } +} + +/// Returns MaxVoterWeightRecord PDA seeds +pub fn get_max_voter_weight_record_seeds<'a>( + realm: &'a Pubkey, + governing_token_mint: &'a Pubkey, +) -> [&'a [u8]; 3] { + [ + b"max-voter-weight-record", + realm.as_ref(), + governing_token_mint.as_ref(), + ] +} + +/// Returns MaxVoterWeightRecord PDA address +pub fn get_max_voter_weight_record_address( + realm: &Pubkey, + governing_token_mint: &Pubkey, +) -> Pubkey { + Pubkey::find_program_address( + &get_max_voter_weight_record_seeds(realm, governing_token_mint), + &id(), + ) + .0 +} + +#[cfg(test)] +mod test { + + use super::*; + + #[test] + fn test_get_space() { + // Arrange + let expected_space = MaxVoterWeightRecord::get_space(); + + // Act + let actual_space = + DISCRIMINATOR_SIZE + MaxVoterWeightRecord::default().try_to_vec().unwrap().len(); + + // Assert + assert_eq!(expected_space, actual_space); + } +} diff --git a/programs/core-attribute-voter/src/state/mod.rs b/programs/core-attribute-voter/src/state/mod.rs new file mode 100644 index 0000000..4084a58 --- /dev/null +++ b/programs/core-attribute-voter/src/state/mod.rs @@ -0,0 +1,15 @@ +pub use registrar::*; +pub mod registrar; + +pub use collection_config::*; +pub mod collection_config; + +pub use nft_vote_record::*; +pub mod nft_vote_record; + +pub mod max_voter_weight_record; + +pub use voter_weight_record::*; +pub mod voter_weight_record; + +pub mod idl_types; diff --git a/programs/core-attribute-voter/src/state/nft_vote_record.rs b/programs/core-attribute-voter/src/state/nft_vote_record.rs new file mode 100644 index 0000000..d84ffa0 --- /dev/null +++ b/programs/core-attribute-voter/src/state/nft_vote_record.rs @@ -0,0 +1,84 @@ +use anchor_lang::prelude::*; +use anchor_lang::solana_program::program_pack::IsInitialized; + +use spl_governance_tools::account::{get_account_data, AccountMaxSize}; + +use crate::{error::CoreNftAttributeVoterError, id}; + +/// Vote record indicating the given NFT voted on the Proposal +/// The PDA of the record is ["nft-vote-record",proposal,asset_mint] +/// It guarantees uniques and ensures the same NFT can't vote twice +#[derive(Clone, Debug, PartialEq, borsh_1::BorshDeserialize, borsh_1::BorshSerialize)] +#[borsh(crate = "borsh_1")] +pub struct AssetVoteRecord { + /// AssetVoteRecord discriminator sha256("account:AssetVoteRecord")[..8] + /// Note: The discriminator is used explicitly because AssetVoteRecords + /// are created and consumed dynamically using remaining_accounts + /// and Anchor doesn't really support this scenario without going through lots of hoops + /// Once Anchor has better support for the scenario it shouldn't be necessary + pub account_discriminator: [u8; 8], + + /// Proposal which was voted on + pub proposal: Pubkey, + + /// The mint of the NFT which was used for the vote + pub asset_mint: Pubkey, + + /// The voter who casted this vote + /// It's a Realm member pubkey corresponding to TokenOwnerRecord.governing_token_owner + pub governing_token_owner: Pubkey, + + /// Reserved for future upgrades + pub reserved: [u8; 8], +} + +impl AssetVoteRecord { + /// sha256("account:AssetVoteRecord")[..8] + pub const ACCOUNT_DISCRIMINATOR: [u8; 8] = [14, 166, 191, 239, 186, 156, 140, 83]; +} + +impl AccountMaxSize for AssetVoteRecord {} + +impl IsInitialized for AssetVoteRecord { + fn is_initialized(&self) -> bool { + self.account_discriminator == AssetVoteRecord::ACCOUNT_DISCRIMINATOR + } +} + +/// Returns AssetVoteRecord PDA seeds +pub fn get_nft_vote_record_seeds<'a>(proposal: &'a Pubkey, asset_mint: &'a Pubkey) -> [&'a [u8]; 3] { + [b"nft-vote-record", proposal.as_ref(), asset_mint.as_ref()] +} + +/// Returns AssetVoteRecord PDA address +pub fn get_nft_vote_record_address(proposal: &Pubkey, asset_mint: &Pubkey) -> Pubkey { + Pubkey::find_program_address(&get_nft_vote_record_seeds(proposal, asset_mint), &id()).0 +} + +/// Deserializes account and checks owner program +pub fn get_nft_vote_record_data(nft_vote_record_info: &AccountInfo) -> Result { + Ok(get_account_data::( + &id(), + nft_vote_record_info, + )?) +} + +pub fn get_nft_vote_record_data_for_proposal_and_token_owner( + nft_vote_record_info: &AccountInfo, + proposal: &Pubkey, + governing_token_owner: &Pubkey, +) -> Result { + let nft_vote_record = get_nft_vote_record_data(nft_vote_record_info)?; + + require!( + nft_vote_record.proposal == *proposal, + CoreNftAttributeVoterError::InvalidProposalForNftVoteRecord + ); + + require!( + nft_vote_record.governing_token_owner == *governing_token_owner, + CoreNftAttributeVoterError::InvalidTokenOwnerForNftVoteRecord + ); + + Ok(nft_vote_record) +} diff --git a/programs/core-attribute-voter/src/state/registrar.rs b/programs/core-attribute-voter/src/state/registrar.rs new file mode 100644 index 0000000..be4f96d --- /dev/null +++ b/programs/core-attribute-voter/src/state/registrar.rs @@ -0,0 +1,219 @@ +use crate::{ + error::CoreNftAttributeVoterError, + id, + state::{CollectionConfig, VoterWeightRecord}, + tools::anchor::DISCRIMINATOR_SIZE, +}; +use anchor_lang::prelude::*; +use mpl_core::{accounts::BaseAssetV1, types::UpdateAuthority, types::PluginType, fetch_plugin}; +use anchor_lang::solana_program::pubkey::PUBKEY_BYTES; +use spl_governance::state::{enums::ProposalState, proposal, token_owner_record}; + +/// Registrar which stores NFT voting configuration for the given Realm +#[account] +#[derive(Debug, PartialEq)] +pub struct Registrar { + /// spl-governance program the Realm belongs to + pub governance_program_id: Pubkey, + + /// Realm of the Registrar + pub realm: Pubkey, + + /// Governing token mint the Registrar is for + /// It can either be the Community or the Council mint of the Realm + /// When the plugin is used the mint is only used as identity of the governing power (voting population) + /// and the actual token of the mint is not used + pub governing_token_mint: Pubkey, + + /// Core Collection used for voting + pub collection_configs: Vec, + + /// Reserved for future upgrades + pub reserved: [u8; 128], +} + +impl Registrar { + pub fn get_space(max_collections: u8) -> usize { + DISCRIMINATOR_SIZE + + PUBKEY_BYTES * 3 + + 4 + + max_collections as usize * CollectionConfig::SERIALIZED_SIZE + + 128 + } +} + +/// Returns Registrar PDA seeds +pub fn get_registrar_seeds<'a>( + realm: &'a Pubkey, + governing_token_mint: &'a Pubkey, +) -> [&'a [u8]; 3] { + [b"registrar", realm.as_ref(), governing_token_mint.as_ref()] +} + +/// Returns Registrar PDA address +pub fn get_registrar_address(realm: &Pubkey, governing_token_mint: &Pubkey) -> Pubkey { + Pubkey::find_program_address(&get_registrar_seeds(realm, governing_token_mint), &id()).0 +} + +impl Registrar { + pub fn get_collection_config(&self, collection: Pubkey) -> Result<&CollectionConfig> { + return self + .collection_configs + .iter() + .find(|cc| cc.collection == collection) + .ok_or_else(|| CoreNftAttributeVoterError::CollectionNotFound.into()); + } + + pub fn max_voter_weight(&self) -> Result { + self.collection_configs + .iter() + .try_fold(0u64, |sum, cc| { + let weight = cc.get_max_weight()?; + sum.checked_add(weight) + .ok_or_else(|| CoreNftAttributeVoterError::ArithmeticOverflow.into()) + }) + } +} + +// Resolves governing_token_owner from voter TokenOwnerRecord and +// 1) asserts it matches the given Registrar and VoterWeightRecord +// 2) asserts governing_token_owner or its delegate is a signer +pub fn resolve_governing_token_owner( + registrar: &Registrar, + voter_token_owner_record_info: &AccountInfo, + voter_authority_info: &AccountInfo, + voter_weight_record: &VoterWeightRecord, +) -> Result { + let voter_token_owner_record = + token_owner_record::get_token_owner_record_data_for_realm_and_governing_mint( + ®istrar.governance_program_id, + voter_token_owner_record_info, + ®istrar.realm, + ®istrar.governing_token_mint, + )?; + + voter_token_owner_record.assert_token_owner_or_delegate_is_signer(voter_authority_info)?; + + // Assert voter TokenOwnerRecord and VoterWeightRecord are for the same governing_token_owner + require_eq!( + voter_token_owner_record.governing_token_owner, + voter_weight_record.governing_token_owner, + CoreNftAttributeVoterError::InvalidTokenOwnerForVoterWeightRecord + ); + + Ok(voter_token_owner_record.governing_token_owner) +} + +/// Resolves proposal account +pub fn resolve_proposal_account( + registrar: &Registrar, + proposal_info: &AccountInfo, +) -> Result { + let proposal_data = proposal::get_proposal_data( + ®istrar.governance_program_id, proposal_info + )?; + + if proposal_data.state != ProposalState::Voting { + return Err(CoreNftAttributeVoterError::InvalidProposalState.into()); + } + + Ok(proposal_info.key()) +} + +/// Resolves vote weight and voting mint for the given NFT +/// Reads the weight from the NFT's Attributes plugin using the collection's weight_attribute_key +pub fn resolve_nft_vote_weight_and_mint( + registrar: &Registrar, + governing_token_owner: &Pubkey, + asset_key: Pubkey, + asset: &BaseAssetV1, + asset_account_info: &AccountInfo, + unique_nft_mints: &mut Vec, +) -> Result<(u64, Pubkey)> { + let nft_owner = asset.owner; + + // voter_weight_record.governing_token_owner must be the owner of the NFT + require!( + nft_owner == *governing_token_owner, + CoreNftAttributeVoterError::VoterDoesNotOwnNft + ); + + let nft_mint = asset_key; + + // Ensure the same NFT was not provided more than once + if unique_nft_mints.contains(&nft_mint) { + return Err(CoreNftAttributeVoterError::DuplicatedNftDetected.into()); + } + unique_nft_mints.push(nft_mint); + + // The Core NFT must have a collection and the collection must be verified + let collection = match asset.update_authority { + UpdateAuthority::Collection(collection) => { + collection + }, + _ => return Err(CoreNftAttributeVoterError::InvalidNftCollection.into()) + }; + + let collection_config = registrar.get_collection_config(collection)?; + + // Fetch the Attributes plugin from the asset + let (authority, attributes, _) = fetch_plugin::( + asset_account_info, + PluginType::Attributes, + ) + .map_err(|_| CoreNftAttributeVoterError::AttributeNotFound)?; + + // Verify the Attributes plugin authority matches the expected authority + require!( + authority == collection_config.expected_attribute_authority, + CoreNftAttributeVoterError::AttributeAuthorityMismatch + ); + + // Find the attribute matching the collection's weight_attribute_key + let weight_value = attributes + .attribute_list + .iter() + .find(|attr| attr.key == collection_config.weight_attribute_key) + .ok_or(CoreNftAttributeVoterError::AttributeNotFound)?; + + // Parse the attribute value as u64 + let weight: u64 = weight_value + .value + .parse::() + .map_err(|_| CoreNftAttributeVoterError::InvalidAttributeValue)?; + + // Cap the weight to max_weight to prevent any single NFT from exceeding the configured ceiling + let capped_weight = weight.min(collection_config.max_weight); + + Ok((capped_weight, nft_mint)) +} + +#[cfg(test)] +mod test { + + use super::*; + + #[test] + fn test_get_space() { + // Arrange + let expected_space = Registrar::get_space(3); + + let registrar = Registrar { + governance_program_id: Pubkey::default(), + realm: Pubkey::default(), + governing_token_mint: Pubkey::default(), + collection_configs: vec![ + CollectionConfig::default(), + CollectionConfig::default(), + CollectionConfig::default(), + ], + reserved: [0; 128], + }; + + // Act + let actual_space = DISCRIMINATOR_SIZE + registrar.try_to_vec().unwrap().len(); + + // Assert + assert_eq!(expected_space, actual_space); + } +} diff --git a/programs/core-attribute-voter/src/state/voter_weight_record.rs b/programs/core-attribute-voter/src/state/voter_weight_record.rs new file mode 100644 index 0000000..4d7bbd4 --- /dev/null +++ b/programs/core-attribute-voter/src/state/voter_weight_record.rs @@ -0,0 +1,110 @@ +use anchor_lang::prelude::*; +use anchor_lang::solana_program::pubkey::PUBKEY_BYTES; + +use crate::tools::anchor::DISCRIMINATOR_SIZE; + +/// VoterWeightAction enum as defined in spl-governance-addin-api +/// It's redefined here for Anchor to export it to IDL +#[derive(AnchorSerialize, AnchorDeserialize, Debug, Clone, Copy, PartialEq)] +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, + + /// Signs off a proposal for a governance. Target: Proposal + /// Note: SignOffProposal is not supported in the current version + SignOffProposal, +} + +/// VoterWeightRecord account as defined in spl-governance-addin-api +/// It's redefined here without account_discriminator for Anchor to treat it as native account +/// +/// The account is used as an api interface to provide voting power to the governance program from external addin contracts +#[account] +#[derive(Debug, PartialEq)] +pub struct VoterWeightRecord { + /// 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, + + /// 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, + + /// 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, + + /// Reserved space for future versions + pub reserved: [u8; 8], +} + +impl VoterWeightRecord { + pub fn get_space() -> usize { + DISCRIMINATOR_SIZE + PUBKEY_BYTES * 4 + 8 + 1 + 8 + 1 + 1 + 1 + 8 + } +} + +impl Default for VoterWeightRecord { + fn default() -> Self { + Self { + realm: Default::default(), + governing_token_mint: Default::default(), + governing_token_owner: Default::default(), + voter_weight: Default::default(), + voter_weight_expiry: Some(0), + weight_action: Some(VoterWeightAction::CastVote), + weight_action_target: Some(Default::default()), + reserved: Default::default(), + } + } +} + +#[cfg(test)] +mod test { + + use super::*; + + #[test] + fn test_get_space() { + // Arrange + let expected_space = VoterWeightRecord::get_space(); + + // Act + let actual_space = + DISCRIMINATOR_SIZE + VoterWeightRecord::default().try_to_vec().unwrap().len(); + + // Assert + assert_eq!(expected_space, actual_space); + } +} diff --git a/programs/core-attribute-voter/src/tools/anchor.rs b/programs/core-attribute-voter/src/tools/anchor.rs new file mode 100644 index 0000000..abc1dd5 --- /dev/null +++ b/programs/core-attribute-voter/src/tools/anchor.rs @@ -0,0 +1 @@ +pub const DISCRIMINATOR_SIZE: usize = 8; diff --git a/programs/core-attribute-voter/src/tools/governance.rs b/programs/core-attribute-voter/src/tools/governance.rs new file mode 100644 index 0000000..ccb2573 --- /dev/null +++ b/programs/core-attribute-voter/src/tools/governance.rs @@ -0,0 +1,19 @@ +use anchor_lang::prelude::Pubkey; +use spl_governance::state::{token_owner_record, vote_record}; + +pub fn get_vote_record_address( + program_id: &Pubkey, + realm: &Pubkey, + governing_token_mint: &Pubkey, + governing_token_owner: &Pubkey, + proposal: &Pubkey, +) -> Pubkey { + let token_owner_record_key = token_owner_record::get_token_owner_record_address( + program_id, + realm, + governing_token_mint, + governing_token_owner, + ); + + vote_record::get_vote_record_address(program_id, proposal, &token_owner_record_key) +} diff --git a/programs/core-attribute-voter/src/tools/mod.rs b/programs/core-attribute-voter/src/tools/mod.rs new file mode 100644 index 0000000..aecc39e --- /dev/null +++ b/programs/core-attribute-voter/src/tools/mod.rs @@ -0,0 +1,2 @@ +pub mod anchor; +pub mod governance; diff --git a/programs/core-attribute-voter/tests/cast_nft_vote.rs b/programs/core-attribute-voter/tests/cast_nft_vote.rs new file mode 100644 index 0000000..3d7a2a9 --- /dev/null +++ b/programs/core-attribute-voter/tests/cast_nft_vote.rs @@ -0,0 +1,1505 @@ +use crate::program_test::core_voter_test::ConfigureCollectionArgs; +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use gpl_core_attribute_voter::state::*; +use program_test::{ + core_voter_test::*, + tools::{assert_gov_err, assert_nft_voter_err}, +}; + +use solana_program_test::*; +use solana_sdk::transport::TransportError; +use spl_governance::error::GovernanceError; + +mod program_test; + +#[tokio::test] +async fn test_cast_asset_vote() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + // Act + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Assert + let asset_vote_record = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(asset_vote_record_cookies[0].account, asset_vote_record); + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 10); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CastVote.into()) + ); + assert_eq!( + voter_weight_record.weight_action_target, + Some(proposal_cookie.address) + ); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_multiple_nfts() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + let asset_cookie2 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + // Act + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1, &asset_cookie2], + None, + ) + .await?; + + // Assert + let asset_vote_record1 = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(asset_vote_record_cookies[0].account, asset_vote_record1); + + let asset_vote_record2 = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[1].address) + .await; + + assert_eq!(asset_vote_record_cookies[1].account, asset_vote_record2); + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 20); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CastVote.into()) + ); + assert_eq!( + voter_weight_record.weight_action_target, + Some(proposal_cookie.address) + ); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_nft_already_voted_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie: program_test::program_test_bench::WalletCookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(CastAssetVoteArgs { + cast_spl_gov_vote: false, + }), + ) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(CastAssetVoteArgs { + cast_spl_gov_vote: false, + }), + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::NftAlreadyVoted); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_invalid_voter_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + + // Act + + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie2, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_gov_err(err, GovernanceError::GoverningTokenOwnerOrDelegateMustSign); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_invalid_owner_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + + let asset_cookie = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie2, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::VoterDoesNotOwnNft); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_invalid_collection_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie: program_test::governance_test::RealmCookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let collection_cookie2 = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie: program_test::program_test_bench::WalletCookie = core_voter_test.bench.with_wallet().await; + + let _random_asset_cookie = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + let asset_cookie = core_voter_test + .core.create_asset_with_weight(&collection_cookie2, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::CollectionNotFound); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_same_nft_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie, &asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::DuplicatedNftDetected); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_max_5_nfts() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let mut asset_cookies = vec![]; + + for _ in 0..5 { + core_voter_test.bench.advance_clock().await; + let asset_cookie = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + asset_cookies.push(asset_cookie) + } + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + // Act + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_cookies.iter().collect::>(), + None, + ) + .await?; + + // Assert + let asset_vote_record1 = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(asset_vote_record_cookies[0].account, asset_vote_record1); + + let asset_vote_record2 = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[1].address) + .await; + + assert_eq!(asset_vote_record_cookies[1].account, asset_vote_record2); + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 50); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CastVote.into()) + ); + assert_eq!( + voter_weight_record.weight_action_target, + Some(proposal_cookie.address) + ); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_using_multiple_instructions() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + let asset_cookie2 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + let args = CastAssetVoteArgs { + cast_spl_gov_vote: false, + }; + + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(args), + ) + .await?; + + // Act + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie2], + None, + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 20); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CastVote.into()) + ); + assert_eq!( + voter_weight_record.weight_action_target, + Some(proposal_cookie.address) + ); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_using_multiple_instructions_with_nft_already_voted_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let args = CastAssetVoteArgs { + cast_spl_gov_vote: false, + }; + + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(args), + ) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::NftAlreadyVoted); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_using_multiple_instructions_with_attempted_sandwiched_relinquish() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let args = CastAssetVoteArgs { + cast_spl_gov_vote: false, + }; + + // Cast vote with NFT + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(args), + ) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Try relinquish NftVoteRecords to accumulate vote + core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await?; + + // Act + + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 10); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_using_delegate() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + + let delegate_cookie = core_voter_test.bench.with_wallet().await; + core_voter_test + .governance + .set_governance_delegate( + &realm_cookie, + &voter_token_owner_record_cookie, + &voter_cookie, + &Some(delegate_cookie.address), + ) + .await; + + // Act + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &delegate_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Assert + let asset_vote_record = core_voter_test + .get_asset_vote_record_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(asset_vote_record_cookies[0].account, asset_vote_record); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_invalid_voter_weight_token_owner_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + // Try to update VoterWeightRecord for different governing_token_owner + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + + let voter_weight_record_cookie2 = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie2) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + // Act + + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie2, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidTokenOwnerForVoterWeightRecord); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_weight_capped_to_max() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create an NFT with weight 100 but configure collection with max_weight 5 + let asset_cookie = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 100) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 5, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await?; + + // Assert — weight should be capped to max_weight (5), not the NFT's actual weight (100) + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 5); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_nft_missing_attributes_plugin_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create an NFT without any attributes plugin + let asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie, &voter_cookie) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::AttributeNotFound); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_missing_weight_attribute_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create an NFT with a different attribute key than what the collection expects + let asset_cookie = core_voter_test + .core + .create_asset_with_named_weight( + &collection_cookie, + &voter_cookie, + "other_key", + "10", + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::AttributeNotFound); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_invalid_attribute_value_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create an NFT with a non-numeric weight attribute value + let asset_cookie = core_voter_test + .core + .create_asset_with_named_weight( + &collection_cookie, + &voter_cookie, + "weight", + "not_a_number", + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + // Act + let err = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie], + None, + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidAttributeValue); + + Ok(()) +} + +#[tokio::test] +async fn test_cast_asset_vote_with_multiple_collections() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie1 = core_voter_test.core.create_collection(None).await?; + let collection_cookie2 = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create assets in different collections + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie1, &voter_cookie, 10) + .await?; + + let asset_cookie2 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie2, &voter_cookie, 20) + .await?; + + // Register both collections + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie1, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie2, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 20, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act — vote with NFTs from both collections in a single instruction + core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1, &asset_cookie2], + None, + ) + .await?; + + // Assert — weight should be sum of both NFT weights (10 + 20 = 30) + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 30); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/configure_collection.rs b/programs/core-attribute-voter/tests/configure_collection.rs new file mode 100644 index 0000000..d27a98f --- /dev/null +++ b/programs/core-attribute-voter/tests/configure_collection.rs @@ -0,0 +1,544 @@ +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use program_test::{ + core_voter_test::CoreVoterTest, + tools::{assert_anchor_err, assert_nft_voter_err}, +}; + +use solana_program_test::*; +use solana_sdk::{signature::Keypair, signer::Signer, transport::TransportError}; + +use crate::program_test::core_voter_test::ConfigureCollectionArgs; + +mod program_test; + +#[tokio::test] +async fn test_configure_collection() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let _asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie, &voter_cookie) + .await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act + let collection_config_cookie = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), + ) + .await?; + + // Assert + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + assert_eq!(registrar.collection_configs.len(), 1); + + assert_eq!( + registrar.collection_configs[0], + collection_config_cookie.collection_config + ); + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + 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 + ); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_multiple_collections() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie1 = core_voter_test.core.create_collection(None).await?; + let collection_cookie2 = core_voter_test.core.create_collection(None).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + for _ in 0..5 { + let _asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie1, &voter_cookie) + .await?; + } + + for _ in 0..10 { + let _asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie2, &voter_cookie) + .await?; + } + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie1, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie2, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 2, ..Default::default() }), + ) + .await?; + + // Assert + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + assert_eq!(registrar.collection_configs.len(), 2); + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None); + assert_eq!(max_voter_weight_record.max_voter_weight, 25); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_max_collections() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + + let _voter_cookie = core_voter_test.bench.with_wallet().await; + + for _ in 0..registrar_cookie.max_collections { + let collection_cookie = core_voter_test.core.create_collection(Some(3)).await?; + + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 1, ..Default::default() }), + ) + .await?; + } + + // Assert + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + assert_eq!( + registrar.collection_configs.len() as u8, + registrar_cookie.max_collections + ); + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None); + assert_eq!(max_voter_weight_record.max_voter_weight, 30); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_existing_collection() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(10)).await?; + + let _voter_cookie = core_voter_test.bench.with_wallet().await; + + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + // Act + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 2, ..Default::default() }), + ) + .await?; + + // Assert + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + assert_eq!(registrar.collection_configs.len(), 1); + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + assert_eq!(max_voter_weight_record.max_voter_weight_expiry, None); + assert_eq!(max_voter_weight_record.max_voter_weight, 20); + + Ok(()) +} + +// TODO: Remove collection test + +#[tokio::test] +async fn test_configure_collection_with_invalid_realm_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let _asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie, &voter_cookie) + .await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Try to use a different Realm + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + + // Act + let err = core_voter_test + .with_collection_using_ix( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + |i| i.accounts[1].pubkey = realm_cookie2.address, // realm + None, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidRealmForRegistrar); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_realm_authority_must_sign_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let _asset_cookie = core_voter_test + .core + .create_asset(&collection_cookie, &voter_cookie) + .await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act + let err = core_voter_test + .with_collection_using_ix( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + |i| i.accounts[2].is_signer = false, // realm_authority + Some(&[]), + ) + .await + .err() + .unwrap(); + + // Assert + + assert_anchor_err(err, anchor_lang::error::ErrorCode::AccountNotSigner); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_invalid_realm_authority_error() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + // let voter_cookie = core_voter_test.bench.with_wallet().await; + + // let _asset_cookie = core_voter_test + // .core + // .create_asset(&collection_cookie, &voter_cookie) + // .await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let realm_authority = Keypair::new(); + + // Act + let err = core_voter_test + .with_collection_using_ix( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + |i| i.accounts[2].pubkey = realm_authority.pubkey(), // realm_authority + Some(&[&realm_authority]), + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidRealmAuthority); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_invalid_max_voter_weight_realm_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + // let voter_cookie = core_voter_test.bench.with_wallet().await; + + // let _asset_cookie = core_voter_test + // .core + // .create_asset(&collection_cookie, &voter_cookie) + // .await?; + + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + let registrar_cookie2 = core_voter_test.with_registrar(&realm_cookie2).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie2) + .await?; + + // Act + let err = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidMaxVoterWeightRecordRealm); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_invalid_max_voter_weight_mint_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + // let voter_cookie = core_voter_test.bench.with_wallet().await; + + // let _asset_cookie = core_voter_test + // .core + // .create_asset(&collection_cookie, &voter_cookie) + // .await?; + + // Create Registrar for council mint + realm_cookie.account.community_mint = realm_cookie.account.config.council_mint.unwrap(); + let registrar_cookie2 = core_voter_test.with_registrar(&realm_cookie).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie2) + .await?; + + // Act + let err = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidMaxVoterWeightRecordMint); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_empty_weight_attribute_key_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act + let err = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + weight_attribute_key: "".to_string(), + ..Default::default() + }), + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidWeightAttributeKey); + + Ok(()) +} + +#[tokio::test] +async fn test_configure_collection_with_too_long_weight_attribute_key_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act — key with 33 chars (exceeds 32 limit) + let err = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + weight_attribute_key: "abcdefghijklmnopqrstuvwxyz1234567".to_string(), + ..Default::default() + }), + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidWeightAttributeKey); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/create_max_voter_weight_record.rs b/programs/core-attribute-voter/tests/create_max_voter_weight_record.rs new file mode 100644 index 0000000..d6bb2dc --- /dev/null +++ b/programs/core-attribute-voter/tests/create_max_voter_weight_record.rs @@ -0,0 +1,127 @@ +use anchor_lang::prelude::ErrorCode; +use program_test::{ + core_voter_test::CoreVoterTest, + tools::{assert_anchor_err, assert_ix_err}, +}; +use solana_program::instruction::InstructionError; +use solana_program_test::*; +use solana_sdk::transport::TransportError; + +mod program_test; + +#[tokio::test] +async fn test_create_max_voter_weight_record() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + // Act + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Assert + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + assert_eq!( + max_voter_weight_record_cookie.account, + max_voter_weight_record + ); + + Ok(()) +} + +#[tokio::test] +async fn test_create_max_voter_weight_record_with_invalid_realm_error() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + + // Act + let err = core_voter_test + .with_max_voter_weight_record_using_ix(®istrar_cookie, |i| { + i.accounts[2].pubkey = realm_cookie2.address // Realm + }) + .await + .err() + .unwrap(); + + // Assert + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} + +#[tokio::test] +async fn test_create_max_voter_weight_record_with_invalid_mint_error() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + + // Act + let err = core_voter_test + .with_max_voter_weight_record_using_ix(®istrar_cookie, |i| { + i.accounts[2].pubkey = realm_cookie2.address // Mint + }) + .await + .err() + .unwrap(); + + // Assert + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} + +#[tokio::test] +async fn test_create_max_voter_weight_record_with_already_exists_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + let err = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await + .err() + .unwrap(); + + // Assert + + // InstructionError::Custom(0) is returned for TransactionError::AccountInUse + assert_ix_err(err, InstructionError::Custom(0)); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/create_registrar.rs b/programs/core-attribute-voter/tests/create_registrar.rs new file mode 100644 index 0000000..c21082c --- /dev/null +++ b/programs/core-attribute-voter/tests/create_registrar.rs @@ -0,0 +1,156 @@ +mod program_test; + +use anchor_lang::prelude::{ErrorCode, Pubkey}; +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use program_test::core_voter_test::CoreVoterTest; + +use solana_program_test::*; +use solana_sdk::{signature::Keypair, transport::TransportError}; + +use program_test::tools::{assert_anchor_err, assert_nft_voter_err}; + +#[tokio::test] +async fn test_create_registrar() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + // Act + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + // Assert + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + assert_eq!(registrar, registrar_cookie.account); + + Ok(()) +} + +#[tokio::test] +async fn test_create_registrar_with_invalid_realm_authority_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + realm_cookie.realm_authority = Keypair::new(); + + // Act + let err = core_voter_test + .with_registrar(&realm_cookie) + .await + .err() + .unwrap(); + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidRealmAuthority); + + Ok(()) +} + +#[tokio::test] +async fn test_create_registrar_with_realm_authority_must_sign_error() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + realm_cookie.realm_authority = Keypair::new(); + + // Act + let err = core_voter_test + .with_registrar_using_ix( + &realm_cookie, + |i| i.accounts[4].is_signer = false, // realm_authority + Some(&[]), + ) + .await + .err() + .unwrap(); + + assert_anchor_err(err, anchor_lang::error::ErrorCode::AccountNotSigner); + + Ok(()) +} + +#[tokio::test] +async fn test_create_registrar_with_invalid_spl_gov_program_id_error() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + realm_cookie.realm_authority = Keypair::new(); + + // Try to use a different program id + let governance_program_id = core_voter_test.program_id; + + // Act + let err = core_voter_test + .with_registrar_using_ix( + &realm_cookie, + |i| i.accounts[1].pubkey = governance_program_id, //governance_program_id + None, + ) + .await + .err() + .unwrap(); + + assert_anchor_err(err, anchor_lang::error::ErrorCode::ConstraintOwner); + + Ok(()) +} + +#[tokio::test] +async fn test_create_registrar_with_invalid_realm_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + realm_cookie.realm_authority = Keypair::new(); + + // Act + let err = core_voter_test + .with_registrar_using_ix( + &realm_cookie, + |i| i.accounts[2].pubkey = Pubkey::new_unique(), // realm + None, + ) + .await + .err() + .unwrap(); + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} + +#[tokio::test] +async fn test_create_registrar_with_invalid_governing_token_mint_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let mut realm_cookie = core_voter_test.governance.with_realm().await?; + realm_cookie.realm_authority = Keypair::new(); + + let mint_cookie = core_voter_test.bench.with_mint().await?; + + // Act + let err = core_voter_test + .with_registrar_using_ix( + &realm_cookie, + |i| i.accounts[3].pubkey = mint_cookie.address, // governing_token_mint + None, + ) + .await + .err() + .unwrap(); + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/create_voter_weight_record.rs b/programs/core-attribute-voter/tests/create_voter_weight_record.rs new file mode 100644 index 0000000..6a6c75d --- /dev/null +++ b/programs/core-attribute-voter/tests/create_voter_weight_record.rs @@ -0,0 +1,127 @@ +use anchor_lang::prelude::ErrorCode; +use program_test::core_voter_test::CoreVoterTest; +use program_test::tools::{assert_anchor_err, assert_ix_err}; +use solana_program::instruction::InstructionError; +use solana_program_test::*; +use solana_sdk::transport::TransportError; + +mod program_test; + +#[tokio::test] +async fn test_create_voter_weight_record() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Act + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record_cookie.account, voter_weight_record); + + Ok(()) +} + +#[tokio::test] +async fn test_create_voter_weight_record_with_invalid_realm_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Act + let err = core_voter_test + .with_voter_weight_record_using_ix(®istrar_cookie, &voter_cookie, |i| { + i.accounts[2].pubkey = realm_cookie2.address // Realm + }) + .await + .err() + .unwrap(); + + // Assert + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} + +#[tokio::test] +async fn test_create_voter_weight_record_with_invalid_mint_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let realm_cookie2 = core_voter_test.governance.with_realm().await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Act + let err = core_voter_test + .with_voter_weight_record_using_ix(®istrar_cookie, &voter_cookie, |i| { + i.accounts[2].pubkey = realm_cookie2.address // Mint + }) + .await + .err() + .unwrap(); + + // Assert + + // PDA doesn't match and hence the error is ConstraintSeeds + assert_anchor_err(err, ErrorCode::ConstraintSeeds); + + Ok(()) +} + +#[tokio::test] +async fn test_create_voter_weight_record_with_already_exists_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + let err = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await + .err() + .unwrap(); + + // Assert + + // InstructionError::Custom(0) is returned for TransactionError::AccountInUse + assert_ix_err(err, InstructionError::Custom(0)); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/fixtures/mpl_core.so b/programs/core-attribute-voter/tests/fixtures/mpl_core.so new file mode 100644 index 0000000000000000000000000000000000000000..a8ca47a59745c2d2a3ea4fbc37f3e02f54314193 GIT binary patch literal 848320 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

{D()8?)K?!0juMh^%rlq&-Z=b+TRcM{Y@|D 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 z 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%0Dbb8#H}<&!E2j{Ga%38k}T@wf=WneBf6+ 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 z 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�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

lJEzj}qkc&EHCWd7+8?!F`*RoSC$jr? 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%0DrySo4iQ< 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%0D_!amc*eCO6 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 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd W0RsjM7%*VKfB^#r3>YwAU^oz*Od2u( literal 0 HcmV?d00001 diff --git a/programs/core-attribute-voter/tests/program_test/core_test.rs b/programs/core-attribute-voter/tests/program_test/core_test.rs new file mode 100644 index 0000000..576c924 --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/core_test.rs @@ -0,0 +1,209 @@ +use std::{str::FromStr, sync::Arc}; + +use anchor_lang::prelude::Pubkey; +use solana_program_test::ProgramTest; +use solana_sdk::{signature::Keypair, signer::Signer, system_program, transport::TransportError}; + +use crate::program_test::program_test_bench::{ProgramTestBench, WalletCookie}; + +pub struct AssetCookie { + pub asset: Pubkey, +} + +pub struct CollectionCookie { + pub collection: Pubkey, + pub authority: Keypair, +} + +pub struct CoreTest { + pub bench: Arc, + pub program_id: Pubkey, +} + +impl CoreTest { + pub fn program_id() -> Pubkey { + Pubkey::from_str("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d").unwrap() + } + + #[allow(dead_code)] + pub fn add_program(program_test: &mut ProgramTest) { + program_test.add_program("mpl_core", Self::program_id(), None); + } + + #[allow(dead_code)] + pub fn new(bench: Arc) -> Self { + CoreTest { + bench, + program_id: Self::program_id(), + } + } + + #[allow(dead_code)] + pub async fn create_collection( + &self, + collection_size: Option, + ) -> Result { + let update_authority = self.bench.context.borrow().payer.pubkey(); + let payer = self.bench.context.borrow().payer.pubkey(); + + // Create collection + let coll_keypair = Keypair::new(); + let coll_authority = Keypair::new(); + + let coll_name = "NFT_C".to_string(); + let coll_uri = "URI".to_string(); + + // instruction args + let args = mpl_core::instructions::CreateCollectionV2InstructionArgs { + name: coll_name, + uri: coll_uri, + plugins: None, + external_plugin_adapters: None, + }; + + // instruction accounts + let create_coll_ix_accounts = mpl_core::instructions::CreateCollectionV2 { + collection: coll_keypair.pubkey(), + update_authority: Some(update_authority), + payer, + system_program: system_program::ID, + }; + + // creates the instruction + let create_coll_ix = create_coll_ix_accounts.instruction(args); + + self.bench + .process_transaction(&[create_coll_ix], Some(&[&coll_keypair])) + .await?; + + if let Some(size) = collection_size { + println!("Minting {} assets to collection", size); + self.mint_assets_to_collection( + &CollectionCookie { + collection: coll_keypair.pubkey(), + authority: coll_authority.insecure_clone(), + }, + size, + ) + .await; + } + + Ok(CollectionCookie { + collection: coll_keypair.pubkey(), + authority: coll_authority, + }) + } + + #[allow(dead_code)] + pub async fn create_asset( + &self, + collection_cookie: &CollectionCookie, + asset_owner_cookie: &WalletCookie, + ) -> Result { + self.create_asset_with_attributes(collection_cookie, asset_owner_cookie, None) + .await + } + + #[allow(dead_code)] + pub async fn create_asset_with_attributes( + &self, + collection_cookie: &CollectionCookie, + asset_owner_cookie: &WalletCookie, + attributes: Option>, + ) -> Result { + let collection_authority = self.bench.context.borrow().payer.pubkey(); + let payer = self.bench.context.borrow().payer.pubkey(); + + // Create Asset + let asset_keypair = Keypair::new(); + + let name = "TestAsset".to_string(); + let uri = "URI".to_string(); + + let plugins = attributes.map(|attrs| { + vec![mpl_core::types::PluginAuthorityPair { + plugin: mpl_core::types::Plugin::Attributes(mpl_core::types::Attributes { + attribute_list: attrs, + }), + authority: Some(mpl_core::types::PluginAuthority::UpdateAuthority), + }] + }); + + // instruction args + let args = mpl_core::instructions::CreateV2InstructionArgs { + data_state: mpl_core::types::DataState::AccountState, + name, + uri, + plugins, + external_plugin_adapters: None, + }; + + // instruction accounts + let create_accounts = mpl_core::instructions::CreateV2 { + asset: asset_keypair.pubkey(), + collection: Some(collection_cookie.collection), + authority: Some(collection_authority), + payer, + owner: Some(asset_owner_cookie.address), + update_authority: None, + system_program: system_program::ID, + log_wrapper: None, + }; + + // creates the instruction + let create_ix = create_accounts.instruction(args); + + self.bench + .process_transaction(&[create_ix], Some(&[&asset_keypair])) + .await?; + + Ok(AssetCookie { + asset: asset_keypair.pubkey(), + }) + } + + #[allow(dead_code)] + pub async fn create_asset_with_weight( + &self, + collection_cookie: &CollectionCookie, + asset_owner_cookie: &WalletCookie, + weight: u64, + ) -> Result { + self.create_asset_with_attributes( + collection_cookie, + asset_owner_cookie, + Some(vec![mpl_core::types::Attribute { + key: "weight".to_string(), + value: weight.to_string(), + }]), + ) + .await + } + + #[allow(dead_code)] + pub async fn create_asset_with_named_weight( + &self, + collection_cookie: &CollectionCookie, + asset_owner_cookie: &WalletCookie, + weight_key: &str, + weight_value: &str, + ) -> Result { + self.create_asset_with_attributes( + collection_cookie, + asset_owner_cookie, + Some(vec![mpl_core::types::Attribute { + key: weight_key.to_string(), + value: weight_value.to_string(), + }]), + ) + .await + } + + pub async fn mint_assets_to_collection(&self, collection_cookie: &CollectionCookie, size: u64) { + let asset_owner = self.bench.with_wallet().await; + + for _ in 0..size { + let _ = self.create_asset(&collection_cookie, &asset_owner).await; + } + } +} diff --git a/programs/core-attribute-voter/tests/program_test/core_voter_test.rs b/programs/core-attribute-voter/tests/program_test/core_voter_test.rs new file mode 100644 index 0000000..256fd2d --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/core_voter_test.rs @@ -0,0 +1,697 @@ +use std::sync::Arc; + +use anchor_lang::prelude::{AccountMeta, Pubkey}; + +use anchor_lang::system_program; +use gpl_core_attribute_voter::state::max_voter_weight_record::{ + get_max_voter_weight_record_address, MaxVoterWeightRecord, +}; +use gpl_core_attribute_voter::state::*; + +use mpl_core::accounts::BaseCollectionV1; +use solana_sdk::transport::TransportError; +use spl_governance::instruction::cast_vote; +use spl_governance::state::vote_record::{self, Vote, VoteChoice}; + +use gpl_core_attribute_voter::state::{ + get_nft_vote_record_address, get_registrar_address, AssetVoteRecord, CollectionConfig, + Registrar, +}; + +use solana_program_test::{BanksClientError, ProgramTest}; +use solana_sdk::instruction::Instruction; +use solana_sdk::signature::Keypair; +use solana_sdk::signer::Signer; + +use crate::program_test::governance_test::GovernanceTest; +use crate::program_test::program_test_bench::ProgramTestBench; + +use crate::program_test::core_test::{AssetCookie, CollectionCookie, CoreTest}; +use crate::program_test::governance_test::{ProposalCookie, RealmCookie, TokenOwnerRecordCookie}; +use crate::program_test::program_test_bench::WalletCookie; +use crate::program_test::tools::NopOverride; + +#[derive(Debug, PartialEq)] +pub struct RegistrarCookie { + pub address: Pubkey, + pub account: Registrar, + + pub realm_authority: Keypair, + pub max_collections: u8, +} + + +pub struct VoterWeightRecordCookie { + pub address: Pubkey, + pub account: VoterWeightRecord, +} + +pub struct MaxVoterWeightRecordCookie { + pub address: Pubkey, + pub account: MaxVoterWeightRecord, +} + +pub struct CollectionConfigCookie { + pub collection_config: CollectionConfig, +} + +pub struct ConfigureCollectionArgs { + pub max_weight: u64, + pub weight_attribute_key: String, + pub expected_attribute_authority: mpl_core::types::PluginAuthority, +} + +impl Default for ConfigureCollectionArgs { + fn default() -> Self { + Self { + max_weight: 1, + weight_attribute_key: "weight".to_string(), + expected_attribute_authority: mpl_core::types::PluginAuthority::UpdateAuthority, + } + } +} + +#[derive(Debug, PartialEq)] +pub struct AssetVoteRecordCookie { + pub address: Pubkey, + pub account: AssetVoteRecord, +} + +pub struct CastAssetVoteArgs { + pub cast_spl_gov_vote: bool, +} + +impl Default for CastAssetVoteArgs { + fn default() -> Self { + Self { + cast_spl_gov_vote: true, + } + } +} + +pub struct CoreVoterTest { + pub program_id: Pubkey, + pub bench: Arc, + pub governance: GovernanceTest, + pub core: CoreTest, +} + +impl CoreVoterTest { + #[allow(dead_code)] + pub fn add_program(program_test: &mut ProgramTest) { + program_test.add_program("gpl_core_attribute_voter", gpl_core_attribute_voter::id(), None); + } + + #[allow(dead_code)] + pub async fn start_new() -> Self { + let mut program_test = ProgramTest::new("gpl_core_attribute_voter", gpl_core_attribute_voter::id(), None); + + CoreVoterTest::add_program(&mut program_test); + GovernanceTest::add_program(&mut program_test); + CoreTest::add_program(&mut program_test); + + let program_id = gpl_core_attribute_voter::id(); + + let bench = ProgramTestBench::start_new(program_test).await; + let bench_rc = Arc::new(bench); + + let governance_bench = + GovernanceTest::new(bench_rc.clone(), Some(program_id), Some(program_id)); + let core_bench = CoreTest::new(bench_rc.clone()); + + Self { + program_id, + bench: bench_rc, + governance: governance_bench, + core: core_bench, + } + } + + #[allow(dead_code)] + pub async fn with_asset( + &self, + collection_cookie: &CollectionCookie, + asset_owner_cookie: &WalletCookie, + ) -> Result { + let collection_authority = self.bench.context.borrow().payer.pubkey(); + let payer = self.bench.context.borrow().payer.pubkey(); + + // Create Asset + let asset_keypair = Keypair::new(); + + let name = "TestAsset".to_string(); + let uri = "URI".to_string(); + + // instruction args + let args = mpl_core::instructions::CreateV2InstructionArgs { + data_state: mpl_core::types::DataState::AccountState, + name, + uri, + plugins: None, + external_plugin_adapters: None, + }; + + // instruction accounts + let create_accounts = mpl_core::instructions::CreateV2 { + asset: asset_keypair.pubkey(), + collection: Some(collection_cookie.collection), + authority: Some(collection_authority), + payer, + owner: Some(asset_owner_cookie.address), + update_authority: None, + system_program: system_program::ID, + log_wrapper: None, + }; + + // creates the instruction + let create_ix = create_accounts.instruction(args); + + self.bench + .process_transaction(&[create_ix], Some(&[&asset_keypair])) + .await?; + + Ok(AssetCookie { + asset: asset_keypair.pubkey(), + }) + } + + #[allow(dead_code)] + pub async fn with_registrar( + &mut self, + realm_cookie: &RealmCookie, + ) -> Result { + self.with_registrar_using_ix(realm_cookie, NopOverride, None) + .await + } + + #[allow(dead_code)] + pub async fn with_registrar_using_ix( + &mut self, + realm_cookie: &RealmCookie, + instruction_override: F, + signers_override: Option<&[&Keypair]>, + ) -> Result { + let registrar_key = + get_registrar_address(&realm_cookie.address, &realm_cookie.account.community_mint); + + let max_collections = 10; + + let data = + anchor_lang::InstructionData::data(&gpl_core_attribute_voter::instruction::CreateRegistrar { + max_collections, + }); + + let accounts = anchor_lang::ToAccountMetas::to_account_metas( + &gpl_core_attribute_voter::accounts::CreateRegistrar { + registrar: registrar_key, + realm: realm_cookie.address, + governance_program_id: self.governance.program_id, + governing_token_mint: realm_cookie.account.community_mint, + realm_authority: realm_cookie.get_realm_authority().pubkey(), + payer: self.bench.payer.pubkey(), + system_program: solana_sdk::system_program::id(), + }, + None, + ); + + let mut create_registrar_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts, + data, + }; + + instruction_override(&mut create_registrar_ix); + + let default_signers = &[&realm_cookie.realm_authority]; + let signers = signers_override.unwrap_or(default_signers); + + self.bench + .process_transaction(&[create_registrar_ix], Some(signers)) + .await?; + + let account = Registrar { + governance_program_id: self.governance.program_id, + realm: realm_cookie.address, + governing_token_mint: realm_cookie.account.community_mint, + collection_configs: vec![], + reserved: [0; 128], + }; + + Ok(RegistrarCookie { + address: registrar_key, + account, + realm_authority: realm_cookie.get_realm_authority(), + max_collections, + }) + } + + #[allow(dead_code)] + pub async fn with_voter_weight_record( + &self, + registrar_cookie: &RegistrarCookie, + voter_cookie: &WalletCookie, + ) -> Result { + self.with_voter_weight_record_using_ix(registrar_cookie, voter_cookie, NopOverride) + .await + } + + #[allow(dead_code)] + pub async fn with_voter_weight_record_using_ix( + &self, + registrar_cookie: &RegistrarCookie, + voter_cookie: &WalletCookie, + instruction_override: F, + ) -> Result { + let governing_token_owner = voter_cookie.address; + + let (voter_weight_record_key, _) = Pubkey::find_program_address( + &[ + b"voter-weight-record".as_ref(), + registrar_cookie.account.realm.as_ref(), + registrar_cookie.account.governing_token_mint.as_ref(), + governing_token_owner.as_ref(), + ], + &gpl_core_attribute_voter::id(), + ); + + let data = anchor_lang::InstructionData::data( + &gpl_core_attribute_voter::instruction::CreateVoterWeightRecord { + governing_token_owner, + }, + ); + + let accounts = gpl_core_attribute_voter::accounts::CreateVoterWeightRecord { + governance_program_id: self.governance.program_id, + realm: registrar_cookie.account.realm, + realm_governing_token_mint: registrar_cookie.account.governing_token_mint, + voter_weight_record: voter_weight_record_key, + payer: self.bench.payer.pubkey(), + system_program: solana_sdk::system_program::id(), + }; + + let mut create_voter_weight_record_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: anchor_lang::ToAccountMetas::to_account_metas(&accounts, None), + data, + }; + + instruction_override(&mut create_voter_weight_record_ix); + + self.bench + .process_transaction(&[create_voter_weight_record_ix], None) + .await?; + + let account = VoterWeightRecord { + realm: registrar_cookie.account.realm, + governing_token_mint: registrar_cookie.account.governing_token_mint, + governing_token_owner, + voter_weight: 0, + voter_weight_expiry: Some(0), + weight_action: None, + weight_action_target: None, + reserved: [0; 8], + }; + + Ok(VoterWeightRecordCookie { + address: voter_weight_record_key, + account, + }) + } + + #[allow(dead_code)] + pub async fn with_max_voter_weight_record( + &mut self, + registrar_cookie: &RegistrarCookie, + ) -> Result { + self.with_max_voter_weight_record_using_ix(registrar_cookie, NopOverride) + .await + } + + #[allow(dead_code)] + pub async fn with_max_voter_weight_record_using_ix( + &mut self, + registrar_cookie: &RegistrarCookie, + instruction_override: F, + ) -> Result { + let max_voter_weight_record_key = get_max_voter_weight_record_address( + ®istrar_cookie.account.realm, + ®istrar_cookie.account.governing_token_mint, + ); + + let data = anchor_lang::InstructionData::data( + &gpl_core_attribute_voter::instruction::CreateMaxVoterWeightRecord {}, + ); + + let accounts = gpl_core_attribute_voter::accounts::CreateMaxVoterWeightRecord { + governance_program_id: self.governance.program_id, + realm: registrar_cookie.account.realm, + realm_governing_token_mint: registrar_cookie.account.governing_token_mint, + max_voter_weight_record: max_voter_weight_record_key, + payer: self.bench.payer.pubkey(), + system_program: solana_sdk::system_program::id(), + }; + + let mut create_max_voter_weight_record_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: anchor_lang::ToAccountMetas::to_account_metas(&accounts, None), + data, + }; + + instruction_override(&mut create_max_voter_weight_record_ix); + + self.bench + .process_transaction(&[create_max_voter_weight_record_ix], None) + .await?; + + let account = MaxVoterWeightRecord { + realm: registrar_cookie.account.realm, + governing_token_mint: registrar_cookie.account.governing_token_mint, + max_voter_weight: 0, + max_voter_weight_expiry: Some(0), + reserved: [0; 8], + }; + + Ok(MaxVoterWeightRecordCookie { + account, + address: max_voter_weight_record_key, + }) + } + + #[allow(dead_code)] + pub async fn update_voter_weight_record( + &self, + registrar_cookie: &RegistrarCookie, + voter_weight_record_cookie: &mut VoterWeightRecordCookie, + voter_weight_action: VoterWeightAction, + asset_voter_cookie: &WalletCookie, + voter_token_owner_record_cookie: &TokenOwnerRecordCookie, + asset_cookies: &[&AssetCookie], + ) -> Result<(), BanksClientError> { + let data = anchor_lang::InstructionData::data( + &gpl_core_attribute_voter::instruction::UpdateVoterWeightRecord { + voter_weight_action, + }, + ); + + let accounts = gpl_core_attribute_voter::accounts::UpdateVoterWeightRecord { + registrar: registrar_cookie.address, + voter_weight_record: voter_weight_record_cookie.address, + voter_token_owner_record: voter_token_owner_record_cookie.address, + voter_authority: asset_voter_cookie.address, + }; + + let mut account_metas = anchor_lang::ToAccountMetas::to_account_metas(&accounts, None); + + for asset_cookie in asset_cookies { + account_metas.push(AccountMeta::new_readonly(asset_cookie.asset, false)); + } + + let instructions = vec![Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: account_metas, + data, + }]; + + self.bench + .process_transaction(&instructions, Some(&[&asset_voter_cookie.signer])) + .await + } + + #[allow(dead_code)] + pub async fn update_max_voter_weight_record( + &self, + registrar_cookie: &RegistrarCookie, + max_voter_weight_record_cookie: &mut MaxVoterWeightRecordCookie, + ) -> Result<(), BanksClientError> { + let data = anchor_lang::InstructionData::data( + &gpl_core_attribute_voter::instruction::UpdateMaxVoterWeightRecord {} + ); + + let accounts = gpl_core_attribute_voter::accounts::UpdateMaxVoterWeightRecord { + registrar: registrar_cookie.address, + max_voter_weight_record: max_voter_weight_record_cookie.address, + }; + + let account_metas = anchor_lang::ToAccountMetas::to_account_metas(&accounts, None); + + let instructions = vec![Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: account_metas, + data, + }]; + + self.bench.process_transaction(&instructions, None).await + } + + #[allow(dead_code)] + pub async fn relinquish_nft_vote( + &mut self, + registrar_cookie: &RegistrarCookie, + voter_weight_record_cookie: &VoterWeightRecordCookie, + proposal_cookie: &ProposalCookie, + voter_cookie: &WalletCookie, + voter_token_owner_record_cookie: &TokenOwnerRecordCookie, + asset_vote_record_cookies: &[AssetVoteRecordCookie], + ) -> Result<(), BanksClientError> { + let data = + anchor_lang::InstructionData::data(&gpl_core_attribute_voter::instruction::RelinquishNftVote {}); + + let vote_record_key = vote_record::get_vote_record_address( + &self.governance.program_id, + &proposal_cookie.address, + &voter_token_owner_record_cookie.address, + ); + + let accounts = gpl_core_attribute_voter::accounts::RelinquishNftVote { + registrar: registrar_cookie.address, + voter_weight_record: voter_weight_record_cookie.address, + governance: proposal_cookie.account.governance, + proposal: proposal_cookie.address, + vote_record: vote_record_key, + beneficiary: self.bench.payer.pubkey(), + voter_token_owner_record: voter_token_owner_record_cookie.address, + voter_authority: voter_cookie.address, + }; + + let mut account_metas = anchor_lang::ToAccountMetas::to_account_metas(&accounts, None); + + for asset_vote_record_cookie in asset_vote_record_cookies { + account_metas.push(AccountMeta::new(asset_vote_record_cookie.address, false)); + } + + let relinquish_nft_vote_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: account_metas, + data, + }; + + self.bench + .process_transaction(&[relinquish_nft_vote_ix], Some(&[&voter_cookie.signer])) + .await?; + + Ok(()) + } + + #[allow(dead_code)] + pub async fn with_collection( + &mut self, + registrar_cookie: &RegistrarCookie, + nft_collection_cookie: &CollectionCookie, + max_voter_weight_record_cookie: &MaxVoterWeightRecordCookie, + args: Option, + ) -> Result { + self.with_collection_using_ix( + registrar_cookie, + nft_collection_cookie, + max_voter_weight_record_cookie, + args, + NopOverride, + None, + ) + .await + } + + #[allow(dead_code)] + pub async fn with_collection_using_ix( + &mut self, + registrar_cookie: &RegistrarCookie, + collection_cookie: &CollectionCookie, + max_voter_weight_record_cookie: &MaxVoterWeightRecordCookie, + args: Option, + instruction_override: F, + signers_override: Option<&[&Keypair]>, + ) -> Result { + let args = args.unwrap_or_default(); + + let data = + anchor_lang::InstructionData::data(&gpl_core_attribute_voter::instruction::ConfigureCollection { + max_weight: args.max_weight, + weight_attribute_key: args.weight_attribute_key.clone(), + expected_attribute_authority: args.expected_attribute_authority.clone(), + }); + + let accounts = gpl_core_attribute_voter::accounts::ConfigureCollection { + registrar: registrar_cookie.address, + realm: registrar_cookie.account.realm, + realm_authority: registrar_cookie.realm_authority.pubkey(), + collection: collection_cookie.collection, + max_voter_weight_record: max_voter_weight_record_cookie.address, + }; + + let mut configure_collection_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: anchor_lang::ToAccountMetas::to_account_metas(&accounts, None), + data, + }; + + instruction_override(&mut configure_collection_ix); + + let default_signers = &[®istrar_cookie.realm_authority]; + let signers = signers_override.unwrap_or(default_signers); + + self.bench + .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, + reserved: [0; 8], + }; + + Ok(CollectionConfigCookie { collection_config }) + } + + /// Casts NFT Vote and spl-gov Vote + #[allow(dead_code)] + pub async fn cast_asset_vote( + &mut self, + registrar_cookie: &RegistrarCookie, + voter_weight_record_cookie: &VoterWeightRecordCookie, + max_voter_weight_record_cookie: &MaxVoterWeightRecordCookie, + proposal_cookie: &ProposalCookie, + asset_voter_cookie: &WalletCookie, + voter_token_owner_record_cookie: &TokenOwnerRecordCookie, + asset_cookies: &[&AssetCookie], + args: Option, + ) -> Result, BanksClientError> { + let args = args.unwrap_or_default(); + + let data = anchor_lang::InstructionData::data(&gpl_core_attribute_voter::instruction::CastNftVote {}); + + let accounts = gpl_core_attribute_voter::accounts::CastNftVote { + registrar: registrar_cookie.address, + voter_weight_record: voter_weight_record_cookie.address, + voter_token_owner_record: voter_token_owner_record_cookie.address, + voter_authority: asset_voter_cookie.address, + payer: self.bench.payer.pubkey(), + system_program: solana_sdk::system_program::id(), + proposal: proposal_cookie.address, + }; + + let mut account_metas = anchor_lang::ToAccountMetas::to_account_metas(&accounts, None); + let mut asset_vote_record_cookies = vec![]; + + for asset_cookie in asset_cookies { + account_metas.push(AccountMeta::new_readonly(asset_cookie.asset, false)); + + let nft_vote_record_key = + get_nft_vote_record_address(&proposal_cookie.address, &asset_cookie.asset); + account_metas.push(AccountMeta::new(nft_vote_record_key, false)); + + let account = AssetVoteRecord { + proposal: proposal_cookie.address, + asset_mint: asset_cookie.asset, + governing_token_owner: voter_weight_record_cookie.account.governing_token_owner, + account_discriminator: AssetVoteRecord::ACCOUNT_DISCRIMINATOR, + reserved: [0; 8], + }; + + asset_vote_record_cookies.push(AssetVoteRecordCookie { + address: nft_vote_record_key, + account, + }) + } + + let cast_nft_vote_ix = Instruction { + program_id: gpl_core_attribute_voter::id(), + accounts: account_metas, + data, + }; + + let mut instruction = vec![cast_nft_vote_ix]; + + if args.cast_spl_gov_vote { + // spl-gov cast vote + let vote = Vote::Approve(vec![VoteChoice { + rank: 0, + weight_percentage: 100, + }]); + + let cast_vote_ix = cast_vote( + &self.governance.program_id, + ®istrar_cookie.account.realm, + &proposal_cookie.account.governance, + &proposal_cookie.address, + &proposal_cookie.account.token_owner_record, + &voter_token_owner_record_cookie.address, + &asset_voter_cookie.address, + &proposal_cookie.account.governing_token_mint, + &self.bench.payer.pubkey(), + Some(voter_weight_record_cookie.address), + Some(max_voter_weight_record_cookie.address), + vote, + ); + + instruction.push(cast_vote_ix); + } + + self.bench + .process_transaction(&instruction, Some(&[&asset_voter_cookie.signer])) + .await?; + + Ok(asset_vote_record_cookies) + } + + #[allow(dead_code)] + pub async fn get_registrar_account(&mut self, registrar: &Pubkey) -> Registrar { + self.bench.get_anchor_account::(*registrar).await + } + + #[allow(dead_code)] + pub async fn get_asset_vote_record_account( + &mut self, + nft_vote_record: &Pubkey, + ) -> AssetVoteRecord { + self.bench + .get_borsh_account::(nft_vote_record) + .await + } + + #[allow(dead_code)] + pub async fn get_max_voter_weight_record( + &self, + max_voter_weight_record: &Pubkey, + ) -> MaxVoterWeightRecord { + self.bench + .get_anchor_account(*max_voter_weight_record) + .await + } + + #[allow(dead_code)] + pub async fn get_voter_weight_record(&self, voter_weight_record: &Pubkey) -> VoterWeightRecord { + self.bench.get_anchor_account(*voter_weight_record).await + } + + #[allow(dead_code)] + pub async fn get_collection_account(&self, voter_weight_record: &Pubkey) -> BaseCollectionV1 { + self.bench.get_anchor_account(*voter_weight_record).await + } +} diff --git a/programs/core-attribute-voter/tests/program_test/governance_test.rs b/programs/core-attribute-voter/tests/program_test/governance_test.rs new file mode 100644 index 0000000..d170d68 --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/governance_test.rs @@ -0,0 +1,435 @@ +use std::{str::FromStr, sync::Arc}; + +use anchor_lang::prelude::Pubkey; +use solana_program_test::ProgramTest; +use solana_sdk::{signature::Keypair, signer::Signer, transport::TransportError}; +use spl_governance::{ + instruction::{ + create_governance, create_proposal, create_realm, create_token_owner_record, + deposit_governing_tokens, relinquish_vote, set_governance_delegate, sign_off_proposal, + }, + state::{ + enums::{ + GovernanceAccountType, MintMaxVoterWeightSource, ProposalState, VoteThreshold, + VoteTipping, + }, + governance::get_governance_address, + proposal::{get_proposal_address, ProposalV2}, + realm::{get_realm_address, GoverningTokenConfigAccountArgs, RealmConfig, RealmV2}, + realm_config::GoverningTokenType, + token_owner_record::{ + get_token_owner_record_address, TokenOwnerRecordV2, TOKEN_OWNER_RECORD_LAYOUT_VERSION, + }, + }, +}; + +use crate::program_test::{ + program_test_bench::{MintCookie, ProgramTestBench, WalletCookie}, + tools::clone_keypair, +}; + +pub struct RealmCookie { + pub address: Pubkey, + pub account: RealmV2, + pub realm_authority: Keypair, + pub community_mint_cookie: MintCookie, + pub council_mint_cookie: Option, +} + +impl RealmCookie { + pub fn get_realm_authority(&self) -> Keypair { + clone_keypair(&self.realm_authority) + } +} + +pub struct ProposalCookie { + pub address: Pubkey, + pub account: ProposalV2, +} + +pub struct TokenOwnerRecordCookie { + pub address: Pubkey, + pub account: TokenOwnerRecordV2, +} + +pub struct GovernanceTest { + pub program_id: Pubkey, + pub bench: Arc, + pub next_id: u8, + pub community_voter_weight_addin: Option, + pub max_community_voter_weight_addin: Option, +} + +impl GovernanceTest { + pub fn program_id() -> Pubkey { + Pubkey::from_str("Governance111111111111111111111111111111111").unwrap() + } + + #[allow(dead_code)] + pub fn add_program(program_test: &mut ProgramTest) { + program_test.add_program("spl_governance", Self::program_id(), None); + } + + #[allow(dead_code)] + pub fn new( + bench: Arc, + community_voter_weight_addin: Option, + max_community_voter_weight_addin: Option, + ) -> Self { + GovernanceTest { + bench, + program_id: Self::program_id(), + next_id: 0, + community_voter_weight_addin, + max_community_voter_weight_addin, + } + } + + #[allow(dead_code)] + pub async fn with_realm(&mut self) -> Result { + let realm_authority = Keypair::new(); + + let community_mint_cookie = self.bench.with_mint().await?; + let council_mint_cookie = self.bench.with_mint().await?; + + self.next_id += 1; + let realm_name = format!("Realm #{}", self.next_id).to_string(); + + let min_community_weight_to_create_governance = 1; + let community_mint_max_voter_weight_source = MintMaxVoterWeightSource::FULL_SUPPLY_FRACTION; + + let realm_key = get_realm_address(&self.program_id, &realm_name); + + let community_token_config_args = GoverningTokenConfigAccountArgs { + voter_weight_addin: self.community_voter_weight_addin, + max_voter_weight_addin: self.max_community_voter_weight_addin, + token_type: GoverningTokenType::default(), + }; + + let create_realm_ix = create_realm( + &self.program_id, + &realm_authority.pubkey(), + &community_mint_cookie.address, + &self.bench.payer.pubkey(), + Some(council_mint_cookie.address), + Some(community_token_config_args), + None, + realm_name.clone(), + min_community_weight_to_create_governance, + community_mint_max_voter_weight_source.clone(), + false, + false, + ); + + self.bench + .process_transaction(&[create_realm_ix], None) + .await?; + + let account = RealmV2 { + account_type: GovernanceAccountType::RealmV2, + community_mint: community_mint_cookie.address, + + name: realm_name, + reserved: [0; 6], + authority: Some(realm_authority.pubkey()), + config: RealmConfig { + council_mint: Some(council_mint_cookie.address), + reserved: [0; 6], + min_community_weight_to_create_governance, + community_mint_max_voter_weight_source, + legacy1: 0, + legacy2: 0, + }, + reserved_v2: [0; 128], + legacy1: 0, + }; + + Ok(RealmCookie { + address: realm_key, + account, + realm_authority, + community_mint_cookie, + council_mint_cookie: Some(council_mint_cookie), + }) + } + + #[allow(dead_code)] + pub async fn with_proposal( + &mut self, + realm_cookie: &RealmCookie, + ) -> Result { + let token_account_cookie = self + .bench + .with_token_account(&realm_cookie.account.community_mint) + .await?; + + let token_owner = self.bench.payer.pubkey(); + let council_mint_cookie = realm_cookie.council_mint_cookie.as_ref().unwrap(); + let governing_token_mint = council_mint_cookie.address; + + let governing_token_account_cookie = self + .bench + .with_tokens(council_mint_cookie, &token_owner, 1) + .await?; + + let proposal_owner_record_key = get_token_owner_record_address( + &self.program_id, + &realm_cookie.address, + &governing_token_mint, + &token_owner, + ); + + let create_tor_ix = create_token_owner_record( + &self.program_id, + &realm_cookie.address, + &self.bench.payer.pubkey(), + &governing_token_mint, + &self.bench.payer.pubkey(), + ); + + self.bench + .process_transaction(&[create_tor_ix], None) + .await?; + + let deposit_ix = deposit_governing_tokens( + &self.program_id, + &realm_cookie.address, + &governing_token_account_cookie.address, + &token_owner, + &token_owner, + &self.bench.payer.pubkey(), + 1, + &governing_token_mint, + false, + ); + + self.bench.process_transaction(&[deposit_ix], None).await?; + + let governance_key = get_governance_address( + &self.program_id, + &realm_cookie.address, + &token_account_cookie.address, + ); + + let create_governance_ix = create_governance( + &self.program_id, + &realm_cookie.address, + Some(&token_account_cookie.address), + &proposal_owner_record_key, + &self.bench.payer.pubkey(), + &realm_cookie.realm_authority.pubkey(), + None, + spl_governance::state::governance::GovernanceConfig { + min_community_weight_to_create_proposal: 1, + min_transaction_hold_up_time: 0, + + min_council_weight_to_create_proposal: 1, + community_vote_threshold: VoteThreshold::YesVotePercentage(60), + voting_base_time: 600, + community_vote_tipping: VoteTipping::Strict, + council_vote_threshold: VoteThreshold::YesVotePercentage(60), + council_veto_vote_threshold: VoteThreshold::Disabled, + council_vote_tipping: VoteTipping::Disabled, + community_veto_vote_threshold: VoteThreshold::Disabled, + voting_cool_off_time: 0, + deposit_exempt_proposal_count: 10, + }, + ); + + self.bench + .process_transaction( + &[create_governance_ix], + Some(&[&realm_cookie.realm_authority]), + ) + .await?; + + let proposal_governing_token_mint = realm_cookie.account.community_mint; + let proposal_seed = Pubkey::new_unique(); + + let proposal_key = get_proposal_address( + &self.program_id, + &governance_key, + &proposal_governing_token_mint, + &proposal_seed, + ); + + let create_proposal_ix = create_proposal( + &self.program_id, + &governance_key, + &proposal_owner_record_key, + &token_owner, + &self.bench.payer.pubkey(), + None, + &realm_cookie.address, + String::from("Proposal #1"), + String::from("Proposal #1 link"), + &proposal_governing_token_mint, + spl_governance::state::proposal::VoteType::SingleChoice, + vec!["Yes".to_string()], + true, + &proposal_seed, + ); + + let sign_off_proposal_ix = sign_off_proposal( + &self.program_id, + &realm_cookie.address, + &governance_key, + &proposal_key, + &token_owner, + Some(&proposal_owner_record_key), + ); + + self.bench + .process_transaction(&[create_proposal_ix, sign_off_proposal_ix], None) + .await?; + + let account = ProposalV2 { + account_type: GovernanceAccountType::GovernanceV2, + governing_token_mint: proposal_governing_token_mint, + state: ProposalState::Voting, + governance: governance_key, + token_owner_record: proposal_owner_record_key, + signatories_count: 1, + signatories_signed_off_count: 1, + vote_type: spl_governance::state::proposal::VoteType::SingleChoice, + options: vec![], + deny_vote_weight: Some(1), + veto_vote_weight: 0, + abstain_vote_weight: None, + start_voting_at: None, + draft_at: 1, + signing_off_at: None, + voting_at: None, + voting_at_slot: None, + voting_completed_at: None, + executing_at: None, + closed_at: None, + execution_flags: spl_governance::state::enums::InstructionExecutionFlags::None, + max_vote_weight: None, + max_voting_time: None, + reserved: [0; 64], + name: String::from("Proposal #1"), + description_link: String::from("Proposal #1 link"), + reserved1: 0, + vote_threshold: None, + }; + + Ok(ProposalCookie { + address: proposal_key, + account, + }) + } + + #[allow(dead_code)] + pub async fn with_token_owner_record( + &mut self, + realm_cookie: &RealmCookie, + token_owner_cookie: &WalletCookie, + ) -> Result { + let token_owner_record_key = get_token_owner_record_address( + &self.program_id, + &realm_cookie.address, + &realm_cookie.account.community_mint, + &token_owner_cookie.address, + ); + + let create_tor_ix = create_token_owner_record( + &self.program_id, + &realm_cookie.address, + &token_owner_cookie.address, + &realm_cookie.account.community_mint, + &self.bench.payer.pubkey(), + ); + + self.bench + .process_transaction(&[create_tor_ix], None) + .await?; + + let account = TokenOwnerRecordV2 { + account_type: GovernanceAccountType::TokenOwnerRecordV2, + realm: realm_cookie.address, + governing_token_mint: realm_cookie.account.community_mint, + governing_token_owner: token_owner_cookie.address, + governing_token_deposit_amount: 0, + unrelinquished_votes_count: 0, + outstanding_proposal_count: 0, + reserved: [0; 6], + governance_delegate: None, + reserved_v2: [0; 128], + version: TOKEN_OWNER_RECORD_LAYOUT_VERSION, + }; + + Ok(TokenOwnerRecordCookie { + address: token_owner_record_key, + account, + }) + } + + #[allow(dead_code)] + pub async fn relinquish_vote( + &mut self, + proposal_cookie: &ProposalCookie, + token_owner_cookie: &WalletCookie, + token_owner_record_cookie: &TokenOwnerRecordCookie, + ) -> Result<(), TransportError> { + let relinquish_vote_ix = relinquish_vote( + &self.program_id, + &token_owner_record_cookie.account.realm, + &proposal_cookie.account.governance, + &proposal_cookie.address, + &token_owner_record_cookie.address, + &proposal_cookie.account.governing_token_mint, + Some(token_owner_record_cookie.account.governing_token_owner), + Some(self.bench.payer.pubkey()), + ); + + self.bench + .process_transaction(&[relinquish_vote_ix], Some(&[&token_owner_cookie.signer])) + .await?; + + Ok(()) + } + + #[allow(dead_code)] + pub async fn set_governance_delegate( + &mut self, + realm_cookie: &RealmCookie, + token_owner_record_cookie: &TokenOwnerRecordCookie, + token_owner_authority_cookie: &WalletCookie, + new_governance_delegate: &Option, + ) { + let set_governance_delegate_ix = set_governance_delegate( + &self.program_id, + &token_owner_authority_cookie.address, + &realm_cookie.address, + &token_owner_record_cookie.account.governing_token_mint, + &token_owner_record_cookie.account.governing_token_owner, + new_governance_delegate, + ); + + self.bench + .process_transaction( + &[set_governance_delegate_ix], + Some(&[&token_owner_authority_cookie.signer]), + ) + .await + .unwrap(); + } + + #[allow(dead_code)] + pub async fn get_proposal(&mut self, proposal_key: &Pubkey) -> ProposalV2 { + self.bench + .get_borsh_account::(proposal_key) + .await + } + + #[allow(dead_code)] + pub async fn get_token_owner_record( + &mut self, + token_owner_record_key: &Pubkey, + ) -> TokenOwnerRecordV2 { + self.bench + .get_borsh_account::(token_owner_record_key) + .await + } +} diff --git a/programs/core-attribute-voter/tests/program_test/mod.rs b/programs/core-attribute-voter/tests/program_test/mod.rs new file mode 100644 index 0000000..bfe2667 --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/mod.rs @@ -0,0 +1,5 @@ +pub mod governance_test; +pub mod core_voter_test; +pub mod program_test_bench; +pub mod core_test; +pub mod tools; diff --git a/programs/core-attribute-voter/tests/program_test/program_test_bench.rs b/programs/core-attribute-voter/tests/program_test/program_test_bench.rs new file mode 100644 index 0000000..27ee7dd --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/program_test_bench.rs @@ -0,0 +1,326 @@ +use std::cell::RefCell; + +use anchor_lang::{ + prelude::{Pubkey, Rent}, + AccountDeserialize, +}; + +use solana_program::system_program; +use solana_program_test::{BanksClientError, ProgramTest, ProgramTestContext}; +use solana_sdk::{ + account::{Account, ReadableAccount}, + instruction::Instruction, + program_pack::Pack, + signature::Keypair, + signer::Signer, + system_instruction, + transaction::Transaction, + transport::TransportError, +}; + +use crate::program_test::tools::clone_keypair; + +pub struct MintCookie { + pub address: Pubkey, + pub mint_authority: Keypair, + pub freeze_authority: Option, +} +pub struct TokenAccountCookie { + pub address: Pubkey, +} + +#[derive(Debug)] +pub struct WalletCookie { + pub address: Pubkey, + pub account: Account, + + pub signer: Keypair, +} + +pub struct ProgramTestBench { + pub context: RefCell, + pub payer: Keypair, + pub rent: Rent, +} + +impl ProgramTestBench { + /// Create new bench given a ProgramTest instance populated with all of the + /// desired programs. + pub async fn start_new(program_test: ProgramTest) -> Self { + let mut context = program_test.start_with_context().await; + + let payer = clone_keypair(&context.payer); + + let rent = context.banks_client.get_rent().await.unwrap(); + + Self { + payer, + context: RefCell::new(context), + rent, + } + } + + #[allow(dead_code)] + pub async fn process_transaction( + &self, + instructions: &[Instruction], + signers: Option<&[&Keypair]>, + ) -> Result<(), BanksClientError> { + let mut context = self.context.borrow_mut(); + + let mut transaction = + Transaction::new_with_payer(&instructions, Some(&context.payer.pubkey())); + + let mut all_signers = vec![&context.payer]; + + if let Some(signers) = signers { + all_signers.extend_from_slice(signers); + } + + transaction.sign(&all_signers, context.last_blockhash); + + context + .banks_client + .process_transaction_with_commitment( + transaction, + solana_sdk::commitment_config::CommitmentLevel::Processed, + ) + .await + } + + pub async fn get_clock(&self) -> solana_program::clock::Clock { + self.context + .borrow_mut() + .banks_client + .get_sysvar::() + .await + .unwrap() + } + + #[allow(dead_code)] + pub async fn advance_clock(&self) { + let clock = self.get_clock().await; + self.context + .borrow_mut() + .warp_to_slot(clock.slot + 2) + .unwrap(); + } + + pub async fn with_mint(&self) -> Result { + let mint_keypair = Keypair::new(); + let mint_authority = Keypair::new(); + let freeze_authority = clone_keypair(&mint_authority); + + self.create_mint( + &mint_keypair, + &mint_authority.pubkey(), + Some(&freeze_authority.pubkey()), + ) + .await?; + + Ok(MintCookie { + address: mint_keypair.pubkey(), + mint_authority, + freeze_authority: Some(freeze_authority), + }) + } + + #[allow(dead_code)] + pub async fn create_mint( + &self, + mint_keypair: &Keypair, + mint_authority: &Pubkey, + freeze_authority: Option<&Pubkey>, + ) -> Result<(), BanksClientError> { + let mint_rent = self.rent.minimum_balance(spl_token::state::Mint::LEN); + + let instructions = [ + system_instruction::create_account( + &self.context.borrow().payer.pubkey(), + &mint_keypair.pubkey(), + mint_rent, + spl_token::state::Mint::LEN as u64, + &spl_token::id(), + ), + spl_token::instruction::initialize_mint( + &spl_token::id(), + &mint_keypair.pubkey(), + mint_authority, + freeze_authority, + 0, + ) + .unwrap(), + ]; + + self.process_transaction(&instructions, Some(&[mint_keypair])) + .await + } + + #[allow(dead_code)] + pub async fn with_token_account( + &self, + token_mint: &Pubkey, + ) -> Result { + let token_account_keypair = Keypair::new(); + self.create_token_account(&token_account_keypair, token_mint, &self.payer.pubkey()) + .await?; + + Ok(TokenAccountCookie { + address: token_account_keypair.pubkey(), + }) + } + + #[allow(dead_code)] + pub async fn with_tokens( + &self, + mint_cookie: &MintCookie, + owner: &Pubkey, + amount: u64, + ) -> Result { + let token_account_keypair = Keypair::new(); + + self.create_token_account(&token_account_keypair, &mint_cookie.address, owner) + .await?; + + self.mint_tokens( + &mint_cookie.address, + &mint_cookie.mint_authority, + &token_account_keypair.pubkey(), + amount, + ) + .await?; + + Ok(TokenAccountCookie { + address: token_account_keypair.pubkey(), + }) + } + + pub async fn mint_tokens( + &self, + token_mint: &Pubkey, + token_mint_authority: &Keypair, + token_account: &Pubkey, + amount: u64, + ) -> Result<(), BanksClientError> { + let mint_instruction = spl_token::instruction::mint_to( + &spl_token::id(), + token_mint, + token_account, + &token_mint_authority.pubkey(), + &[], + amount, + ) + .unwrap(); + + self.process_transaction(&[mint_instruction], Some(&[token_mint_authority])) + .await + } + + #[allow(dead_code)] + pub async fn create_token_account( + &self, + token_account_keypair: &Keypair, + token_mint: &Pubkey, + owner: &Pubkey, + ) -> Result<(), BanksClientError> { + let rent = self + .context + .borrow_mut() + .banks_client + .get_rent() + .await + .unwrap(); + + let create_account_instruction = system_instruction::create_account( + &self.context.borrow().payer.pubkey(), + &token_account_keypair.pubkey(), + rent.minimum_balance(spl_token::state::Account::get_packed_len()), + spl_token::state::Account::get_packed_len() as u64, + &spl_token::id(), + ); + + let initialize_account_instruction = spl_token::instruction::initialize_account( + &spl_token::id(), + &token_account_keypair.pubkey(), + token_mint, + owner, + ) + .unwrap(); + + self.process_transaction( + &[create_account_instruction, initialize_account_instruction], + Some(&[token_account_keypair]), + ) + .await + } + + #[allow(dead_code)] + pub async fn with_wallet(&self) -> WalletCookie { + let account_rent = self.rent.minimum_balance(0); + let account_keypair = Keypair::new(); + + let create_account_ix = system_instruction::create_account( + &self.context.borrow().payer.pubkey(), + &account_keypair.pubkey(), + account_rent, + 0, + &system_program::id(), + ); + + self.process_transaction(&[create_account_ix], Some(&[&account_keypair])) + .await + .unwrap(); + + let account = Account { + lamports: account_rent, + data: vec![], + owner: system_program::id(), + executable: false, + rent_epoch: 0, + }; + + WalletCookie { + address: account_keypair.pubkey(), + account, + signer: account_keypair, + } + } + + #[allow(dead_code)] + pub async fn get_account(&self, address: &Pubkey) -> Option { + self.context + .borrow_mut() + .banks_client + .get_account(*address) + .await + .unwrap() + } + + #[allow(dead_code)] + pub async fn get_borsh_account(&self, address: &Pubkey) -> T { + self.get_account(address) + .await + .map(|a| borsh_1::BorshDeserialize::deserialize(&mut a.data.as_slice()).unwrap()) + .unwrap_or_else(|| panic!("GET-TEST-ACCOUNT-ERROR: Account {} not found", address)) + } + + #[allow(dead_code)] + pub async fn get_account_data(&self, address: Pubkey) -> Vec { + self.context + .borrow_mut() + .banks_client + .get_account(address) + .await + .unwrap() + .unwrap() + .data() + .to_vec() + } + + #[allow(dead_code)] + pub async fn get_anchor_account(&self, address: Pubkey) -> T { + let data = self.get_account_data(address).await; + let mut data_slice: &[u8] = &data; + AccountDeserialize::try_deserialize(&mut data_slice).unwrap() + } +} diff --git a/programs/core-attribute-voter/tests/program_test/tools.rs b/programs/core-attribute-voter/tests/program_test/tools.rs new file mode 100644 index 0000000..9896c1e --- /dev/null +++ b/programs/core-attribute-voter/tests/program_test/tools.rs @@ -0,0 +1,98 @@ +use anchor_lang::prelude::ERROR_CODE_OFFSET; +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use solana_program::instruction::InstructionError; +use solana_program_test::BanksClientError; +use solana_sdk::{signature::Keypair, transaction::TransactionError, transport::TransportError}; +use spl_governance::error::GovernanceError; +use spl_governance_tools::error::GovernanceToolsError; + +pub fn clone_keypair(source: &Keypair) -> Keypair { + Keypair::from_bytes(&source.to_bytes()).unwrap() +} + +/// NOP (No Operation) Override function +#[allow(non_snake_case)] +pub fn NopOverride(_: &mut T) {} + +#[allow(dead_code)] +pub fn assert_nft_voter_err(banks_client_error: BanksClientError, nft_locker_error: CoreNftAttributeVoterError) { + let tx_error = banks_client_error.unwrap(); + + println!("banks client error: {:?}", tx_error); + println!("nft locker error: {:?}", nft_locker_error); + println!("error code offset: {:?}", ERROR_CODE_OFFSET); + println!("nft locker error as u32: {:?}", nft_locker_error as u32 + ERROR_CODE_OFFSET); + + match tx_error { + TransactionError::InstructionError(_, instruction_error) => match instruction_error { + InstructionError::Custom(e) => { + assert_eq!(e, nft_locker_error as u32 + ERROR_CODE_OFFSET) + } + _ => panic!("{:?} Is not InstructionError::Custom()", instruction_error), + }, + _ => panic!("{:?} Is not InstructionError", tx_error), + }; +} + +#[allow(dead_code)] +pub fn assert_gov_tools_err( + banks_client_error: TransportError, + gov_tools_error: GovernanceToolsError, +) { + let tx_error = banks_client_error.unwrap(); + + match tx_error { + TransactionError::InstructionError(_, instruction_error) => match instruction_error { + InstructionError::Custom(e) => { + assert_eq!(e, gov_tools_error as u32) + } + _ => panic!("{:?} Is not InstructionError::Custom()", instruction_error), + }, + _ => panic!("{:?} Is not InstructionError", tx_error), + }; +} + +#[allow(dead_code)] +pub fn assert_gov_err(banks_client_error: BanksClientError, gov_error: GovernanceError) { + let tx_error = banks_client_error.unwrap(); + + match tx_error { + TransactionError::InstructionError(_, instruction_error) => match instruction_error { + InstructionError::Custom(e) => { + assert_eq!(e, gov_error as u32) + } + _ => panic!("{:?} Is not InstructionError::Custom()", instruction_error), + }, + _ => panic!("{:?} Is not InstructionError", tx_error), + }; +} + +#[allow(dead_code)] +pub fn assert_anchor_err( + banks_client_error: BanksClientError, + anchor_error: anchor_lang::error::ErrorCode, +) { + let tx_error = banks_client_error.unwrap(); + + match tx_error { + TransactionError::InstructionError(_, instruction_error) => match instruction_error { + InstructionError::Custom(e) => { + assert_eq!(e, anchor_error as u32) + } + _ => panic!("{:?} Is not InstructionError::Custom()", instruction_error), + }, + _ => panic!("{:?} Is not InstructionError", tx_error), + }; +} + +#[allow(dead_code)] +pub fn assert_ix_err(banks_client_error: BanksClientError, ix_error: InstructionError) { + let tx_error = banks_client_error.unwrap(); + + match tx_error { + TransactionError::InstructionError(_, instruction_error) => { + assert_eq!(instruction_error, ix_error); + } + _ => panic!("{:?} Is not InstructionError", tx_error), + }; +} diff --git a/programs/core-attribute-voter/tests/relinquish_nft_vote.rs b/programs/core-attribute-voter/tests/relinquish_nft_vote.rs new file mode 100644 index 0000000..94f56d4 --- /dev/null +++ b/programs/core-attribute-voter/tests/relinquish_nft_vote.rs @@ -0,0 +1,670 @@ +use crate::program_test::core_voter_test::ConfigureCollectionArgs; +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use program_test::core_voter_test::{CastAssetVoteArgs, CoreVoterTest}; +use program_test::tools::{assert_gov_err, assert_nft_voter_err}; +use solana_program_test::*; +use solana_sdk::transport::TransportError; +use spl_governance::error::GovernanceError; + +mod program_test; + +#[tokio::test] +async fn test_relinquish_nft_vote() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_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 + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight_expiry, Some(0)); + assert_eq!(voter_weight_record.voter_weight, 0); + + // Check NftVoteRecord was disposed + let asset_vote_record = core_voter_test + .bench + .get_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(None, asset_vote_record); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_for_proposal_in_voting_state() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Relinquish Vote from spl-gov + core_voter_test + .governance + .relinquish_vote( + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + ) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Act + core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await?; + + // Assert + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight_expiry, Some(0)); + assert_eq!(voter_weight_record.voter_weight, 0); + + // Check NftVoteRecord was disposed + let asset_vote_record = core_voter_test + .bench + .get_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(None, asset_vote_record); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_for_proposal_in_voting_state_and_vote_record_exists_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(5)).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + // Create and store 6th asset. This will be used for the vote. + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None + + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Act + let err = core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await + .err() + .unwrap(); + + println!("{:?}", err); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::VoteRecordMustBeWithdrawn); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_with_invalid_voter_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_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 + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Try to use a different voter + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + + // Act + + let err = core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie2, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_gov_err(err, GovernanceError::GoverningTokenOwnerOrDelegateMustSign); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_with_unexpired_vote_weight_record() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 10, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: 10, + ..Default::default() + }), + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let args = CastAssetVoteArgs { + cast_spl_gov_vote: false, + }; + + // Cast vote with NFT + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + Some(args), + ) + .await?; + + // Act + + let err = core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::VoterWeightRecordMustBeExpired); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_with_invalid_voter_weight_token_owner_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + // Try to update VoterWeightRecord for different governing_token_owner + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + let voter_weight_record_cookie2 = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie2) + .await?; + + // Act + + let err = core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie2, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidTokenOwnerForVoterWeightRecord); + + Ok(()) +} + +#[tokio::test] +async fn test_relinquish_nft_vote_using_delegate() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core.create_asset_with_weight( + &collection_cookie, + &voter_cookie, + 1, + ) + .await?; + + core_voter_test + .with_collection( + ®istrar_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 + ) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let proposal_cookie = core_voter_test + .governance + .with_proposal(&realm_cookie) + .await?; + + let asset_vote_record_cookies = core_voter_test + .cast_asset_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &max_voter_weight_record_cookie, + &proposal_cookie, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + None, + ) + .await?; + + core_voter_test.bench.advance_clock().await; + + // Setup delegate + let delegate_cookie = core_voter_test.bench.with_wallet().await; + core_voter_test + .governance + .set_governance_delegate( + &realm_cookie, + &voter_token_owner_record_cookie, + &voter_cookie, + &Some(delegate_cookie.address), + ) + .await; + + // Act + + core_voter_test + .relinquish_nft_vote( + ®istrar_cookie, + &voter_weight_record_cookie, + &proposal_cookie, + &delegate_cookie, + &voter_token_owner_record_cookie, + &asset_vote_record_cookies, + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight_expiry, Some(0)); + assert_eq!(voter_weight_record.voter_weight, 0); + + // Check NftVoteRecord was disposed + let asset_vote_record = core_voter_test + .bench + .get_account(&asset_vote_record_cookies[0].address) + .await; + + assert_eq!(None, asset_vote_record); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs b/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs new file mode 100644 index 0000000..6511051 --- /dev/null +++ b/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs @@ -0,0 +1,192 @@ +use crate::program_test::core_voter_test::ConfigureCollectionArgs; +use program_test::core_voter_test::CoreVoterTest; +use solana_program_test::*; +use solana_sdk::transport::TransportError; + +mod program_test; + +#[tokio::test] +async fn test_update_collection_config_invalidates_max_voter_weight_record_expirey( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let _voter_cookie = core_voter_test.bench.with_wallet().await; + + let mut max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let collection_1_size = 7; + let collection_1_weight = 5; + + let collection_cookie_1 = core_voter_test + .core + .create_collection(Some(collection_1_size)) + .await?; + + // Register collection_1 to registrar + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie_1, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: collection_1_weight, + ..Default::default() + }), + ) + .await?; + + // Generate an updated new max voter weight record + core_voter_test + .update_max_voter_weight_record(®istrar_cookie, &mut max_voter_weight_record_cookie) + .await?; + + let collection_2_size = 10; + let collection_2_weight = 2; + + // Generate a new collection and update the registrar with the additional collection + // while invalidating max voter weight. + let collection_cookie_2 = core_voter_test + .core + .create_collection(Some(collection_2_size)) + .await?; + + // Register collection_2 to registrar + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie_2, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: collection_2_weight, + ..Default::default() + }), + ) + .await?; + + // Fetch registrar account and assert that collection was added to the registrars collection_configs + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + core_voter_test.bench.advance_clock().await; + 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); + + assert!(registrar.collection_configs.len() == 2); + assert!(max_voter_weight_record.max_voter_weight_expiry.is_none()); + assert!(max_voter_weight_record.max_voter_weight == max_voter_weight_total as u64); + + Ok(()) +} + +#[tokio::test] +async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result<(), TransportError> +{ + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let mut max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let _voter_cookie = core_voter_test.bench.with_wallet().await; + + // Set collection sizes and weights for collection_1 + let collection_1_size = 11; + let collection_1_weight = 4; + + let collection_cookie_1 = core_voter_test + .core + .create_collection(Some(collection_1_size)) + .await?; + + // Register collection_1 to registrar + let _collection_config_cookie = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie_1, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: collection_1_weight, + ..Default::default() + }), + ) + .await?; + + // Generate an updated new max voter weight record + core_voter_test + .update_max_voter_weight_record(®istrar_cookie, &mut max_voter_weight_record_cookie) + .await?; + + // Advance clock so that second `update_max_voter_weight_record`` can be made without a duplicate + // transaction submission which causes transaction to "pass" but not actually update the account. + + core_voter_test.bench.advance_clock().await; + let _clock = core_voter_test.bench.get_clock().await; + + // Generate a new collection and update the registrar with the additional collection + // which also invalidates max_voter_weight_expirey. + + let collection_2_size = 9; + let collection_2_weight = 3; + let collection_cookie_2 = core_voter_test + .core + .create_collection(Some(collection_2_size)) + .await?; + + // Register collection_2 to registrar + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie_2, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + max_weight: collection_2_weight, + ..Default::default() + }), + ) + .await?; + + // Revalidate max voter weight record by calling the update + let _update_max_voter_weight_record_2 = core_voter_test + .update_max_voter_weight_record(®istrar_cookie, &mut max_voter_weight_record_cookie) + .await?; + + // Fetch registrar account and assert that collection was added to the registrars collection_configs + let registrar = core_voter_test + .get_registrar_account(®istrar_cookie.address) + .await; + + // Fetch max voter weight record and assert that max voter weight expiry is set + let max_voter_weight_record = core_voter_test + .get_max_voter_weight_record(&max_voter_weight_record_cookie.address) + .await; + + // Assert + let max_voter_weight_total = + (collection_1_weight * collection_1_size) + (collection_2_weight * collection_2_size); + + assert!(registrar.collection_configs.len() == 2); + assert!(max_voter_weight_record.max_voter_weight == max_voter_weight_total as u64); + assert!(max_voter_weight_record.max_voter_weight_expiry.is_some()); + + Ok(()) +} diff --git a/programs/core-attribute-voter/tests/update_voter_weight_record.rs b/programs/core-attribute-voter/tests/update_voter_weight_record.rs new file mode 100644 index 0000000..17162ae --- /dev/null +++ b/programs/core-attribute-voter/tests/update_voter_weight_record.rs @@ -0,0 +1,414 @@ +use crate::program_test::core_voter_test::ConfigureCollectionArgs; +use gpl_core_attribute_voter::error::CoreNftAttributeVoterError; +use gpl_core_attribute_voter::state::*; +use program_test::core_voter_test::CoreVoterTest; +use program_test::tools::*; +use solana_program_test::*; +use solana_sdk::msg; +use solana_sdk::transport::TransportError; + +mod program_test; + +#[tokio::test] +async fn test_update_voter_weight_record() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + msg!("Register the collection to the registrar"); + // Register the collection to the registrar + let _collection_config_cookie = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 10, ..Default::default() }), + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + // Act + core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CreateProposal, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1] + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 10); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CreateProposal.into()) + ); + assert_eq!(voter_weight_record.weight_action_target, None); + + Ok(()) +} + +#[tokio::test] +async fn test_update_voter_weight_with_multiple_nfts() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + let asset_cookie2 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + let _collection_config_cookie = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 10, ..Default::default() }), + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + core_voter_test.bench.advance_clock().await; + let clock = core_voter_test.bench.get_clock().await; + + // Act + core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CreateProposal, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1, &asset_cookie2], + ) + .await?; + + // Assert + + let voter_weight_record = core_voter_test + .get_voter_weight_record(&voter_weight_record_cookie.address) + .await; + + assert_eq!(voter_weight_record.voter_weight, 20); + assert_eq!(voter_weight_record.voter_weight_expiry, Some(clock.slot)); + assert_eq!( + voter_weight_record.weight_action, + Some(VoterWeightAction::CreateProposal.into()) + ); + assert_eq!(voter_weight_record.weight_action_target, None); + + Ok(()) +} + +#[tokio::test] +async fn test_update_voter_weight_with_cast_vote_not_allowed_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 10, ..Default::default() }), + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CastVote, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::CastVoteIsNotAllowed); + + Ok(()) +} + +#[tokio::test] +async fn test_update_voter_weight_with_invalid_owner_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let voter_cookie2 = core_voter_test.bench.with_wallet().await; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie2, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 10, ..Default::default() }), + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CreateGovernance, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::VoterDoesNotOwnNft); + + Ok(()) +} + +#[tokio::test] +async fn test_update_voter_weight_with_invalid_collection_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let collection_cookie2 = core_voter_test.core.create_collection(None).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + let dummy_wallet = core_voter_test.bench.with_wallet().await; + + // Create a dummy asset in collection_cookie so it has size > 0 (required by configure_collection) + let _dummy_asset_cookie = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &dummy_wallet, 10) + .await?; + + let asset_cookie1 = core_voter_test + .core + .create_asset_with_weight(&collection_cookie2, &voter_cookie, 10) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { max_weight: 10, ..Default::default() }), + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CreateGovernance, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie1], + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::CollectionNotFound); + + Ok(()) +} + +#[tokio::test] +async fn test_update_voter_weight_with_same_nft_error() -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(None).await?; + + let voter_cookie = core_voter_test.bench.with_wallet().await; + + let asset_cookie = core_voter_test + .core + .create_asset_with_weight(&collection_cookie, &voter_cookie, 1) + .await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + None, + ) + .await?; + + let mut voter_weight_record_cookie = core_voter_test + .with_voter_weight_record(®istrar_cookie, &voter_cookie) + .await?; + + let voter_token_owner_record_cookie = core_voter_test + .governance + .with_token_owner_record(&realm_cookie, &voter_cookie) + .await?; + + // Act + let err = core_voter_test + .update_voter_weight_record( + ®istrar_cookie, + &mut voter_weight_record_cookie, + VoterWeightAction::CreateProposal, + &voter_cookie, + &voter_token_owner_record_cookie, + &[&asset_cookie, &asset_cookie], + ) + .await + .err() + .unwrap(); + + // Assert + + assert_nft_voter_err(err, CoreNftAttributeVoterError::DuplicatedNftDetected); + + Ok(()) +} From 71aabfecccc7b9a7da059f907b5ac6170c107496 Mon Sep 17 00:00:00 2001 From: crypt0miester Date: Thu, 5 Mar 2026 23:59:38 +0400 Subject: [PATCH 2/3] fix size in collection config --- programs/core-attribute-voter/README.md | 37 +++++++++++++++++-- programs/core-attribute-voter/src/error.rs | 4 +- .../src/instructions/configure_collection.rs | 19 ++++------ .../src/state/collection_config.rs | 22 ++++------- .../src/state/registrar.rs | 3 +- .../tests/configure_collection.rs | 9 ++--- .../tests/program_test/core_voter_test.rs | 5 --- .../tests/relinquish_nft_vote.rs | 11 ++---- .../tests/update_max_voter_weight_record.rs | 6 +-- 9 files changed, 61 insertions(+), 55 deletions(-) diff --git a/programs/core-attribute-voter/README.md b/programs/core-attribute-voter/README.md index 186d216..4d643a4 100644 --- a/programs/core-attribute-voter/README.md +++ b/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 | diff --git a/programs/core-attribute-voter/src/error.rs b/programs/core-attribute-voter/src/error.rs index 6f3303d..dcd318e 100644 --- a/programs/core-attribute-voter/src/error.rs +++ b/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, diff --git a/programs/core-attribute-voter/src/instructions/configure_collection.rs b/programs/core-attribute-voter/src/instructions/configure_collection.rs index 5017010..2e7a8f1 100644 --- a/programs/core-attribute-voter/src/instructions/configure_collection.rs +++ b/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; diff --git a/programs/core-attribute-voter/src/state/collection_config.rs b/programs/core-attribute-voter/src/state/collection_config.rs index a24e0f0..372378a 100644 --- a/programs/core-attribute-voter/src/state/collection_config.rs +++ b/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 { - (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(), diff --git a/programs/core-attribute-voter/src/state/registrar.rs b/programs/core-attribute-voter/src/state/registrar.rs index be4f96d..fb02b92 100644 --- a/programs/core-attribute-voter/src/state/registrar.rs +++ b/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()) }) } diff --git a/programs/core-attribute-voter/tests/configure_collection.rs b/programs/core-attribute-voter/tests/configure_collection.rs index d27a98f..57ff6f4 100644 --- a/programs/core-attribute-voter/tests/configure_collection.rs +++ b/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(()) } diff --git a/programs/core-attribute-voter/tests/program_test/core_voter_test.rs b/programs/core-attribute-voter/tests/program_test/core_voter_test.rs index 256fd2d..a708cc7 100644 --- a/programs/core-attribute-voter/tests/program_test/core_voter_test.rs +++ b/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, diff --git a/programs/core-attribute-voter/tests/relinquish_nft_vote.rs b/programs/core-attribute-voter/tests/relinquish_nft_vote.rs index 94f56d4..dad8ddc 100644 --- a/programs/core-attribute-voter/tests/relinquish_nft_vote.rs +++ b/programs/core-attribute-voter/tests/relinquish_nft_vote.rs @@ -38,7 +38,7 @@ async fn test_relinquish_nft_vote() -> Result<(), TransportError> { ®istrar_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 ®istrar_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 ®istrar_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> ®istrar_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?; diff --git a/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs b/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs index 6511051..40ad89d 100644 --- a/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs +++ b/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); From b01a5054322e34e22cd017f716a74f4ddea513ab Mon Sep 17 00:00:00 2001 From: Utkarsh <83659045+0xShuk@users.noreply.github.com> Date: Fri, 6 Mar 2026 22:05:45 +0530 Subject: [PATCH 3/3] add total weight changes --- programs/core-attribute-voter/README.md | 22 ++++++----- programs/core-attribute-voter/src/error.rs | 3 ++ .../src/instructions/configure_collection.rs | 7 ++++ programs/core-attribute-voter/src/lib.rs | 3 +- .../src/state/collection_config.rs | 15 ++++--- .../src/state/registrar.rs | 2 +- .../tests/configure_collection.rs | 39 ++++++++++++++++++- .../tests/program_test/core_voter_test.rs | 5 +++ .../tests/update_max_voter_weight_record.rs | 28 ++++++++----- 9 files changed, 96 insertions(+), 28 deletions(-) diff --git a/programs/core-attribute-voter/README.md b/programs/core-attribute-voter/README.md index 4d643a4..728900b 100644 --- a/programs/core-attribute-voter/README.md +++ b/programs/core-attribute-voter/README.md @@ -12,7 +12,8 @@ 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 and represents the collection's max governance weight +- A **max weight** — a ceiling that caps any single NFT's voting power +- A **total weight** — the collection's contribution to the quorum denominator (`max_voter_weight`) - An **expected attribute authority** — the trusted authority that set the attributes When a voter submits their NFTs, the program: @@ -32,20 +33,21 @@ When a voter submits their NFTs, the program: The maximum possible voting power across all configured collections: ``` -max_voter_weight = Σ collection.max_weight +max_voter_weight = Σ collection.total_weight ``` -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. +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 `total_weight` must be set by the realm authority to reflect the expected total voting power of each collection. -#### Setting `max_weight` correctly +#### Setting `max_weight` and `total_weight` correctly -`max_weight` plays a dual role — it caps individual NFT weights **and** feeds into the quorum denominator. Getting it right matters: +- `max_weight` caps per-NFT voting power. +- `total_weight` controls quorum denominator contribution for the collection. **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 +- If `total_weight = 200`, quorum denominator reflects the true total voting power - A 60% quorum requires 120 voting power to pass **Example 2 — Set too low:** @@ -61,8 +63,8 @@ Same collection, but `max_weight = 10000`. - 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` +Collection A: `max_weight = 500`, `total_weight = 500`; Collection B: `max_weight = 300`, `total_weight = 300`. +- `max_voter_weight = 500 + 300 = 800` (sum of `total_weight`) - A voter holding NFTs from both collections accumulates weight across them - 60% quorum requires 480 total voting power @@ -103,6 +105,7 @@ create_max_voter_weight_record() configure_collection( max_weight: 100, + total_weight: 1000, weight_attribute_key: "voting_power", expected_attribute_authority: UpdateAuthority ) @@ -162,7 +165,8 @@ relinquish_nft_vote() | Parameter | Type | Constraints | Description | |---|---|---|---| -| `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. | +| `max_weight` | `u64` | > 0 | Max governance weight per NFT (attribute cap per asset). | +| `total_weight` | `u64` | > 0 | Collection's total governance contribution for quorum calculation. Summed across collections into `max_voter_weight`. | | `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 | diff --git a/programs/core-attribute-voter/src/error.rs b/programs/core-attribute-voter/src/error.rs index dcd318e..f87bd73 100644 --- a/programs/core-attribute-voter/src/error.rs +++ b/programs/core-attribute-voter/src/error.rs @@ -12,6 +12,9 @@ pub enum CoreNftAttributeVoterError { #[msg("Invalid max weight, must be greater than 0")] InvalidMaxWeight, + #[msg("Invalid total weight, must be greater than 0")] + InvalidTotalWeight, + #[msg("Invalid MaxVoterWeightRecord Realm")] InvalidMaxVoterWeightRecordRealm, diff --git a/programs/core-attribute-voter/src/instructions/configure_collection.rs b/programs/core-attribute-voter/src/instructions/configure_collection.rs index 2e7a8f1..4ef0481 100644 --- a/programs/core-attribute-voter/src/instructions/configure_collection.rs +++ b/programs/core-attribute-voter/src/instructions/configure_collection.rs @@ -49,6 +49,7 @@ pub struct ConfigureCollection<'info> { pub fn configure_collection( ctx: Context, max_weight: u64, + total_weight: u64, weight_attribute_key: String, expected_attribute_authority: PluginAuthority, ) -> Result<()> { @@ -71,6 +72,11 @@ pub fn configure_collection( CoreNftAttributeVoterError::InvalidMaxWeight ); + require!( + total_weight > 0, + CoreNftAttributeVoterError::InvalidTotalWeight + ); + // Validate weight_attribute_key require!( !weight_attribute_key.is_empty() && weight_attribute_key.len() <= 32, @@ -80,6 +86,7 @@ pub fn configure_collection( let collection_config = CollectionConfig { collection: collection_key, max_weight, + total_weight, weight_attribute_key, expected_attribute_authority, reserved: [0; 8], diff --git a/programs/core-attribute-voter/src/lib.rs b/programs/core-attribute-voter/src/lib.rs index fff51d7..fc41345 100644 --- a/programs/core-attribute-voter/src/lib.rs +++ b/programs/core-attribute-voter/src/lib.rs @@ -52,11 +52,12 @@ pub mod core_attribute_voter { pub fn configure_collection( ctx: Context, max_weight: u64, + total_weight: u64, weight_attribute_key: String, expected_attribute_authority: mpl_core::types::PluginAuthority, ) -> Result<()> { log_version(); - instructions::configure_collection(ctx, max_weight, weight_attribute_key, expected_attribute_authority) + instructions::configure_collection(ctx, max_weight, total_weight, weight_attribute_key, expected_attribute_authority) } pub fn cast_nft_vote<'a, 'b, 'c, 'info>( diff --git a/programs/core-attribute-voter/src/state/collection_config.rs b/programs/core-attribute-voter/src/state/collection_config.rs index 372378a..64c48c5 100644 --- a/programs/core-attribute-voter/src/state/collection_config.rs +++ b/programs/core-attribute-voter/src/state/collection_config.rs @@ -8,12 +8,13 @@ pub struct CollectionConfig { pub collection: Pubkey, /// 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 + /// Any NFT whose configured attribute value exceeds this cap is limited to this value. pub max_weight: u64, + /// Total governance power contribution of the collection to quorum denominator. + /// This value is summed across collections to produce MaxVoterWeightRecord.max_voter_weight. + pub total_weight: u64, + /// The attribute key to read the voting weight from on each NFT /// The attribute value must be a valid u64 string pub weight_attribute_key: String, @@ -27,8 +28,9 @@ pub struct CollectionConfig { } impl CollectionConfig { - /// 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; + /// Borsh serialized size: 32 (Pubkey) + 8 (max_weight) + 8 (total_weight) + /// + 4+32 (String with max 32 chars) + 33 (PluginAuthority) + 8 (reserved) + pub const SERIALIZED_SIZE: usize = 32 + 8 + 8 + 36 + 33 + 8; } @@ -37,6 +39,7 @@ impl Default for CollectionConfig { Self { collection: Pubkey::default(), max_weight: 0, + total_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(), expected_attribute_authority: PluginAuthority::Address { address: Pubkey::default() }, diff --git a/programs/core-attribute-voter/src/state/registrar.rs b/programs/core-attribute-voter/src/state/registrar.rs index fb02b92..bb3aba5 100644 --- a/programs/core-attribute-voter/src/state/registrar.rs +++ b/programs/core-attribute-voter/src/state/registrar.rs @@ -68,7 +68,7 @@ impl Registrar { self.collection_configs .iter() .try_fold(0u64, |sum, cc| { - sum.checked_add(cc.max_weight) + sum.checked_add(cc.total_weight) .ok_or_else(|| CoreNftAttributeVoterError::ArithmeticOverflow.into()) }) } diff --git a/programs/core-attribute-voter/tests/configure_collection.rs b/programs/core-attribute-voter/tests/configure_collection.rs index 57ff6f4..d32f6f9 100644 --- a/programs/core-attribute-voter/tests/configure_collection.rs +++ b/programs/core-attribute-voter/tests/configure_collection.rs @@ -62,7 +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 + registrar.collection_configs[0].total_weight ); Ok(()) @@ -505,6 +505,43 @@ async fn test_configure_collection_with_empty_weight_attribute_key_error( Ok(()) } +#[tokio::test] +async fn test_configure_collection_with_zero_total_weight_error( +) -> Result<(), TransportError> { + // Arrange + let mut core_voter_test = CoreVoterTest::start_new().await; + + let realm_cookie = core_voter_test.governance.with_realm().await?; + + let registrar_cookie = core_voter_test.with_registrar(&realm_cookie).await?; + + let collection_cookie = core_voter_test.core.create_collection(Some(1)).await?; + + let max_voter_weight_record_cookie = core_voter_test + .with_max_voter_weight_record(®istrar_cookie) + .await?; + + // Act + let err = core_voter_test + .with_collection( + ®istrar_cookie, + &collection_cookie, + &max_voter_weight_record_cookie, + Some(ConfigureCollectionArgs { + total_weight: Some(0), + ..Default::default() + }), + ) + .await + .err() + .unwrap(); + + // Assert + assert_nft_voter_err(err, CoreNftAttributeVoterError::InvalidTotalWeight); + + Ok(()) +} + #[tokio::test] async fn test_configure_collection_with_too_long_weight_attribute_key_error( ) -> Result<(), TransportError> { diff --git a/programs/core-attribute-voter/tests/program_test/core_voter_test.rs b/programs/core-attribute-voter/tests/program_test/core_voter_test.rs index a708cc7..0b09f76 100644 --- a/programs/core-attribute-voter/tests/program_test/core_voter_test.rs +++ b/programs/core-attribute-voter/tests/program_test/core_voter_test.rs @@ -57,6 +57,7 @@ pub struct CollectionConfigCookie { pub struct ConfigureCollectionArgs { pub max_weight: u64, + pub total_weight: Option, pub weight_attribute_key: String, pub expected_attribute_authority: mpl_core::types::PluginAuthority, } @@ -65,6 +66,7 @@ impl Default for ConfigureCollectionArgs { fn default() -> Self { Self { max_weight: 1, + total_weight: None, weight_attribute_key: "weight".to_string(), expected_attribute_authority: mpl_core::types::PluginAuthority::UpdateAuthority, } @@ -522,10 +524,12 @@ impl CoreVoterTest { signers_override: Option<&[&Keypair]>, ) -> Result { let args = args.unwrap_or_default(); + let total_weight = args.total_weight.unwrap_or(args.max_weight); let data = anchor_lang::InstructionData::data(&gpl_core_attribute_voter::instruction::ConfigureCollection { max_weight: args.max_weight, + total_weight, weight_attribute_key: args.weight_attribute_key.clone(), expected_attribute_authority: args.expected_attribute_authority.clone(), }); @@ -556,6 +560,7 @@ impl CoreVoterTest { let collection_config = CollectionConfig { collection: collection_cookie.collection, max_weight: args.max_weight, + total_weight, weight_attribute_key: args.weight_attribute_key, expected_attribute_authority: args.expected_attribute_authority, reserved: [0; 8], diff --git a/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs b/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs index 40ad89d..1185611 100644 --- a/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs +++ b/programs/core-attribute-voter/tests/update_max_voter_weight_record.rs @@ -22,7 +22,8 @@ async fn test_update_collection_config_invalidates_max_voter_weight_record_expir .await?; let collection_1_size = 7; - let collection_1_weight = 5; + let collection_1_max_weight = 5; + let collection_1_total_weight = 40; let collection_cookie_1 = core_voter_test .core @@ -36,7 +37,8 @@ async fn test_update_collection_config_invalidates_max_voter_weight_record_expir &collection_cookie_1, &max_voter_weight_record_cookie, Some(ConfigureCollectionArgs { - max_weight: collection_1_weight, + max_weight: collection_1_max_weight, + total_weight: Some(collection_1_total_weight), ..Default::default() }), ) @@ -48,7 +50,8 @@ async fn test_update_collection_config_invalidates_max_voter_weight_record_expir .await?; let collection_2_size = 10; - let collection_2_weight = 2; + let collection_2_max_weight = 2; + let collection_2_total_weight = 30; // Generate a new collection and update the registrar with the additional collection // while invalidating max voter weight. @@ -64,7 +67,8 @@ async fn test_update_collection_config_invalidates_max_voter_weight_record_expir &collection_cookie_2, &max_voter_weight_record_cookie, Some(ConfigureCollectionArgs { - max_weight: collection_2_weight, + max_weight: collection_2_max_weight, + total_weight: Some(collection_2_total_weight), ..Default::default() }), ) @@ -83,7 +87,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_2_weight; + let max_voter_weight_total = collection_1_total_weight + collection_2_total_weight; assert!(registrar.collection_configs.len() == 2); assert!(max_voter_weight_record.max_voter_weight_expiry.is_none()); @@ -110,7 +114,8 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result< // Set collection sizes and weights for collection_1 let collection_1_size = 11; - let collection_1_weight = 4; + let collection_1_max_weight = 4; + let collection_1_total_weight = 44; let collection_cookie_1 = core_voter_test .core @@ -124,7 +129,8 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result< &collection_cookie_1, &max_voter_weight_record_cookie, Some(ConfigureCollectionArgs { - max_weight: collection_1_weight, + max_weight: collection_1_max_weight, + total_weight: Some(collection_1_total_weight), ..Default::default() }), ) @@ -145,7 +151,8 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result< // which also invalidates max_voter_weight_expirey. let collection_2_size = 9; - let collection_2_weight = 3; + let collection_2_max_weight = 3; + let collection_2_total_weight = 27; let collection_cookie_2 = core_voter_test .core .create_collection(Some(collection_2_size)) @@ -158,7 +165,8 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result< &collection_cookie_2, &max_voter_weight_record_cookie, Some(ConfigureCollectionArgs { - max_weight: collection_2_weight, + max_weight: collection_2_max_weight, + total_weight: Some(collection_2_total_weight), ..Default::default() }), ) @@ -180,7 +188,7 @@ async fn test_update_max_voter_weight_record_provides_valid_expirey() -> Result< .await; // Assert - let max_voter_weight_total = collection_1_weight + collection_2_weight; + let max_voter_weight_total = collection_1_total_weight + collection_2_total_weight; assert!(registrar.collection_configs.len() == 2); assert!(max_voter_weight_record.max_voter_weight == max_voter_weight_total as u64);