[token cli]: add support for group pointer

This PR adds support for the group pointer in the Token CLI!

Author: Joe C

token/cli/src/clap_app.rs

@@ -116,6 +116,7 @@ pub enum CommandName {
     DepositConfidentialTokens,
     WithdrawConfidentialTokens,
     ApplyPendingBalance,
+    UpdateGroupAddress,
 }
 impl fmt::Display for CommandName {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -184,6 +185,7 @@ pub enum CliAuthorityType {
     ConfidentialTransferFee,
     MetadataPointer,
     Metadata,
+    GroupPointer,
 }
 impl TryFrom<CliAuthorityType> for AuthorityType {
     type Error = Error;
@@ -209,6 +211,7 @@ impl TryFrom<CliAuthorityType> for AuthorityType {
             CliAuthorityType::Metadata => {
                 Err("Metadata authority does not map to a token authority type".into())
             }
+            CliAuthorityType::GroupPointer => Ok(AuthorityType::GroupPointer),
         }
     }
 }
@@ -670,6 +673,17 @@ pub fn app<'a, 'b>(
                             "Specify address that stores token metadata."
                         ),
                 )
+                .arg(
+                    Arg::with_name("group_address")
+                        .long("group-address")
+                        .value_name("ADDRESS")
+                        .validator(is_valid_pubkey)
+                        .takes_value(true)
+                        .conflicts_with("enable_group")
+                        .help(
+                            "Specify address that stores token group configurations."
+                        ),
+                )
                 .arg(
                     Arg::with_name("enable_non_transferable")
                         .long("enable-non-transferable")
@@ -739,6 +753,13 @@ pub fn app<'a, 'b>(
                         .takes_value(false)
                         .help("Enables metadata in the mint. The mint authority must initialize the metadata."),
                 )
+                .arg(
+                    Arg::with_name("enable_group")
+                        .long("enable-group")
+                        .conflicts_with("group_address")
+                        .takes_value(false)
+                        .help("Enables group configurations in the mint. The mint authority must initialize the group."),
+                )
                 .nonce_args(true)
                 .arg(memo_arg())
         )
@@ -1897,6 +1918,49 @@ pub fn app<'a, 'b>(
                 .arg(multisig_signer_arg())
                 .nonce_args(true)
         )
+        .subcommand(
+            SubCommand::with_name(CommandName::UpdateGroupAddress.into())
+                .about("Updates group pointer address for the mint. Requires the group pointer extension.")
+                .arg(
+                    Arg::with_name("token")
+                        .validator(is_valid_pubkey)
+                        .value_name("TOKEN_MINT_ADDRESS")
+                        .takes_value(true)
+                        .index(1)
+                        .required(true)
+                        .help("The address of the token mint to update the group pointer address"),
+                )
+                .arg(
+                    Arg::with_name("group_address")
+                        .index(2)
+                        .validator(is_valid_pubkey)
+                        .value_name("GROUP_ADDRESS")
+                        .takes_value(true)
+                        .required_unless("disable")
+                        .help("Specify address that stores token's group-pointer"),
+                )
+                .arg(
+                    Arg::with_name("disable")
+                        .long("disable")
+                        .takes_value(false)
+                        .conflicts_with("group_address")
+                        .help("Unset group pointer address.")
+                )
+                .arg(
+                    Arg::with_name("authority")
+                        .long("authority")
+                        .value_name("KEYPAIR")
+                        .validator(is_valid_signer)
+                        .takes_value(true)
+                        .help(
+                            "Specify the token's group-pointer authority. \
+                            This may be a keypair file or the ASK keyword. \
+                            Defaults to the client keypair.",
+                        ),
+                )
+                .arg(multisig_signer_arg())
+                .nonce_args(true)
+        )
         .subcommand(
             SubCommand::with_name(CommandName::WithdrawWithheldTokens.into())
                 .about("Withdraw withheld transfer fee tokens from mint and / or account(s)")

token/cli/src/command.rs

@@ -46,6 +46,7 @@ use {
             confidential_transfer_fee::ConfidentialTransferFeeConfig,
             cpi_guard::CpiGuard,
             default_account_state::DefaultAccountState,
+            group_pointer::GroupPointer,
             interest_bearing_mint::InterestBearingConfig,
             memo_transfer::MemoTransfer,
             metadata_pointer::MetadataPointer,
@@ -187,12 +188,14 @@ async fn command_create_token(
     enable_permanent_delegate: bool,
     memo: Option<String>,
     metadata_address: Option<Pubkey>,
+    group_address: Option<Pubkey>,
     rate_bps: Option<i16>,
     default_account_state: Option<AccountState>,
     transfer_fee: Option<(u16, u64)>,
     confidential_transfer_auto_approve: Option<bool>,
     transfer_hook_program_id: Option<Pubkey>,
     enable_metadata: bool,
+    enable_group: bool,
     bulk_signers: Vec<Arc<dyn Signer>>,
 ) -> CommandResult {
     println_display(
@@ -281,6 +284,18 @@ async fn command_create_token(
         });
     }
 
+    if group_address.is_some() || enable_group {
+        let group_address = if enable_group {
+            Some(token_pubkey)
+        } else {
+            group_address
+        };
+        extensions.push(ExtensionInitializationParams::GroupPointer {
+            authority: Some(authority),
+            group_address,
+        });
+    }
+
     let res = token
         .create_mint(
             &authority,
@@ -303,6 +318,15 @@ async fn command_create_token(
         );
     }
 
+    if enable_group {
+        println_display(
+            config,
+            format!(
+                "To initialize group configurations inside the mint, please run `spl-token initialize-group {token_pubkey} <MAX_SIZE>`, and sign with the mint authority.",
+            ),
+        );
+    }
+
     Ok(match tx_return {
         TransactionReturnData::CliSignature(cli_signature) => format_output(
             CliCreateToken {
@@ -837,6 +861,16 @@ async fn command_authorize(
                         Err(format!("Mint `{account}` does not support metadata"))
                     }
                 }
+                CliAuthorityType::GroupPointer => {
+                    if let Ok(extension) = mint.get_extension::<GroupPointer>() {
+                        Ok(Option::<Pubkey>::from(extension.authority))
+                    } else {
+                        Err(format!(
+                            "Mint `{}` does not support a group pointer",
+                            account
+                        ))
+                    }
+                }
             }?;
 
             Ok((account, previous_authority))
@@ -875,7 +909,8 @@ async fn command_authorize(
                 | CliAuthorityType::TransferHookProgramId
                 | CliAuthorityType::ConfidentialTransferFee
                 | CliAuthorityType::MetadataPointer
-                | CliAuthorityType::Metadata => Err(format!(
+                | CliAuthorityType::Metadata
+                | CliAuthorityType::GroupPointer => Err(format!(
                     "Authority type `{auth_str}` not supported for SPL Token accounts",
                 )),
                 CliAuthorityType::Owner => {
@@ -2483,6 +2518,33 @@ async fn command_update_metadata_pointer_address(
     })
 }
 
+async fn command_update_group_pointer_address(
+    config: &Config<'_>,
+    token_pubkey: Pubkey,
+    authority: Pubkey,
+    new_group_address: Option<Pubkey>,
+    bulk_signers: BulkSigners,
+) -> CommandResult {
+    if config.sign_only {
+        panic!("Config can not be sign-only for updating group pointer address.");
+    }
+
+    let token = token_client_from_config(config, &token_pubkey, None)?;
+    let res = token
+        .update_group_address(&authority, new_group_address, &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_update_default_account_state(
     config: &Config<'_>,
     token_pubkey: Pubkey,
@@ -3190,6 +3252,7 @@ pub async fn process_command<'a>(
             let memo = value_t!(arg_matches, "memo", String).ok();
             let rate_bps = value_t!(arg_matches, "interest_rate", i16).ok();
             let metadata_address = value_t!(arg_matches, "metadata_address", Pubkey).ok();
+            let group_address = value_t!(arg_matches, "group_address", Pubkey).ok();
 
             let transfer_fee = arg_matches.values_of("transfer_fee").map(|mut v| {
                 (
@@ -3234,12 +3297,14 @@ pub async fn process_command<'a>(
                 arg_matches.is_present("enable_permanent_delegate"),
                 memo,
                 metadata_address,
+                group_address,
                 rate_bps,
                 default_account_state,
                 transfer_fee,
                 confidential_transfer_auto_approve,
                 transfer_hook_program_id,
                 arg_matches.is_present("enable_metadata"),
+                arg_matches.is_present("enable_group"),
                 bulk_signers,
             )
             .await
@@ -3905,6 +3970,28 @@ pub async fn process_command<'a>(
             )
             .await
         }
+        (CommandName::UpdateGroupAddress, arg_matches) => {
+            // Since account is required argument it will always be present
+            let token = pubkey_of_signer(arg_matches, "token", &mut wallet_manager)
+                .unwrap()
+                .unwrap();
+
+            let (authority_signer, authority) =
+                config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
+            if config.multisigner_pubkeys.is_empty() {
+                push_signer_with_dedup(authority_signer, &mut bulk_signers);
+            }
+            let group_address = value_t!(arg_matches, "group_address", Pubkey).ok();
+
+            command_update_group_pointer_address(
+                config,
+                token,
+                authority,
+                group_address,
+                bulk_signers,
+            )
+            .await
+        }
         (CommandName::WithdrawWithheldTokens, arg_matches) => {
             let (authority_signer, authority) = config.signer_or_default(
                 arg_matches,

token/cli/tests/command.rs

@@ -20,6 +20,7 @@ use {
             confidential_transfer::{ConfidentialTransferAccount, ConfidentialTransferMint},
             cpi_guard::CpiGuard,
             default_account_state::DefaultAccountState,
+            group_pointer::GroupPointer,
             interest_bearing_mint::InterestBearingConfig,
             memo_transfer::MemoTransfer,
             metadata_pointer::MetadataPointer,
@@ -124,6 +125,7 @@ async fn main() {
         async_trial!(withdraw_excess_lamports_from_mint, test_validator, payer),
         async_trial!(withdraw_excess_lamports_from_account, test_validator, payer),
         async_trial!(metadata_pointer, test_validator, payer),
+        async_trial!(group_pointer, test_validator, payer),
         async_trial!(transfer_hook, test_validator, payer),
         async_trial!(metadata, test_validator, payer),
         // GC messes with every other test, so have it on its own test validator
@@ -3275,6 +3277,89 @@ async fn metadata_pointer(test_validator: &TestValidator, payer: &Keypair) {
     );
 }
 
+async fn group_pointer(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 group_address = Pubkey::new_unique();
+
+    let result = process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::CreateToken.into(),
+            "--program-id",
+            &program_id.to_string(),
+            "--group-address",
+            &group_address.to_string(),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let value: serde_json::Value = serde_json::from_str(&result).unwrap();
+    let mint = Pubkey::from_str(value["commandOutput"]["address"].as_str().unwrap()).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::<GroupPointer>().unwrap();
+
+    assert_eq!(
+        extension.group_address,
+        Some(group_address).try_into().unwrap()
+    );
+
+    let new_group_address = Pubkey::new_unique();
+
+    let _new_result = process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::UpdateGroupAddress.into(),
+            &mint.to_string(),
+            &new_group_address.to_string(),
+        ],
+    )
+    .await;
+
+    let new_account = config.rpc_client.get_account(&mint).await.unwrap();
+    let new_mint_state = StateWithExtensionsOwned::<Mint>::unpack(new_account.data).unwrap();
+
+    let new_extension = new_mint_state.get_extension::<GroupPointer>().unwrap();
+
+    assert_eq!(
+        new_extension.group_address,
+        Some(new_group_address).try_into().unwrap()
+    );
+
+    let _result_with_disable = process_test_command(
+        &config,
+        payer,
+        &[
+            "spl-token",
+            CommandName::UpdateGroupAddress.into(),
+            &mint.to_string(),
+            "--disable",
+        ],
+    )
+    .await
+    .unwrap();
+
+    let new_account_disbale = config.rpc_client.get_account(&mint).await.unwrap();
+    let new_mint_state_disable =
+        StateWithExtensionsOwned::<Mint>::unpack(new_account_disbale.data).unwrap();
+
+    let new_extension_disable = new_mint_state_disable
+        .get_extension::<GroupPointer>()
+        .unwrap();
+
+    assert_eq!(
+        new_extension_disable.group_address,
+        None.try_into().unwrap()
+    );
+}
+
 async fn transfer_hook(test_validator: &TestValidator, payer: &Keypair) {
     let program_id = spl_token_2022::id();
     let mut config = test_config_with_default_signer(test_validator, payer, &program_id);