Struct govern::Proposal

pub struct Proposal {

    pub governor: Pubkey,
    pub index: u64,
    pub bump: u8,
    pub proposer: Pubkey,
    pub quorum_votes: u64,
    pub for_votes: u64,
    pub against_votes: u64,
    pub abstain_votes: u64,
    pub canceled_at: i64,
    pub created_at: i64,
    pub activated_at: i64,
    pub voting_ends_at: i64,
    pub queued_at: i64,
    pub queued_transaction: Pubkey,
    pub instructions: Vec<ProposalInstruction>,
}

A Proposal is a pending transaction that may or may not be executed by the DAO.

Fields

governor: Pubkey

The public key of the governor.

index: u64

The unique ID of the proposal, auto-incremented.

bump: u8

Bump seed

proposer: Pubkey

The public key of the proposer.

quorum_votes: u64

The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed

for_votes: u64

Current number of votes in favor of this proposal

against_votes: u64

Current number of votes in opposition to this proposal

abstain_votes: u64

Current number of votes for abstaining for this proposal

canceled_at: i64

The timestamp when the proposal was canceled.

created_at: i64

The timestamp when the proposal was created.

activated_at: i64

The timestamp in which the proposal was activated. This is when voting begins.

voting_ends_at: i64

The timestamp when voting ends. This only applies to active proposals.

queued_at: i64

The timestamp in which the proposal was queued, i.e. approved for execution on the Smart Wallet.

queued_transaction: Pubkey

If the transaction was queued, this is the associated Goki Smart Wallet transaction.

instructions: Vec<ProposalInstruction>

The instructions associated with the proposal.

Implementations

impl Proposal

pub fn get_state(&self) -> Result<ProposalState>

Gets the state.

pub fn meets_quorum(&self, quorum_votes: u64) -> Option<bool>

Checks if the proposal meets quorum; that is, enough votes were made on the proposal.

pub fn state(&self, current_time: i64) -> Option<ProposalState>

The state of the proposal. See ProposalState for more details. Adapted from https://github.com/compound-finance/compound-protocol/blob/4a8648ec0364d24c4ecfc7d6cae254f55030d65f/contracts/Governance/GovernorBravoDelegate.sol#L205

pub fn to_smart_wallet_instructions(&self) -> Vec<TXInstruction>

Converts this proposal to Smart Wallet smart_wallet::TXInstructions.

impl Proposal

pub fn space(instructions: Vec<ProposalInstruction>) -> usize

Space that the Proposal takes up.

Trait Implementations

impl AccountDeserialize for Proposal

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

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, ProgramError>

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 Proposal

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

Serializes the account data into writer.

impl BorshDeserialize for Proposal where
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    u8: BorshDeserialize,
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    u64: BorshDeserialize,
    i64: BorshDeserialize,
    i64: BorshDeserialize,
    i64: BorshDeserialize,
    i64: BorshDeserialize,
    i64: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Vec<ProposalInstruction>: 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 BorshSerialize for Proposal where
    Pubkey: BorshSerialize,
    u64: BorshSerialize,
    u8: BorshSerialize,
    Pubkey: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    u64: BorshSerialize,
    i64: BorshSerialize,
    i64: BorshSerialize,
    i64: BorshSerialize,
    i64: BorshSerialize,
    i64: BorshSerialize,
    Pubkey: BorshSerialize,
    Vec<ProposalInstruction>: 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 Proposal

fn clone(&self) -> Proposal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Proposal

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

Formats the value using the given formatter.

impl Default for Proposal

fn default() -> Proposal

Returns the “default value” for a type.

impl Discriminator for Proposal

fn discriminator() -> [u8; 8]

impl Owner for Proposal

fn owner() -> Pubkey