name-tokenizer 2.1.0

A Solana program which enables the tokenization of a Solana Name Service into an NFT
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

use solana_program::{
    account_info::AccountInfo, entrypoint::ProgramResult, msg, program::invoke_signed,
    program_error::ProgramError, program_pack::Pack, pubkey::Pubkey, rent::Rent,
    system_instruction, system_instruction::create_account, sysvar::Sysvar,
};

#[allow(missing_docs)]
pub struct Cpi {}

impl Cpi {
    #[allow(missing_docs)]
    pub fn create_account<'a>(
        program_id: &Pubkey,
        system_program: &AccountInfo<'a>,
        fee_payer: &AccountInfo<'a>,
        account_to_create: &AccountInfo<'a>,
        signer_seeds: &[&[u8]],
        space: usize,
    ) -> ProgramResult {
        let account_lamports = account_to_create.lamports();
        if account_lamports != 0 && account_to_create.data_is_empty() {
            let defund_created_account = system_instruction::transfer(
                account_to_create.key,
                fee_payer.key,
                account_lamports,
            );
            invoke_signed(
                &defund_created_account,
                &[
                    system_program.clone(),
                    fee_payer.clone(),
                    account_to_create.clone(),
                ],
                &[signer_seeds],
            )?;
        }
        let create_state_instruction = create_account(
            fee_payer.key,
            account_to_create.key,
            Rent::get()?.minimum_balance(space),
            space as u64,
            program_id,
        );

        invoke_signed(
            &create_state_instruction,
            &[
                system_program.clone(),
                fee_payer.clone(),
                account_to_create.clone(),
            ],
            &[signer_seeds],
        )
    }

    #[allow(clippy::too_many_arguments)]
    pub fn allocate_and_create_token_account<'a>(
        token_account_owner: &Pubkey,
        spl_token_program: &AccountInfo<'a>,
        payer_info: &AccountInfo<'a>,
        signer_seeds: &[&[u8]],
        token_account: &AccountInfo<'a>,
        mint_account: &AccountInfo<'a>,
        rent_account: &AccountInfo<'a>,
        system_program_info: &AccountInfo<'a>,
    ) -> Result<(), ProgramError> {
        msg!("Initializing token account");
        let size = spl_token::state::Account::LEN;
        let required_lamports = Rent::get()?.minimum_balance(size);
        let ix_allocate = create_account(
            payer_info.key,
            token_account.key,
            required_lamports,
            size as u64,
            &spl_token::ID,
        );
        invoke_signed(
            &ix_allocate,
            &[
                system_program_info.clone(),
                payer_info.clone(),
                token_account.clone(),
            ],
            &[signer_seeds],
        )?;
        let ix_initialize = spl_token::instruction::initialize_account2(
            &spl_token::ID,
            token_account.key,
            mint_account.key,
            token_account_owner,
        )?;
        invoke_signed(
            &ix_initialize,
            &[
                spl_token_program.clone(),
                token_account.clone(),
                mint_account.clone(),
                rent_account.clone(),
            ],
            &[signer_seeds],
        )?;
        Ok(())
    }
}