token-cli: Add command_update_group_max_size to token CLI (#6150)

* add `spl-token-group-interface` to `spl-token-cli`

* add cli for updating token group max-size

* Add test for `command_update_group_max_size`

* Rewrote subcommand description

* removed commented out code

* changed update_authority validator to is_valid_signer

* changed update_authority value_name to Signer

* fixed subcommand about field

Author: tonton-sol

token/cli/src/clap_app.rs

@@ -108,6 +108,7 @@ pub enum CommandName {
     InitializeMetadata,
     UpdateMetadata,
     InitializeGroup,
+    UpdateGroupMaxSize,
     UpdateConfidentialTransferSettings,
     ConfigureConfidentialTransferAccount,
     EnableConfidentialCredits,
@@ -1007,6 +1008,39 @@ pub fn app<'a, 'b>(
                         ),
                 )
         )
+        .subcommand(
+            SubCommand::with_name(CommandName::UpdateGroupMaxSize.into())
+                .about("Updates the maximum number of members for a group.")
+                .arg(
+                    Arg::with_name("token")
+                        .validator(is_valid_pubkey)
+                        .value_name("TOKEN_MINT_ADDRESS")
+                        .takes_value(true)
+                        .required(true)
+                        .index(1)
+                        .help("The token address of the group account."),
+                )
+                .arg(
+                        Arg::with_name("new_max_size")
+                        .validator(is_amount)
+                        .value_name("NEW_MAX_SIZE")
+                        .takes_value(true)
+                        .required(true)
+                        .index(2)
+                        .help("The number of members in the group."),
+                    )
+                .arg(
+                    Arg::with_name("update_authority")
+                        .long("update-authority")
+                        .value_name("SIGNER")
+                        .validator(is_valid_signer)
+                        .takes_value(true)
+                        .help(
+                            "Specify the update authority address. \
+                             Defaults to the client keypair address."
+                        ),
+                )
+        )
         .subcommand(
             SubCommand::with_name(CommandName::CreateAccount.into())
                 .about("Create a new token account")

token/cli/src/command.rs

@@ -627,6 +627,32 @@ async fn command_initialize_group(
         }
     })
 }
+
+#[allow(clippy::too_many_arguments)]
+async fn command_update_group_max_size(
+    config: &Config<'_>,
+    token_pubkey: Pubkey,
+    update_authority: Pubkey,
+    new_max_size: u32,
+    bulk_signers: Vec<Arc<dyn Signer>>,
+) -> CommandResult {
+    let token = token_client_from_config(config, &token_pubkey, None)?;
+
+    let res = token
+        .token_group_update_max_size(&update_authority, new_max_size, &bulk_signers)
+        .await?;
+
+    let tx_return = finish_tx(config, &res, false).await?;
+    Ok(match tx_return {
+        TransactionReturnData::CliSignature(signature) => {
+            config.output_format.formatted_string(&signature)
+        }
+        TransactionReturnData::CliSignOnlyData(sign_only_data) => {
+            config.output_format.formatted_string(&sign_only_data)
+        }
+    })
+}
+
 async fn command_set_transfer_fee(
     config: &Config<'_>,
     token_pubkey: Pubkey,
@@ -3507,6 +3533,24 @@ pub async fn process_command<'a>(
             )
             .await
         }
+        (CommandName::UpdateGroupMaxSize, arg_matches) => {
+            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
+                .unwrap()
+                .unwrap();
+            let new_max_size = value_t_or_exit!(arg_matches, "new_max_size", u32);
+            let (update_authority_signer, update_authority) =
+                config.signer_or_default(arg_matches, "update_authority", &mut wallet_manager);
+            let bulk_signers = vec![update_authority_signer];
+
+            command_update_group_max_size(
+                config,
+                token_pubkey,
+                update_authority,
+                new_max_size,
+                bulk_signers,
+            )
+            .await
+        }
         (CommandName::CreateAccount, arg_matches) => {
             let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
                 .unwrap()

token/cli/tests/command.rs

@@ -3842,4 +3842,27 @@ async fn group(test_validator: &TestValidator, payer: &Keypair) {
         extension_pointer.group_address,
         Some(mint).try_into().unwrap()
     );
+
+    let new_max_size = 12;
+
+    // Update token-group max-size
+    process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::UpdateGroupMaxSize.into(),
+            &mint.to_string(),
+            &new_max_size.to_string(),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let account = config.rpc_client.get_account(&mint).await.unwrap();
+
+    let updated_mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
+
+    let updated_extension = updated_mint_state.get_extension::<TokenGroup>().unwrap();
+    assert_eq!(updated_extension.max_size, new_max_size.into());
 }