quasar-svm 0.1.0

Lightweight Solana virtual machine for local transaction execution
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use solana_pubkey::Pubkey;
use solana_rent::Rent;
use solana_program_pack::Pack;
use spl_token::state::{Account as SplTokenAccount, Mint as SplMint, AccountState};

use crate::Account;

// ---------------------------------------------------------------------------
// Re-exports for convenience
// ---------------------------------------------------------------------------

pub use spl_token::state::{Account as TokenAccount, Mint};

// ---------------------------------------------------------------------------
// Account factories
// ---------------------------------------------------------------------------

/// Create a system-owned account.
pub fn create_keyed_system_account(address: &Pubkey, lamports: u64) -> Account {
    Account {
        address: *address,
        lamports,
        data: vec![],
        owner: solana_sdk_ids::system_program::ID,
        executable: false,
    }
}

/// Create a pre-initialized mint account.
pub fn create_keyed_mint_account(address: &Pubkey, mint: &SplMint) -> Account {
    create_keyed_mint_account_with_program(address, mint, &crate::SPL_TOKEN_PROGRAM_ID)
}

/// Create a pre-initialized mint account with a specific token program.
#[inline(always)]
pub fn create_keyed_mint_account_with_program(address: &Pubkey, mint: &SplMint, token_program_id: &Pubkey) -> Account {
    let mut data = vec![0u8; SplMint::LEN];
    SplMint::pack(*mint, &mut data).unwrap();
    Account {
        address: *address,
        lamports: Rent::default().minimum_balance(SplMint::LEN),
        data,
        owner: *token_program_id,
        executable: false,
    }
}

/// Create a pre-initialized token account.
pub fn create_keyed_token_account(address: &Pubkey, token: &SplTokenAccount) -> Account {
    create_keyed_token_account_with_program(address, token, &crate::SPL_TOKEN_PROGRAM_ID)
}

/// Create a pre-initialized token account with a specific token program.
#[inline(always)]
pub fn create_keyed_token_account_with_program(address: &Pubkey, token: &SplTokenAccount, token_program_id: &Pubkey) -> Account {
    let mut data = vec![0u8; SplTokenAccount::LEN];
    SplTokenAccount::pack(*token, &mut data).unwrap();
    Account {
        address: *address,
        lamports: Rent::default().minimum_balance(SplTokenAccount::LEN),
        data,
        owner: *token_program_id,
        executable: false,
    }
}

/// Create a pre-initialized associated token account.
/// The address is derived from the wallet, mint, and token program.
pub fn create_keyed_associated_token_account(
    wallet: &Pubkey,
    mint: &Pubkey,
    amount: u64,
) -> Account {
    create_keyed_associated_token_account_with_program(wallet, mint, amount, &crate::SPL_TOKEN_PROGRAM_ID)
}

/// Create a pre-initialized associated token account with a specific token program.
/// The address is derived from the wallet, mint, and token program.
#[inline(always)]
pub fn create_keyed_associated_token_account_with_program(
    wallet: &Pubkey,
    mint: &Pubkey,
    amount: u64,
    token_program_id: &Pubkey,
) -> Account {
    let (ata, _bump) = Pubkey::find_program_address(
        &[
            wallet.as_ref(),
            token_program_id.as_ref(),
            mint.as_ref(),
        ],
        &crate::SPL_ASSOCIATED_TOKEN_PROGRAM_ID,
    );
    let token = SplTokenAccount {
        mint: *mint,
        owner: *wallet,
        amount,
        state: AccountState::Initialized,
        ..SplTokenAccount::default()
    };
    create_keyed_token_account_with_program(&ata, &token, token_program_id)
}