Enum 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

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,

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

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 FeatureProposalInstruction

where u64: BorshSerialize, AcceptanceCriteria: 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.

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

fn clone(&self) -> FeatureProposalInstruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureProposalInstruction

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

Formats the value using the given formatter.

impl Pack for FeatureProposalInstruction

const LEN: usize = 25usize

The length, in bytes, of the packed representation

fn get_packed_len() -> usize

Get the packed length

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

Unpack from slice without checking if initialized

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

Pack into slice

impl PartialEq for FeatureProposalInstruction

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sealed for FeatureProposalInstruction

impl StructuralPartialEq for FeatureProposalInstruction