Struct spl_governance::state::realm::RealmV2

pub struct RealmV2 {
    pub account_type: GovernanceAccountType,
    pub community_mint: Pubkey,
    pub config: RealmConfig,
    pub reserved: [u8; 6],
    pub legacy1: u16,
    pub authority: Option<Pubkey>,
    pub name: String,
    pub reserved_v2: [u8; 128],
}

Governance Realm Account Account PDA seeds“ [‘governance’, name]

Fields

account_type: GovernanceAccountType

Governance account type

community_mint: Pubkey

Community mint

config: RealmConfig

Configuration of the Realm

reserved: [u8; 6]

Reserved space for future versions

legacy1: u16

Legacy field not used since program V3 any longer Note: If the field is going to be reused in future version it must be taken under consideration that for some Realms it might be already set to none zero because it was used as voting_proposal_count before

authority: Option<Pubkey>

Realm authority. The authority must sign transactions which update the realm config The authority should be transferred to Realm Governance to make the Realm self governed through proposals

name: String

Governance Realm name

reserved_v2: [u8; 128]

Reserved space for versions v2 and onwards Note: V1 accounts must be resized before using this space

Implementations

impl RealmV2

pub fn assert_is_valid_governing_token_mint( &self, governing_token_mint: &Pubkey ) -> Result<(), ProgramError>

Asserts the given mint is either Community or Council mint of the Realm

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

Returns the governing token mint which is used to vote on a proposal given the provided Vote kind and vote_governing_token_mint

Veto vote is cast on a proposal configured for the opposite voting population defined using governing_token_mint Council can veto Community vote and Community can veto Council assuming the veto for the voting population is enabled

For all votes other than Veto (Electorate votes) the vote_governing_token_mint is the same as Proposal governing_token_mint

pub fn assert_is_valid_governing_token_mint_and_holding( &self, program_id: &Pubkey, realm: &Pubkey, governing_token_mint: &Pubkey, governing_token_holding: &Pubkey ) -> Result<(), ProgramError>

Asserts the given governing token mint and holding accounts are valid for the realm

pub fn assert_create_authority_can_create_governance( &self, program_id: &Pubkey, realm: &Pubkey, token_owner_record_info: &AccountInfo<'_>, create_authority_info: &AccountInfo<'_>, account_info_iter: &mut Iter<'_, AccountInfo<'_>> ) -> Result<(), ProgramError>

Assert the given create authority can create governance

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

Serializes account into the target buffer

Trait Implementations

impl AccountMaxSize for RealmV2

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 RealmV2

where GovernanceAccountType: BorshDeserialize, Pubkey: BorshDeserialize, RealmConfig: BorshDeserialize, [u8; 6]: BorshDeserialize, u16: BorshDeserialize, Option<Pubkey>: BorshDeserialize, String: BorshDeserialize, [u8; 128]: 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 RealmV2

where GovernanceAccountType: BorshSchema, Pubkey: BorshSchema, RealmConfig: BorshSchema, [u8; 6]: BorshSchema, u16: BorshSchema, Option<Pubkey>: BorshSchema, String: BorshSchema, [u8; 128]: 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 RealmV2

where GovernanceAccountType: BorshSerialize, Pubkey: BorshSerialize, RealmConfig: BorshSerialize, [u8; 6]: BorshSerialize, u16: BorshSerialize, Option<Pubkey>: BorshSerialize, String: BorshSerialize, [u8; 128]: 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 RealmV2

fn clone(&self) -> RealmV2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RealmV2

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

Formats the value using the given formatter.

impl IsInitialized for RealmV2

fn is_initialized(&self) -> bool

Is initialized

impl PartialEq for RealmV2

fn eq(&self, other: &RealmV2) -> 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 RealmV2

impl StructuralEq for RealmV2

impl StructuralPartialEq for RealmV2