Struct spl_governance::state::governance::GovernanceV2

pub struct GovernanceV2 {
    pub account_type: GovernanceAccountType,
    pub realm: Pubkey,
    pub governed_account: Pubkey,
    pub reserved1: u32,
    pub config: GovernanceConfig,
    pub reserved_v2: Reserved119,
    pub required_signatories_count: u8,
    pub active_proposal_count: u64,
}

Governance Account

Fields

account_type: GovernanceAccountType

Account type. It can be Uninitialized, Governance, ProgramGovernance, TokenGovernance or MintGovernance

realm: Pubkey

Governance Realm

governed_account: Pubkey

Account governed by this Governance and/or PDA identity seed It can be Program account, Mint account, Token account or any other account

Note: The account doesn’t have to exist. In that case the field is only a PDA seed

Note: Setting governed_account doesn’t give any authority over the governed account The relevant authorities for specific account types must still be transferred to the Governance PDA Ex: mint_authority/ freeze_authority for a Mint account or upgrade_authority for a Program account should be transferred to the Governance PDA

reserved1: u32

Reserved space for future versions

config: GovernanceConfig

Governance config

reserved_v2: Reserved119

Reserved space for versions v2 and onwards Note 1: V1 accounts must be resized before using this space Note 2: The reserved space should be used from the end to also allow the config to grow if needed

required_signatories_count: u8

The number of required signatories for proposals in the Governance

active_proposal_count: u64

The number of active proposals where active means Draft, SigningOff or Voting state

Note: The counter was introduced in program V3 and didn’t exist in program V1 & V2 If the program is upgraded from program V1 or V2 while there are any outstanding active proposals the counter won’t be accurate until all proposals are transitioned to an inactive final state and the counter reset

Implementations

impl GovernanceV2

pub fn get_governance_address_seeds(&self) -> Result<[&[u8]; 3], ProgramError>

Returns Governance PDA seeds

pub fn serialize<W: Write>(self, writer: W) -> Result<(), ProgramError>

Serializes account into the target buffer

pub fn serialize_as_governance_v2<'a>( self, governance_info: &AccountInfo<'a>, payer_info: &AccountInfo<'a>, system_info: &AccountInfo<'a>, rent: &Rent ) -> Result<(), ProgramError>

Serializes Governance accounts as GovernanceV2 If the account is GovernanceV1 then it changes its type to GovernanceV2 and resizes account data Note: It supports all the specialized Governance account types (Governance, ProgramGovernance, MintGovernance and TokenGovernance)

pub fn assert_governing_token_mint_can_vote( &self, realm_data: &RealmV2, vote_governing_token_mint: &Pubkey, vote_kind: &VoteKind ) -> Result<(), ProgramError>

Asserts the provided voting population represented by the given governing_token_mint can cast the given vote type on proposals for the Governance

pub fn resolve_vote_threshold( &self, realm_data: &RealmV2, vote_governing_token_mint: &Pubkey, vote_kind: &VoteKind ) -> Result<VoteThreshold, ProgramError>

Resolves VoteThreshold for the given realm, governing token and Vote kind

pub fn get_vote_tipping( &self, realm_data: &RealmV2, governing_token_mint: &Pubkey ) -> Result<&VoteTipping, ProgramError>

Returns VoteTipping for the given governing_token_mint

pub fn get_proposal_deposit_amount(&self) -> u64

Returns the required deposit amount for creating Nth Proposal based on the number of active proposals where N equals to active_proposal_count - deposit_exempt_proposal_count The deposit is not payed unless there are more active Proposal than the exempt amount

Note: The exact deposit payed for Nth Proposal is N*SECURITY_DEPOSIT_BASE_LAMPORTS + min_rent_for(ProposalDeposit)

Note: Although the deposit amount payed for Nth proposal is linear the total deposit amount required to create N proposals is sum of arithmetic series Dn = Nr + dN*(N+1)/2

Trait Implementations

impl AccountMaxSize for GovernanceV2

fn get_max_size(&self) -> Option<usize>

Returns max account size or None if max size is not known and actual instance size should be used

impl BorshDeserialize for GovernanceV2

where GovernanceAccountType: BorshDeserialize, Pubkey: BorshDeserialize, u32: BorshDeserialize, GovernanceConfig: BorshDeserialize, Reserved119: BorshDeserialize, u8: BorshDeserialize, u64: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSchema for GovernanceV2

where GovernanceAccountType: BorshSchema, Pubkey: BorshSchema, u32: BorshSchema, GovernanceConfig: BorshSchema, Reserved119: BorshSchema, u8: BorshSchema, u64: BorshSchema,

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively( definitions: &mut HashMap<Declaration, Definition> )

Recursively, using DFS, add type definitions required for this type. For primitive types this is an empty map. Type definition explains how to serialize/deserialize a type.

fn add_definition( declaration: String, definition: Definition, definitions: &mut HashMap<String, Definition> )

Helper method to add a single type definition to the map.

fn schema_container() -> BorshSchemaContainer

impl BorshSerialize for GovernanceV2

where GovernanceAccountType: BorshSerialize, Pubkey: BorshSerialize, u32: BorshSerialize, GovernanceConfig: BorshSerialize, Reserved119: BorshSerialize, u8: BorshSerialize, u64: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for GovernanceV2

fn clone(&self) -> GovernanceV2

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GovernanceV2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IsInitialized for GovernanceV2

fn is_initialized(&self) -> bool

Is initialized

impl PartialEq for GovernanceV2

fn eq(&self, other: &GovernanceV2) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for GovernanceV2

impl StructuralEq for GovernanceV2

impl StructuralPartialEq for GovernanceV2