spl-token-wrap 1.0.0

Solana Program Library Token Wrap
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

use {
    crate::helpers::{
        common::{KeyedAccount, TokenProgram, DEFAULT_MINT_DECIMALS, DEFAULT_MINT_SUPPLY},
        extensions::{calc_mint_len, init_mint_extensions, MintExtension},
    },
    solana_account::Account,
    solana_program_pack::Pack,
    solana_pubkey::Pubkey,
    solana_rent::Rent,
    spl_pod::primitives::{PodBool, PodU64},
    spl_token_2022::{
        extension::{BaseStateWithExtensionsMut, PodStateWithExtensionsMut},
        pod::{PodCOption, PodMint},
        state::Mint,
    },
};

pub struct MintBuilder {
    token_program: TokenProgram,
    mint_authority: Option<Pubkey>,
    freeze_authority: Option<Pubkey>,
    supply: u64,
    decimals: u8,
    mint_key: Option<Pubkey>,
    lamports: Option<u64>,
    extensions: Vec<MintExtension>,
}

impl Default for MintBuilder {
    fn default() -> Self {
        Self {
            token_program: TokenProgram::SplToken,
            mint_authority: None,
            freeze_authority: None,
            supply: DEFAULT_MINT_SUPPLY,
            decimals: DEFAULT_MINT_DECIMALS,
            mint_key: None,
            lamports: None,
            extensions: Vec::new(),
        }
    }
}

impl MintBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn token_program(mut self, program: TokenProgram) -> Self {
        self.token_program = program;
        self
    }

    pub fn mint_authority(mut self, authority: Pubkey) -> Self {
        self.mint_authority = Some(authority);
        self
    }

    pub fn freeze_authority(mut self, authority: Pubkey) -> Self {
        self.freeze_authority = Some(authority);
        self
    }

    pub fn supply(mut self, supply: u64) -> Self {
        self.supply = supply;
        self
    }

    pub fn decimals(mut self, decimals: u8) -> Self {
        self.decimals = decimals;
        self
    }

    pub fn mint_key(mut self, key: Pubkey) -> Self {
        self.mint_key = Some(key);
        self
    }

    pub fn lamports(mut self, lamports: u64) -> Self {
        self.lamports = Some(lamports);
        self
    }

    pub fn with_extension(mut self, extension: MintExtension) -> Self {
        self.extensions.push(extension);
        self
    }

    pub fn build(self) -> KeyedAccount {
        let mint_key = self.mint_key.unwrap_or_else(Pubkey::new_unique);
        let mint_size = match self.token_program {
            TokenProgram::SplToken2022 => calc_mint_len(&mint_key, &self.extensions),
            TokenProgram::SplToken => {
                assert!(
                    self.extensions.is_empty(),
                    "SPL Token doesn't support extensions"
                );
                Mint::LEN
            }
        };
        let mut buffer = vec![0; mint_size];
        let mut state =
            PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut buffer).unwrap();

        // Set base mint data
        state.base.decimals = self.decimals;
        state.base.is_initialized = PodBool::from_bool(true);
        state.base.supply = PodU64::from(self.supply);
        let mint_authority = self.mint_authority.unwrap_or_else(Pubkey::new_unique);
        state.base.mint_authority = PodCOption::some(mint_authority);
        state.base.freeze_authority = self
            .freeze_authority
            .map(PodCOption::some)
            .unwrap_or(PodCOption::none());

        state.init_account_type().unwrap();

        // Initialize extensions (only for token 2022)
        if self.token_program == TokenProgram::SplToken2022 {
            init_mint_extensions(&mut state, &self.extensions, &mint_key);
        }

        let lamports = self
            .lamports
            .unwrap_or_else(|| Rent::default().minimum_balance(buffer.len()));

        KeyedAccount {
            key: mint_key,
            account: Account {
                lamports,
                data: buffer,
                owner: self.token_program.id(),
                ..Default::default()
            },
        }
    }
}