[token-CLI] Add command_initialize_group to Token Cli (#6135)

* added extra metas resolution to create_recipient_associated_account_and_transfer()

* add command_initialize_group to token CLI

* added clap validator for max_size argument

* added test for initializeing a token-group

* added checks for authority and max_size for group test

Author: tonton-sol

token/cli/Cargo.toml

@@ -36,6 +36,7 @@ spl-token-2022 = { version = "1.0", path = "../program-2022", features = [
 ] }
 spl-token-client = { version = "0.8", path = "../client" }
 spl-token-metadata-interface = { version = "0.2", path = "../../token-metadata/interface" }
+spl-token-group-interface = { version = "0.1", path = "../../token-group/interface" }
 spl-associated-token-account = { version = "2.0", path = "../../associated-token-account/program", features = [
   "no-entrypoint",
 ] }

token/cli/src/clap_app.rs

@@ -107,6 +107,7 @@ pub enum CommandName {
     SetTransferHook,
     InitializeMetadata,
     UpdateMetadata,
+    InitializeGroup,
     UpdateConfidentialTransferSettings,
     ConfigureConfidentialTransferAccount,
     EnableConfidentialCredits,
@@ -960,6 +961,52 @@ pub fn app<'a, 'b>(
                 .arg(transfer_lamports_arg())
                 .offline_args_config(&SignOnlyNeedsTransferLamports{}),
         )
+        .subcommand(
+            SubCommand::with_name(CommandName::InitializeGroup.into())
+                .about("Initialize group extension on a token mint")
+                .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("max_size")
+                        .validator(is_amount)
+                        .value_name("MAX_SIZE")
+                        .takes_value(true)
+                        .required(true)
+                        .index(2)
+                        .help("The number of members in the group."),
+                    )
+                .arg(
+                    Arg::with_name("mint_authority")
+                        .long("mint-authority")
+                        .alias("owner")
+                        .value_name("KEYPAIR")
+                        .validator(is_valid_signer)
+                        .takes_value(true)
+                        .help(
+                            "Specify the mint authority keypair. \
+                             This may be a keypair file or the ASK keyword. \
+                             Defaults to the client keypair."
+                        ),
+                )
+                .arg(
+                    Arg::with_name("update_authority")
+                        .long("update-authority")
+                        .value_name("ADDRESS")
+                        .validator(is_valid_pubkey)
+                        .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

@@ -596,6 +596,37 @@ async fn command_update_metadata(
     })
 }
 
+#[allow(clippy::too_many_arguments)]
+async fn command_initialize_group(
+    config: &Config<'_>,
+    token_pubkey: Pubkey,
+    mint_authority: Pubkey,
+    update_authority: Pubkey,
+    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_initialize_with_rent_transfer(
+            &config.fee_payer()?.pubkey(),
+            &mint_authority,
+            &update_authority,
+            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,
@@ -3455,6 +3486,27 @@ pub async fn process_command<'a>(
             )
             .await
         }
+        (CommandName::InitializeGroup, arg_matches) => {
+            let token_pubkey = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
+                .unwrap()
+                .unwrap();
+            let max_size = value_t_or_exit!(arg_matches, "max_size", u32);
+            let (mint_authority_signer, mint_authority) =
+                config.signer_or_default(arg_matches, "mint_authority", &mut wallet_manager);
+            let update_authority =
+                config.pubkey_or_default(arg_matches, "update_authority", &mut wallet_manager)?;
+            let bulk_signers = vec![mint_authority_signer];
+
+            command_initialize_group(
+                config,
+                token_pubkey,
+                mint_authority,
+                update_authority,
+                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

@@ -46,6 +46,7 @@ use {
         },
         token::Token,
     },
+    spl_token_group_interface::state::TokenGroup,
     spl_token_metadata_interface::state::TokenMetadata,
     std::{ffi::OsString, path::PathBuf, str::FromStr, sync::Arc},
     tempfile::NamedTempFile,
@@ -131,6 +132,7 @@ async fn main() {
         async_trial!(group_member_pointer, test_validator, payer),
         async_trial!(transfer_hook, test_validator, payer),
         async_trial!(metadata, test_validator, payer),
+        async_trial!(group, test_validator, payer),
         async_trial!(confidential_transfer_with_fee, test_validator, payer),
         // GC messes with every other test, so have it on its own test validator
         async_trial!(gc, gc_test_validator, gc_payer),
@@ -3788,3 +3790,56 @@ async fn metadata(test_validator: &TestValidator, payer: &Keypair) {
         Some(mint).try_into().unwrap()
     );
 }
+
+async fn group(test_validator: &TestValidator, payer: &Keypair) {
+    let program_id = spl_token_2022::id();
+    let config = test_config_with_default_signer(test_validator, payer, &program_id);
+    let max_size = 10;
+
+    // Create token
+    let result = process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::CreateToken.into(),
+            "--program-id",
+            &program_id.to_string(),
+            "--enable-group",
+        ],
+    )
+    .await;
+
+    let value: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).unwrap();
+
+    // Initialize the group
+    process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::InitializeGroup.into(),
+            &mint.to_string(),
+            &max_size.to_string(),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let account = config.rpc_client.get_account(&mint).await.unwrap();
+    let mint_state = StateWithExtensionsOwned::<Mint>::unpack(account.data).unwrap();
+
+    let extension = mint_state.get_extension::<TokenGroup>().unwrap();
+    assert_eq!(
+        extension.update_authority,
+        Some(payer.pubkey()).try_into().unwrap()
+    );
+    assert_eq!(extension.max_size, max_size.into());
+
+    let extension_pointer = mint_state.get_extension::<GroupPointer>().unwrap();
+    assert_eq!(
+        extension_pointer.group_address,
+        Some(mint).try_into().unwrap()
+    );
+}