solana-runtime 4.0.0-beta.7

Solana runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use {
    solana_account::{AccountSharedData, ReadableAccount, state_traits::StateMut},
    solana_clock::Epoch,
    solana_native_token::LAMPORTS_PER_SOL,
    solana_pubkey::Pubkey,
    solana_rent::Rent,
    solana_stake_interface::{
        program as stake_program,
        stake_flags::StakeFlags,
        state::{Authorized, Delegation, Meta, Stake, StakeStateV2},
    },
    solana_vote_interface::state::VoteStateV4,
};

/// The minimum stake amount that can be delegated, in lamports.
/// When this feature is added, it will be accompanied by an upgrade to the BPF Stake Program.
/// NOTE: This is also used to calculate the minimum balance of a delegated stake account,
/// which is the rent exempt reserve _plus_ the minimum stake delegation.
#[inline(always)]
pub fn get_minimum_delegation(upgrade_bpf_stake_program_to_v5_is_active: bool) -> u64 {
    if upgrade_bpf_stake_program_to_v5_is_active {
        const MINIMUM_DELEGATION_SOL: u64 = 1;
        MINIMUM_DELEGATION_SOL * LAMPORTS_PER_SOL
    } else {
        1
    }
}

/// Utility function for creating a stake account from basic parameters.
/// Only used in tests and CLIs.
pub fn create_stake_account(
    authorized: &Pubkey,
    voter_pubkey: &Pubkey,
    vote_account: &AccountSharedData,
    rent: &Rent,
    lamports: u64,
) -> AccountSharedData {
    let mut stake_account =
        AccountSharedData::new(lamports, StakeStateV2::size_of(), &stake_program::id());

    let vote_state = VoteStateV4::deserialize(vote_account.data(), voter_pubkey).unwrap();
    let credits_observed = vote_state.credits();

    let rent_exempt_reserve = rent.minimum_balance(stake_account.data().len());
    let stake_amount = lamports
        .checked_sub(rent_exempt_reserve)
        .expect("lamports >= rent_exempt_reserve");

    let meta = Meta {
        authorized: Authorized::auto(authorized),
        rent_exempt_reserve,
        ..Meta::default()
    };

    let stake = Stake {
        delegation: Delegation::new(voter_pubkey, stake_amount, Epoch::MAX),
        credits_observed,
    };

    stake_account
        .set_state(&StakeStateV2::Stake(meta, stake, StakeFlags::empty()))
        .expect("set_state");

    stake_account
}