Struct spl_governance_addin_api::voter_weight::VoterWeightRecord

pub struct VoterWeightRecord {
    pub account_discriminator: [u8; 8],
    pub realm: Pubkey,
    pub governing_token_mint: Pubkey,
    pub governing_token_owner: Pubkey,
    pub voter_weight: u64,
    pub voter_weight_expiry: Option<Slot>,
    pub weight_action: Option<VoterWeightAction>,
    pub weight_action_target: Option<Pubkey>,
    pub reserved: [u8; 8],
}

VoterWeightRecord account The account is used as an api interface to provide voting power to the governance program from external addin contracts

Fields

account_discriminator: [u8; 8]

VoterWeightRecord discriminator sha256(“account:VoterWeightRecord”)[..8] Note: The discriminator size must match the addin implementing program discriminator size to ensure it’s stored in the private space of the account data and it’s unique

realm: Pubkey

The Realm the VoterWeightRecord belongs to

governing_token_mint: 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

governing_token_owner: Pubkey

The owner of the governing token and voter This is the actual owner (voter) and corresponds to TokenOwnerRecord.governing_token_owner

voter_weight: u64

Voter’s weight The weight of the voter provided by the addin for the given realm, governing_token_mint and governing_token_owner (voter)

voter_weight_expiry: Option<Slot>

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

weight_action: Option<VoterWeightAction>

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

weight_action_target: Option<Pubkey>

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

reserved: [u8; 8]

Reserved space for future versions

Implementations

impl VoterWeightRecord

pub const ACCOUNT_DISCRIMINATOR: [u8; 8]

sha256(“account:VoterWeightRecord”)[..8]

Trait Implementations

impl AccountMaxSize for VoterWeightRecord

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 VoterWeightRecord where
    [u8; 8]: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    Option<Slot>: BorshDeserialize,
    Option<VoterWeightAction>: BorshDeserialize,
    Option<Pubkey>: BorshDeserialize,
    [u8; 8]: BorshDeserialize, 

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.

impl BorshSchema for VoterWeightRecord where
    [u8; 8]: BorshSchema,
    Pubkey: BorshSchema,
    Pubkey: BorshSchema,
    Pubkey: BorshSchema,
    u64: BorshSchema,
    Option<Slot>: BorshSchema,
    Option<VoterWeightAction>: BorshSchema,
    Option<Pubkey>: BorshSchema,
    [u8; 8]: 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, RandomState>
)

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

fn schema_container() -> BorshSchemaContainer

impl BorshSerialize for VoterWeightRecord where
    [u8; 8]: BorshSerialize,
    Pubkey: BorshSerialize,
    Pubkey: BorshSerialize,
    Pubkey: BorshSerialize,
    u64: BorshSerialize,
    Option<Slot>: BorshSerialize,
    Option<VoterWeightAction>: BorshSerialize,
    Option<Pubkey>: BorshSerialize,
    [u8; 8]: BorshSerialize, 

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

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

Serialize this instance into a vector of bytes.

impl Clone for VoterWeightRecord

fn clone(&self) -> VoterWeightRecord

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VoterWeightRecord

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

Formats the value using the given formatter.

impl IsInitialized for VoterWeightRecord

fn is_initialized(&self) -> bool

Is initialized

impl PartialEq<VoterWeightRecord> for VoterWeightRecord

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

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

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

This method tests for !=.

impl StructuralPartialEq for VoterWeightRecord