Enum SinglePoolInstruction 

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

Instructions supported by the SinglePool program.

Variants

InitializePool

Initialize the mint and main stake account for a new single-validator stake pool. The pool stake account must contain the rent-exempt minimum plus the minimum balance of 1 sol. No tokens will be minted; to deposit more, use Deposit after InitializeStake and InitializePoolOnRamp.

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

ReplenishPool

Bring the pool stake accounts to their optimal state. This performs several operations:

• If the main stake account has been deactivated by DeactivateDelinquent, reactivate it.
• Then, if the main stake account is already fully active:
  • If the on-ramp is fully active, move its stake to the main account.
  • If the main account has excess lamports, move them to the on-ramp.
  • Delegate the on-ramp if it has excess lamports to activate.

Combined, these operations allow harvesting and delegating MEV rewards and also enable depositing liquid sol for pool tokens via DepositSol.

This instruction is idempotent and gracefully skips operations that would fail or have no effect, up to no-op. This allows it to be executed speculatively or as part of arbitrary flows involving the pool. If the on-ramp account is already activating, and there are excess lamports beyond the activating delegation, it increases the delegation to include them.

This instruction will fail with an error if the on-ramp account does not exist. If the pool does not have the account, InitializePoolOnRamp must be called to create it.

0. [] Validator vote account
1. [] Pool account
2. [w] Pool stake account
3. [w] Pool on-ramp account
4. [] Pool stake authority
5. [] Clock sysvar
6. [] Stake history sysvar
7. [] Stake config sysvar
8. [] 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. [] Pool on-ramp account
3. [w] Pool token mint
4. [] Pool stake authority
5. [] Pool mint authority
6. [w] User stake account to join to the pool
7. [w] User account to receive pool tokens
8. [w] User account to receive lamports
9. [] Clock sysvar
10. [] Stake history sysvar
11. [] Token program
12. [] Stake program

WithdrawStake

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

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

Fields

user_stake_authority: Pubkey

User authority for the new stake account

token_amount: u64

Amount of tokens to redeem for stake

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

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

Fields

name: String

Token name

symbol: String

Token symbol e.g. stkSOL

uri: String

URI of the uploaded metadata of the spl-token

InitializePoolOnRamp

Create the on-ramp account for a single-validator stake pool, which is used to delegate liquid sol so that it can be merged into the main pool account as active stake.

New pools created with initialize() will include this instruction automatically. Existing pools must use InitializePoolOnRamp to upgrade to the latest version. Note the on-ramp IS necessary for the pool to operate.

0. [] Pool account
1. [w] Pool on-ramp account
2. [] Pool stake authority
3. [] Rent sysvar
4. [] System program
5. [] Stake program

DepositSol

Deposit liquid sol into the pool. The output is a “pool” token representing fractional ownership of the pool stake. Inputs are converted to the current ratio, less a fee of DEPOSIT_SOL_FEE_BPS. This instruction invokes ReplenishPool to immediately delegate any newly added sol if possible.

0. [] Validator vote account
1. [] Pool account
2. [w] Pool stake account
3. [w] Pool on-ramp account
4. [w] Pool token mint
5. [] Pool stake authority
6. [] Pool mint authority
7. [w, s] User system account to deposit from
8. [w] User account to receive pool tokens
9. [] Clock sysvar
10. [] Stake history sysvar
11. [] Stake config sysvar
12. [] System program
13. [] Token program
14. [] Stake program
15. [] Single-validator stake pool program

Fields

lamports: u64

Amount of sol to deposit

Trait Implementations

impl BorshDeserialize for SinglePoolInstruction

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 SinglePoolInstruction

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

impl Clone for SinglePoolInstruction

fn clone(&self) -> SinglePoolInstruction

Returns a duplicate 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 SinglePoolInstruction

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

Deserialises given variant of an enum from the reader.

impl PartialEq for SinglePoolInstruction

fn eq(&self, other: &SinglePoolInstruction) -> 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 StructuralPartialEq for SinglePoolInstruction