spl-token-2022-interface 3.0.0

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

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use {
    crate::{
        check_program_account,
        instruction::{encode_instruction, TokenInstruction},
    },
    alloc::vec,
    bytemuck::{Pod, Zeroable},
    num_enum::{IntoPrimitive, TryFromPrimitive},
    solana_address::Address,
    solana_instruction::{AccountMeta, Instruction},
    solana_program_error::ProgramError,
};

/// Pausable extension instructions
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
#[derive(Clone, Copy, Debug, PartialEq, IntoPrimitive, TryFromPrimitive)]
#[repr(u8)]
pub enum PausableInstruction {
    /// Initialize the pausable extension for the given mint account
    ///
    /// Fails if the account has already been initialized, so must be called
    /// before `InitializeMint`.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[writable]`  The mint account to initialize.
    ///
    /// Data expected by this instruction:
    ///   `crate::extension::pausable::instruction::InitializeInstructionData`
    Initialize,
    /// Pause minting, burning, and transferring for the mint.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[writable]` The mint to update.
    ///   1. `[signer]` The mint's pause authority.
    ///
    ///   * Multisignature authority
    ///   0. `[writable]` The mint to update.
    ///   1. `[]` The mint's multisignature pause authority.
    ///   2. `..2+M` `[signer]` M signer accounts.
    Pause,
    /// Resume minting, burning, and transferring for the mint.
    ///
    /// Accounts expected by this instruction:
    ///
    ///   0. `[writable]` The mint to update.
    ///   1. `[signer]` The mint's pause authority.
    ///
    ///   * Multisignature authority
    ///   0. `[writable]` The mint to update.
    ///   1. `[]` The mint's multisignature pause authority.
    ///   2. `..2+M` `[signer]` M signer accounts.
    Resume,
}

/// Data expected by `PausableInstruction::Initialize`
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
#[derive(Clone, Copy, Pod, Zeroable)]
#[repr(C)]
pub struct InitializeInstructionData {
    /// The public key for the account that can pause the mint
    pub authority: Address,
}

/// Create an `Initialize` instruction
pub fn initialize(
    token_program_id: &Address,
    mint: &Address,
    authority: &Address,
) -> Result<Instruction, ProgramError> {
    check_program_account(token_program_id)?;
    let accounts = vec![AccountMeta::new(*mint, false)];
    Ok(encode_instruction(
        token_program_id,
        accounts,
        TokenInstruction::PausableExtension,
        PausableInstruction::Initialize,
        &InitializeInstructionData {
            authority: *authority,
        },
    ))
}

/// Create a `Pause` instruction
pub fn pause(
    token_program_id: &Address,
    mint: &Address,
    authority: &Address,
    signers: &[&Address],
) -> Result<Instruction, ProgramError> {
    check_program_account(token_program_id)?;
    let mut accounts = vec![
        AccountMeta::new(*mint, false),
        AccountMeta::new_readonly(*authority, signers.is_empty()),
    ];
    for signer_pubkey in signers.iter() {
        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
    }
    Ok(encode_instruction(
        token_program_id,
        accounts,
        TokenInstruction::PausableExtension,
        PausableInstruction::Pause,
        &(),
    ))
}

/// Create a `Resume` instruction
pub fn resume(
    token_program_id: &Address,
    mint: &Address,
    authority: &Address,
    signers: &[&Address],
) -> Result<Instruction, ProgramError> {
    check_program_account(token_program_id)?;
    let mut accounts = vec![
        AccountMeta::new(*mint, false),
        AccountMeta::new_readonly(*authority, signers.is_empty()),
    ];
    for signer_pubkey in signers.iter() {
        accounts.push(AccountMeta::new_readonly(**signer_pubkey, true));
    }
    Ok(encode_instruction(
        token_program_id,
        accounts,
        TokenInstruction::PausableExtension,
        PausableInstruction::Resume,
        &(),
    ))
}