Skip to content
This repository was archived by the owner on Mar 11, 2025. It is now read-only.

Commit 3ab6e24

Browse files
author
Joe C
authored
token 2022: add UpdateGroupMaxSize instruction from SPL Token Group interface (#5626)
* token 2022: add `UpdateGroupMaxSize` instruction from SPL Token Group interface * make it a 4 !
1 parent 82713ca commit 3ab6e24

File tree

3 files changed

+316
-2
lines changed

3 files changed

+316
-2
lines changed

‎token/client/src/token.rs

+21
Original file line numberDiff line numberDiff line change
@@ -3722,4 +3722,25 @@ where
37223722
));
37233723
self.process_ixs(&instructions, signing_keypairs).await
37243724
}
3725+
3726+
/// Update a token-group max size on a mint
3727+
pub async fn token_group_update_max_size<S: Signers>(
3728+
&self,
3729+
update_authority: &Pubkey,
3730+
new_max_size: u32,
3731+
signing_keypairs: &S,
3732+
) -> TokenResult<T::Output> {
3733+
self.process_ixs(
3734+
&[
3735+
spl_token_group_interface::instruction::update_group_max_size(
3736+
&self.program_id,
3737+
&self.pubkey,
3738+
update_authority,
3739+
new_max_size,
3740+
),
3741+
],
3742+
signing_keypairs,
3743+
)
3744+
.await
3745+
}
37253746
}

‎token/program-2022-test/tests/token_group_update_max_size.rs

+249
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,249 @@
1+
#![cfg(feature = "test-sbf")]
2+
#![allow(clippy::items_after_test_module)]
3+
4+
mod program_test;
5+
use {
6+
program_test::TestContext,
7+
solana_program_test::{processor, tokio, ProgramTest},
8+
solana_sdk::{
9+
account::Account as SolanaAccount, instruction::InstructionError, pubkey::Pubkey,
10+
signature::Signer, signer::keypair::Keypair, transaction::TransactionError,
11+
transport::TransportError,
12+
},
13+
spl_token_2022::{extension::BaseStateWithExtensions, processor::Processor},
14+
spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
15+
spl_token_group_interface::{
16+
error::TokenGroupError, instruction::update_group_max_size, state::TokenGroup,
17+
},
18+
std::{convert::TryInto, sync::Arc},
19+
test_case::test_case,
20+
};
21+
22+
fn setup_program_test() -> ProgramTest {
23+
let mut program_test = ProgramTest::default();
24+
program_test.add_program(
25+
"spl_token_2022",
26+
spl_token_2022::id(),
27+
processor!(Processor::process),
28+
);
29+
program_test
30+
}
31+
32+
async fn setup(mint: Keypair, authority: &Pubkey) -> TestContext {
33+
let program_test = setup_program_test();
34+
35+
let context = program_test.start_with_context().await;
36+
let context = Arc::new(tokio::sync::Mutex::new(context));
37+
let mut context = TestContext {
38+
context,
39+
token_context: None,
40+
};
41+
let group_address = Some(mint.pubkey());
42+
context
43+
.init_token_with_mint_keypair_and_freeze_authority(
44+
mint,
45+
vec![ExtensionInitializationParams::GroupPointer {
46+
authority: Some(*authority),
47+
group_address,
48+
}],
49+
None,
50+
)
51+
.await
52+
.unwrap();
53+
context
54+
}
55+
56+
// Successful attempts to set higher than size
57+
#[test_case(0, 0, 10)]
58+
#[test_case(5, 0, 10)]
59+
#[test_case(50, 0, 200_000)]
60+
#[test_case(100_000, 100_000, 200_000)]
61+
#[test_case(50, 0, 300_000_000)]
62+
#[test_case(100_000, 100_000, 300_000_000)]
63+
#[test_case(100_000_000, 100_000_000, 300_000_000)]
64+
#[test_case(0, 0, u32::MAX)]
65+
#[test_case(200_000, 200_000, u32::MAX)]
66+
#[test_case(300_000_000, 300_000_000, u32::MAX)]
67+
// Attempts to set lower than size
68+
#[test_case(5, 5, 4)]
69+
#[test_case(200_000, 200_000, 50)]
70+
#[test_case(200_000, 200_000, 100_000)]
71+
#[test_case(300_000_000, 300_000_000, 50)]
72+
#[test_case(u32::MAX, u32::MAX, 0)]
73+
#[tokio::test]
74+
async fn test_update_group_max_size(max_size: u32, size: u32, new_max_size: u32) {
75+
let authority = Keypair::new();
76+
let mint_keypair = Keypair::new();
77+
let mut test_context = setup(mint_keypair.insecure_clone(), &authority.pubkey()).await;
78+
let payer_pubkey = test_context.context.lock().await.payer.pubkey();
79+
let token_context = test_context.token_context.take().unwrap();
80+
81+
let update_authority = Keypair::new();
82+
let mut token_group = TokenGroup::new(
83+
&mint_keypair.pubkey(),
84+
Some(update_authority.pubkey()).try_into().unwrap(),
85+
max_size,
86+
);
87+
88+
token_context
89+
.token
90+
.token_group_initialize_with_rent_transfer(
91+
&payer_pubkey,
92+
&token_context.mint_authority.pubkey(),
93+
&update_authority.pubkey(),
94+
max_size,
95+
&[&token_context.mint_authority],
96+
)
97+
.await
98+
.unwrap();
99+
100+
{
101+
// Update the group's size manually
102+
let mut context = test_context.context.lock().await;
103+
104+
let group_mint_account = context
105+
.banks_client
106+
.get_account(mint_keypair.pubkey())
107+
.await
108+
.unwrap()
109+
.unwrap();
110+
111+
let old_data = context
112+
.banks_client
113+
.get_account(mint_keypair.pubkey())
114+
.await
115+
.unwrap()
116+
.unwrap()
117+
.data;
118+
119+
let data = {
120+
// 0....81: mint
121+
// 82...164: padding
122+
// 165..166: account type
123+
// 167..170: extension discriminator (GroupPointer)
124+
// 171..202: authority
125+
// 203..234: group pointer
126+
// 235..238: extension discriminator (TokenGroup)
127+
// 239..270: mint
128+
// 271..302: update_authority
129+
// 303..306: size
130+
// 307..310: max_size
131+
let (front, back) = old_data.split_at(302);
132+
let (_, back) = back.split_at(4);
133+
let size_bytes = size.to_le_bytes();
134+
let mut bytes = vec![];
135+
bytes.extend_from_slice(front);
136+
bytes.extend_from_slice(&size_bytes);
137+
bytes.extend_from_slice(back);
138+
bytes
139+
};
140+
141+
context.set_account(
142+
&mint_keypair.pubkey(),
143+
&SolanaAccount {
144+
data,
145+
..group_mint_account
146+
}
147+
.into(),
148+
);
149+
150+
token_group.size = size.into();
151+
}
152+
153+
token_group.max_size = new_max_size.into();
154+
155+
if new_max_size < size {
156+
let error = token_context
157+
.token
158+
.token_group_update_max_size(
159+
&update_authority.pubkey(),
160+
new_max_size,
161+
&[&update_authority],
162+
)
163+
.await
164+
.unwrap_err();
165+
assert_eq!(
166+
error,
167+
TokenClientError::Client(Box::new(TransportError::TransactionError(
168+
TransactionError::InstructionError(
169+
0,
170+
InstructionError::Custom(TokenGroupError::SizeExceedsNewMaxSize as u32)
171+
)
172+
))),
173+
);
174+
} else {
175+
token_context
176+
.token
177+
.token_group_update_max_size(
178+
&update_authority.pubkey(),
179+
new_max_size,
180+
&[&update_authority],
181+
)
182+
.await
183+
.unwrap();
184+
185+
let mint_info = token_context.token.get_mint_info().await.unwrap();
186+
let fetched_group = mint_info.get_extension::<TokenGroup>().unwrap();
187+
assert_eq!(fetched_group, &token_group);
188+
}
189+
}
190+
191+
#[tokio::test]
192+
async fn fail_authority_checks() {
193+
let authority = Keypair::new();
194+
let mint_keypair = Keypair::new();
195+
let mut test_context = setup(mint_keypair, &authority.pubkey()).await;
196+
let payer_pubkey = test_context.context.lock().await.payer.pubkey();
197+
let token_context = test_context.token_context.take().unwrap();
198+
199+
let update_authority = Keypair::new();
200+
token_context
201+
.token
202+
.token_group_initialize_with_rent_transfer(
203+
&payer_pubkey,
204+
&token_context.mint_authority.pubkey(),
205+
&update_authority.pubkey(),
206+
10,
207+
&[&token_context.mint_authority],
208+
)
209+
.await
210+
.unwrap();
211+
212+
// no signature
213+
let mut instruction = update_group_max_size(
214+
&spl_token_2022::id(),
215+
token_context.token.get_address(),
216+
&update_authority.pubkey(),
217+
20,
218+
);
219+
instruction.accounts[1].is_signer = false;
220+
221+
let error = token_context
222+
.token
223+
.process_ixs(&[instruction], &[] as &[&dyn Signer; 0]) // yuck, but the compiler needs it
224+
.await
225+
.unwrap_err();
226+
assert_eq!(
227+
error,
228+
TokenClientError::Client(Box::new(TransportError::TransactionError(
229+
TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
230+
)))
231+
);
232+
233+
// wrong authority
234+
let wrong_authority = Keypair::new();
235+
let error = token_context
236+
.token
237+
.token_group_update_max_size(&wrong_authority.pubkey(), 20, &[&wrong_authority])
238+
.await
239+
.unwrap_err();
240+
assert_eq!(
241+
error,
242+
TokenClientError::Client(Box::new(TransportError::TransactionError(
243+
TransactionError::InstructionError(
244+
0,
245+
InstructionError::Custom(TokenGroupError::IncorrectUpdateAuthority as u32)
246+
)
247+
)))
248+
);
249+
}

‎token/program-2022/src/extension/token_group/processor.rs

+46-2
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use {
66
error::TokenError,
77
extension::{
88
alloc_and_serialize, group_pointer::GroupPointer, BaseStateWithExtensions,
9-
StateWithExtensions,
9+
StateWithExtensions, StateWithExtensionsMut,
1010
},
1111
state::Mint,
1212
},
@@ -18,13 +18,29 @@ use {
1818
program_option::COption,
1919
pubkey::Pubkey,
2020
},
21+
spl_pod::optional_keys::OptionalNonZeroPubkey,
2122
spl_token_group_interface::{
2223
error::TokenGroupError,
23-
instruction::{InitializeGroup, TokenGroupInstruction},
24+
instruction::{InitializeGroup, TokenGroupInstruction, UpdateGroupMaxSize},
2425
state::TokenGroup,
2526
},
2627
};
2728

29+
fn check_update_authority(
30+
update_authority_info: &AccountInfo,
31+
expected_update_authority: &OptionalNonZeroPubkey,
32+
) -> Result<(), ProgramError> {
33+
if !update_authority_info.is_signer {
34+
return Err(ProgramError::MissingRequiredSignature);
35+
}
36+
let update_authority = Option::<Pubkey>::from(*expected_update_authority)
37+
.ok_or(TokenGroupError::ImmutableGroup)?;
38+
if update_authority != *update_authority_info.key {
39+
return Err(TokenGroupError::IncorrectUpdateAuthority.into());
40+
}
41+
Ok(())
42+
}
43+
2844
/// Processes a [InitializeGroup](enum.TokenGroupInstruction.html) instruction.
2945
pub fn process_initialize_group(
3046
_program_id: &Pubkey,
@@ -76,6 +92,30 @@ pub fn process_initialize_group(
7692
Ok(())
7793
}
7894

95+
/// Processes an
96+
/// [UpdateGroupMaxSize](enum.GroupInterfaceInstruction.html)
97+
/// instruction
98+
pub fn process_update_group_max_size(
99+
_program_id: &Pubkey,
100+
accounts: &[AccountInfo],
101+
data: UpdateGroupMaxSize,
102+
) -> ProgramResult {
103+
let account_info_iter = &mut accounts.iter();
104+
105+
let group_info = next_account_info(account_info_iter)?;
106+
let update_authority_info = next_account_info(account_info_iter)?;
107+
108+
let mut buffer = group_info.try_borrow_mut_data()?;
109+
let mut state = StateWithExtensionsMut::<Mint>::unpack(&mut buffer)?;
110+
let group = state.get_extension_mut::<TokenGroup>()?;
111+
112+
check_update_authority(update_authority_info, &group.update_authority)?;
113+
114+
group.update_max_size(data.max_size.into())?;
115+
116+
Ok(())
117+
}
118+
79119
/// Processes an [Instruction](enum.Instruction.html).
80120
pub fn process_instruction(
81121
program_id: &Pubkey,
@@ -87,6 +127,10 @@ pub fn process_instruction(
87127
msg!("TokenGroupInstruction: InitializeGroup");
88128
process_initialize_group(program_id, accounts, data)
89129
}
130+
TokenGroupInstruction::UpdateGroupMaxSize(data) => {
131+
msg!("TokenGroupInstruction: UpdateGroupMaxSize");
132+
process_update_group_max_size(program_id, accounts, data)
133+
}
90134
_ => Err(ProgramError::InvalidInstructionData),
91135
}
92136
}

0 commit comments

Comments
 (0)