Enum spl_feature_proposal::instruction::FeatureProposalInstruction

pub enum FeatureProposalInstruction {
    Propose {
        tokens_to_mint: u64,
        acceptance_criteria: AcceptanceCriteria,
    },
    Tally,
}

Instructions supported by the Feature Proposal program

Variants

Propose

Propose a new feature.

This instruction will create a variety of accounts to support the feature proposal, all funded by account 0:

• A new token mint with a supply of tokens_to_mint, owned by the program and never modified again
• A new "distributor" token account that holds the total supply, owned by account 0.
• A new "acceptance" token account that holds 0 tokens, owned by the program. Tokens transfers to this address are irrevocable and permanent.
• A new feature id account that has been funded and allocated (as described in solana_program::feature)

On successful execution of the instruction, the feature proposer is expected to distribute the tokens in the distributor token account out to all participating parties.

Based on the provided acceptance criteria, if AcceptanceCriteria::tokens_required tokens are transferred into the acceptance token account before AcceptanceCriteria::deadline then the proposal is eligible to be accepted.

The FeatureProposalInstruction::Tally instruction must be executed, by any party, to complete the feature acceptance process.

Accounts expected by this instruction:

0. [writeable,signer] Funding account (must be a system account)
1. [writeable,signer] Unallocated feature proposal account to create
2. [writeable] Token mint address from get_mint_address
3. [writeable] Distributor token account address from get_distributor_token_address
4. [writeable] Acceptance token account address from get_acceptance_token_address
5. [writeable] Feature id account address from get_feature_id_address
6. [] System program
7. [] SPL Token program
8. [] Rent sysvar

Fields of Propose

tokens_to_mint: u64

Total number of tokens to mint for this proposal

acceptance_criteria: AcceptanceCriteria

Criteria for how this proposal may be activated

Tally

Tally is a permission-less instruction to check the acceptance criteria for the feature proposal, which may result in:

• No action
• Feature proposal acceptance
• Feature proposal expiration

Accounts expected by this instruction:

0. [writeable] Feature proposal account
1. [] Acceptance token account address from get_acceptance_token_address
2. [writeable] Derived feature id account address from get_feature_id_address
3. [] System program
4. [] Clock sysvar

Trait Implementations

impl BorshDeserialize for FeatureProposalInstruction where
    u64: BorshDeserialize,
    AcceptanceCriteria: BorshDeserialize, 

pub 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.

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

Deserialize this instance from a slice of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it's worth handling it as a special case to improve performance. It's a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl BorshSchema for FeatureProposalInstruction

pub fn declaration() -> Declaration

Get the name of the type without brackets.

pub 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.

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

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

pub fn schema_container() -> BorshSchemaContainer

impl BorshSerialize for FeatureProposalInstruction where
    u64: BorshSerialize,
    AcceptanceCriteria: BorshSerialize, 

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

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

Serialize this instance into a vector of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it's worth handling it as a special case to improve performance. It's a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl Clone for FeatureProposalInstruction

pub fn clone(&self) -> FeatureProposalInstruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureProposalInstruction

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

Formats the value using the given formatter.

impl Pack for FeatureProposalInstruction

pub const LEN: usize

The length, in bytes, of the packed representation

pub fn pack_into_slice(&self, dst: &mut [u8])

pub fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError>

pub fn get_packed_len() -> usize

Get the packed length

pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> where
    Self: IsInitialized, 

Unpack from slice and check if initialized

pub fn unpack_unchecked(input: &[u8]) -> Result<Self, ProgramError>

Unpack from slice without checking if initialized

pub fn pack(src: Self, dst: &mut [u8]) -> Result<(), ProgramError>

Pack into slice

impl PartialEq<FeatureProposalInstruction> for FeatureProposalInstruction

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

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

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

This method tests for !=.

impl Sealed for FeatureProposalInstruction

impl StructuralPartialEq for FeatureProposalInstruction