cruiser 0.2.0

Solana code generation
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Client functions for the [`spl-token`] program.

use crate::client::HashedSigner;
use crate::on_chain_size::OnChainStaticSize;
use crate::program::ProgramKey;
use crate::spl::token::{MintAccount, TokenAccount, TokenProgram};
use cruiser::SolanaInstruction;
use solana_program::pubkey::Pubkey;
use solana_program::system_instruction::create_account;
use solana_sdk::signature::Signer;
use spl_token::instruction;
use std::future::Future;

/// Creates a new token account
#[allow(clippy::missing_panics_doc)]
pub async fn create_token_account<'a, F, E>(
    funder: impl Into<HashedSigner<'a>>,
    account: impl Into<HashedSigner<'a>>,
    mint: Pubkey,
    owner: Pubkey,
    rent: impl FnOnce(usize) -> F,
) -> Result<
    (
        impl IntoIterator<Item = SolanaInstruction>,
        impl IntoIterator<Item = HashedSigner<'a>>,
    ),
    E,
>
where
    F: Future<Output = Result<u64, E>>,
{
    let funder = funder.into();
    let account = account.into();
    let space = TokenAccount::<()>::on_chain_static_size();
    let rent = rent(space).await?;
    Ok((
        [
            create_account(
                &funder.pubkey(),
                &account.pubkey(),
                rent,
                space as u64,
                &TokenProgram::<()>::KEY,
            ),
            instruction::initialize_account(
                &TokenProgram::<()>::KEY,
                &account.pubkey(),
                &mint,
                &owner,
            )
            .unwrap(),
        ],
        [funder, account],
    ))
}

/// Creates a new mint
#[allow(clippy::missing_panics_doc)]
pub async fn create_mint<'a, F, E>(
    funder: impl Into<HashedSigner<'a>>,
    account: impl Into<HashedSigner<'a>>,
    mint_authority: Pubkey,
    freeze_authority: Option<Pubkey>,
    decimals: u8,
    rent: impl FnOnce(usize) -> F,
) -> Result<
    (
        impl IntoIterator<Item = SolanaInstruction>,
        impl IntoIterator<Item = HashedSigner<'a>>,
    ),
    E,
>
where
    F: Future<Output = Result<u64, E>>,
{
    let funder = funder.into();
    let account = account.into();
    let space = MintAccount::<()>::on_chain_static_size();
    let rent = rent(space).await?;
    Ok((
        [
            create_account(
                &funder.pubkey(),
                &account.pubkey(),
                rent,
                space as u64,
                &TokenProgram::<()>::KEY,
            ),
            instruction::initialize_mint(
                &TokenProgram::<()>::KEY,
                &account.pubkey(),
                &mint_authority,
                freeze_authority.as_ref(),
                decimals,
            )
            .unwrap(),
        ],
        [funder, account],
    ))
}

/// Mints tokens to an account
#[allow(clippy::missing_panics_doc)]
pub fn mint_to<'a>(
    mint: Pubkey,
    token_account_to: Pubkey,
    mint_authority: impl Into<HashedSigner<'a>>,
    amount: u64,
) -> (
    impl IntoIterator<Item = SolanaInstruction>,
    impl IntoIterator<Item = HashedSigner<'a>>,
) {
    let mint_authority = mint_authority.into();
    (
        [instruction::mint_to(
            &TokenProgram::<()>::KEY,
            &mint,
            &token_account_to,
            &mint_authority.pubkey(),
            &[],
            amount,
        )
        .unwrap()],
        [mint_authority],
    )
}

/// Transfers tokens between accounts
#[allow(clippy::missing_panics_doc)]
pub fn transfer<'a>(
    source_account: Pubkey,
    destination_account: Pubkey,
    authority: impl Into<HashedSigner<'a>>,
    amount: u64,
) -> (
    impl IntoIterator<Item = SolanaInstruction>,
    impl IntoIterator<Item = HashedSigner<'a>>,
) {
    let authority = authority.into();
    (
        [instruction::transfer(
            &TokenProgram::<()>::KEY,
            &source_account,
            &destination_account,
            &authority.pubkey(),
            &[],
            amount,
        )
        .unwrap()],
        [authority],
    )
}