Struct NormalProposal 

pub struct NormalProposal {

    pub assets: Vec<ProposalAsset>,
    pub instruction_hashes: Vec<[u8; 32]>,
    pub propose_timestamp: i64,
    pub proposal_deadline_timestamp: i64,
    pub proposal_passed_timestamp: Option<i64>,
    pub proposal_index: u64,
    pub timelock_offset: u32,
    pub group: Pubkey,
    pub proposer: Pubkey,
    pub proposal_seed: Pubkey,
    pub passed_assets_count: u8,
    pub state: ProposalState,
    pub account_bump: u8,
}

Fields

assets: Vec<ProposalAsset>

instruction_hashes: Vec<[u8; 32]>

Hashes of each instruction in the proposal transaction, in order.

propose_timestamp: i64

proposal_deadline_timestamp: i64

proposal_passed_timestamp: Option<i64>

proposal_index: u64

timelock_offset: u32

group: Pubkey

proposer: Pubkey

proposal_seed: Pubkey

passed_assets_count: u8

state: ProposalState

account_bump: u8

Implementations

impl NormalProposal

pub fn new( proposer: Pubkey, proposal_seed: Pubkey, group: Pubkey, assets: Vec<ProposalAsset>, account_bump: u8, proposal_index: u64, proposal_deadline_timestamp: i64, instruction_hashes: Vec<[u8; 32]>, timelock_offset: u32, ) -> Result<Self>

pub fn get_asset_mut(&mut self, index: usize) -> Option<&mut ProposalAsset>

pub fn increment_passed_assets_count(&mut self) -> Result<()>

pub fn has_all_assets_passed(&self) -> bool

pub fn set_proposal_passed_timestamp(&mut self, timestamp: i64)

pub fn get_valid_from_timestamp(&self) -> Result<i64>

pub fn set_state(&mut self, new_state: ProposalState) -> Result<()>

pub fn mark_executed(&mut self) -> Result<()>

pub fn get_size(asset_count: usize, instruction_hash_count: usize) -> usize

pub fn check_and_mark_asset_passed( &mut self, index: usize, governed_asset: &Account<'_, Asset>, ) -> Result<bool>

Check if an asset has enough support to be marked as passed and pass the proposal if possible

pub fn check_and_mark_asset_failed( &mut self, index: usize, governed_asset: &Account<'_, Asset>, ) -> Result<bool>

Check if an asset has enough opposition to be marked as failed and fail the proposal if possible

Trait Implementations

impl AccountDeserialize for NormalProposal

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for NormalProposal

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

Serializes the account data into writer.

impl BorshDeserialize for NormalProposal

where Vec<ProposalAsset>: BorshDeserialize, Vec<[u8; 32]>: BorshDeserialize, i64: BorshDeserialize, Option<i64>: BorshDeserialize, u64: BorshDeserialize, u32: BorshDeserialize, Pubkey: BorshDeserialize, u8: BorshDeserialize, ProposalState: 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 BorshSerialize for NormalProposal

where Vec<ProposalAsset>: BorshSerialize, Vec<[u8; 32]>: BorshSerialize, i64: BorshSerialize, Option<i64>: BorshSerialize, u64: BorshSerialize, u32: BorshSerialize, Pubkey: BorshSerialize, u8: BorshSerialize, ProposalState: 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 NormalProposal

fn clone(&self) -> NormalProposal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Discriminator for NormalProposal

const DISCRIMINATOR: &'static [u8]

Discriminator slice.

impl Owner for NormalProposal

fn owner() -> Pubkey