Enum spl_single_pool::instruction::SinglePoolInstruction

#[repr(C)]
pub enum SinglePoolInstruction {
    InitializePool,
    ReactivatePoolStake,
    DepositStake,
    WithdrawStake {
        user_stake_authority: Pubkey,
        token_amount: u64,
    },
    CreateTokenMetadata,
    UpdateTokenMetadata {
        name: String,
        symbol: String,
        uri: String,
    },
}

Instructions supported by the SinglePool program.

Variants

InitializePool

Initialize the mint and stake account for a new single-validator stake pool. The pool stake account must contain the rent-exempt minimum plus the minimum delegation. No tokens will be minted: to deposit more, use Deposit after InitializeStake.

0. [] Validator vote account
1. [w] Pool account
2. [w] Pool stake account
3. [w] Pool token mint
4. [] Pool stake authority
5. [] Pool mint authority
6. [] Rent sysvar
7. [] Clock sysvar
8. [] Stake history sysvar
9. [] Stake config sysvar
10. [] System program
11. [] Token program
12. [] Stake program

ReactivatePoolStake

Restake the pool stake account if it was deactivated. This can happen through the stake program’s DeactivateDelinquent instruction, or during a cluster restart.

0. [] Validator vote account
1. [] Pool account
2. [w] Pool stake account
3. [] Pool stake authority
4. [] Clock sysvar
5. [] Stake history sysvar
6. [] Stake config sysvar
7. [] Stake program

DepositStake

Deposit stake into the pool. The output is a “pool” token representing fractional ownership of the pool stake. Inputs are converted to the current ratio.

0. [] Pool account
1. [w] Pool stake account
2. [w] Pool token mint
3. [] Pool stake authority
4. [] Pool mint authority
5. [w] User stake account to join to the pool
6. [w] User account to receive pool tokens
7. [w] User account to receive lamports
8. [] Clock sysvar
9. [] Stake history sysvar
10. [] Token program
11. [] Stake program

WithdrawStake

Fields

user_stake_authority: Pubkey

User authority for the new stake account

token_amount: u64

Amount of tokens to redeem for stake

Redeem tokens issued by this pool for stake at the current ratio.

0. [] Pool account
1. [w] Pool stake account
2. [w] Pool token mint
3. [] Pool stake authority
4. [] Pool mint authority
5. [w] User stake account to receive stake at
6. [w] User account to take pool tokens from
7. [] Clock sysvar
8. [] Token program
9. [] Stake program

CreateTokenMetadata

Create token metadata for the stake-pool token in the metaplex-token program. Step three of the permissionless three-stage initialization flow. Note this instruction is not necessary for the pool to operate, to ensure we cannot be broken by upstream.

0. [] Pool account
1. [] Pool token mint
2. [] Pool mint authority
3. [] Pool MPL authority
4. [s, w] Payer for creation of token metadata account
5. [w] Token metadata account
6. [] Metadata program id
7. [] System program id

UpdateTokenMetadata

Fields

name: String

Token name

symbol: String

Token symbol e.g. stkSOL

uri: String

URI of the uploaded metadata of the spl-token

Update token metadata for the stake-pool token in the metaplex-token program.

0. [] Validator vote account
1. [] Pool account
2. [] Pool MPL authority
3. [s] Vote account authorized withdrawer
4. [w] Token metadata account
5. [] Metadata program id

Trait Implementations

impl BorshDeserialize for SinglePoolInstructionwhere Pubkey: BorshDeserialize, u64: BorshDeserialize, String: 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 SinglePoolInstructionwhere Pubkey: BorshSerialize, u64: BorshSerialize, String: 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 SinglePoolInstruction

fn clone(&self) -> SinglePoolInstruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SinglePoolInstruction

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

Formats the value using the given formatter.

impl EnumExt for SinglePoolInstructionwhere Pubkey: BorshDeserialize, u64: BorshDeserialize, String: BorshDeserialize,

fn deserialize_variant<R: Read>( reader: &mut R, variant_idx: u8 ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.

impl PartialEq for SinglePoolInstruction

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

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

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

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

impl StructuralPartialEq for SinglePoolInstruction