spl-token-2022 12.0.0

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

use {
    crate::{
        extension::confidential_mint_burn::processor::process_confidential_burn,
        pod_instruction::{AmountCheckedData, AmountData},
        processor::{BurnInstructionVariant, InstructionVariant, Processor},
    },
    pinocchio::{account::next_account_view, AccountView},
    solana_address::Address,
    solana_msg::msg,
    solana_program_error::{ProgramError, ProgramResult},
    spl_token_2022_interface::{
        check_program_account,
        extension::{
            confidential_mint_burn::instruction::BurnInstructionData,
            permissioned_burn::{
                instruction::{InitializeInstructionData, PermissionedBurnInstruction},
                PermissionedBurnConfig,
            },
            BaseStateWithExtensionsMut, PodStateWithExtensionsMut,
        },
        instruction::{decode_instruction_data, decode_instruction_type},
        pod::PodMint,
    },
};

fn process_initialize(
    _program_id: &Address,
    accounts: &mut [AccountView],
    authority: &Address,
) -> ProgramResult {
    let account_info_iter = &mut accounts.iter_mut();
    let mint_account_info = next_account_view(account_info_iter)?;
    check_program_account(mint_account_info.owner())?;

    let mut mint_data = mint_account_info.try_borrow_mut()?;
    let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;

    let extension = mint.init_extension::<PermissionedBurnConfig>(true)?;
    extension.authority = Some(*authority)
        .try_into()
        .map_err(|_| ProgramError::InvalidArgument)?;

    Ok(())
}

pub(crate) fn process_instruction(
    program_id: &Address,
    accounts: &mut [AccountView],
    input: &[u8],
) -> ProgramResult {
    check_program_account(program_id)?;

    match decode_instruction_type(input)? {
        PermissionedBurnInstruction::Initialize => {
            msg!("PermissionedBurnInstruction::Initialize");
            let InitializeInstructionData { authority } = decode_instruction_data(input)?;
            process_initialize(program_id, accounts, authority)
        }
        PermissionedBurnInstruction::Burn => {
            msg!("PermissionedBurnInstruction::Burn");
            let data = decode_instruction_data::<AmountData>(input)?;
            Processor::process_burn(
                program_id,
                accounts,
                data.amount.into(),
                BurnInstructionVariant::Permissioned,
                InstructionVariant::Unchecked,
            )
        }
        PermissionedBurnInstruction::BurnChecked => {
            msg!("PermissionedBurnInstruction::BurnChecked");
            let data = decode_instruction_data::<AmountCheckedData>(input)?;
            Processor::process_burn(
                program_id,
                accounts,
                data.amount.into(),
                BurnInstructionVariant::Permissioned,
                InstructionVariant::Checked {
                    decimals: data.decimals,
                },
            )
        }
        PermissionedBurnInstruction::ConfidentialBurn => {
            msg!("PermissionedBurnInstruction::ConfidentialBurn");
            let data = decode_instruction_data::<BurnInstructionData>(input)?;
            process_confidential_burn(
                program_id,
                accounts,
                data,
                BurnInstructionVariant::Permissioned,
            )
        }
    }
}