مجموعات الرموز والأعضاء

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::create_account;
use spl_token_2022_interface::{
    extension::{
        group_member_pointer::{
            instruction::initialize as initialize_group_member_pointer, GroupMemberPointer,
        },
        group_pointer::{instruction::initialize as initialize_group_pointer, GroupPointer},
        BaseStateWithExtensions, ExtensionType, StateWithExtensions,
    },
    instruction::initialize_mint,
    state::Mint,
    ID as TOKEN_2022_PROGRAM_ID,
};
use spl_token_group_interface::{
    instruction::{initialize_group, initialize_member},
    state::{TokenGroup, TokenGroupMember},
};

#[tokio::main]
async fn main() -> Result<()> {
    // Create connection to local validator
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );
    let latest_blockhash = client.get_latest_blockhash().await?;

    // Generate the authority for the mint (also acts as fee payer)
    let authority = Keypair::new();

    // Airdrop 5 SOL to authority/fee payer
    let airdrop_signature = client
        .request_airdrop(&authority.pubkey(), 5_000_000_000)
        .await?;

    loop {
        let confirmed = client.confirm_transaction(&airdrop_signature).await?;
        if confirmed {
            break;
        }
    }

    // Create group mint
    // Generate keypair to use as address of group mint
    let group_mint = Keypair::new();

    // Calculate space for mint with group pointer extension only (for account creation)
    let group_mint_space =
        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::GroupPointer])?;

    // Calculate space for mint with group pointer and group extension (for rent calculation)
    let group_mint_space_with_data = ExtensionType::try_calculate_account_len::<Mint>(&[
        ExtensionType::GroupPointer,
        ExtensionType::TokenGroup,
    ])?;

    // Get rent exempt balance for full space (including data extension)
    let group_mint_rent = client
        .get_minimum_balance_for_rent_exemption(group_mint_space_with_data)
        .await?;

    let create_group_mint_account_instruction = create_account(
        &authority.pubkey(),     // payer
        &group_mint.pubkey(),    // new account (mint)
        group_mint_rent,         // lamports
        group_mint_space as u64, // space (pointer only for account creation)
        &TOKEN_2022_PROGRAM_ID,  // program id
    );

    let initialize_group_pointer_instruction = initialize_group_pointer(
        &TOKEN_2022_PROGRAM_ID,
        &group_mint.pubkey(),      // mint
        Some(authority.pubkey()),  // authority
        Some(group_mint.pubkey()), // group address (points to itself)
    )?;

    let initialize_group_mint_instruction = initialize_mint(
        &TOKEN_2022_PROGRAM_ID,    // program id
        &group_mint.pubkey(),      // mint
        &authority.pubkey(),       // mint authority
        Some(&authority.pubkey()), // freeze authority
        0,                         // decimals (NFT-style)
    )?;

    // Initialize group extension (added post-mint initialization)
    let initialize_group_instruction = initialize_group(
        &TOKEN_2022_PROGRAM_ID,   // program id
        &group_mint.pubkey(),     // group
        &group_mint.pubkey(),     // mint
        &authority.pubkey(),      // mint authority
        Some(authority.pubkey()), // update authority
        10,                       // max size
    );

    // Build group mint transaction
    let group_transaction = Transaction::new_signed_with_payer(
        &[
            create_group_mint_account_instruction,
            initialize_group_pointer_instruction,
            initialize_group_mint_instruction,
            initialize_group_instruction,
        ],
        Some(&authority.pubkey()),
        &[&authority, &group_mint],
        latest_blockhash,
    );

    client
        .send_and_confirm_transaction(&group_transaction)
        .await?;

    // Generate keypair for member mint
    let member_mint = Keypair::new();

    // Calculate space for mint with member pointer extension only (for account creation)
    let member_mint_space =
        ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::GroupMemberPointer])?;

    // Calculate space for mint with member pointer and member extension (for rent calculation)
    let member_mint_space_with_data = ExtensionType::try_calculate_account_len::<Mint>(&[
        ExtensionType::GroupMemberPointer,
        ExtensionType::TokenGroupMember,
    ])?;

    // Get rent exempt balance for full space (including data extension)
    let member_mint_rent = client
        .get_minimum_balance_for_rent_exemption(member_mint_space_with_data)
        .await?;

    let create_member_mint_account_instruction = create_account(
        &authority.pubkey(),      // payer
        &member_mint.pubkey(),    // new account (mint)
        member_mint_rent,         // lamports
        member_mint_space as u64, // space (pointer only for account creation)
        &TOKEN_2022_PROGRAM_ID,   // program id
    );

    let initialize_member_pointer_instruction = initialize_group_member_pointer(
        &TOKEN_2022_PROGRAM_ID,
        &member_mint.pubkey(),      // mint
        Some(authority.pubkey()),   // authority
        Some(member_mint.pubkey()), // member address (points to itself)
    )?;

    let initialize_member_mint_instruction = initialize_mint(
        &TOKEN_2022_PROGRAM_ID,    // program id
        &member_mint.pubkey(),     // mint
        &authority.pubkey(),       // mint authority
        Some(&authority.pubkey()), // freeze authority
        0,                         // decimals (NFT-style)
    )?;

    // Initialize member extension (added post-mint initialization)
    let initialize_member_instruction = initialize_member(
        &TOKEN_2022_PROGRAM_ID, // program id
        &member_mint.pubkey(),  // member
        &member_mint.pubkey(),  // member mint
        &authority.pubkey(),    // member mint authority
        &group_mint.pubkey(),   // group (references the group mint)
        &authority.pubkey(),    // group update authority
    );

    // Build member mint transaction
    let member_transaction = Transaction::new_signed_with_payer(
        &[
            create_member_mint_account_instruction,
            initialize_member_pointer_instruction,
            initialize_member_mint_instruction,
            initialize_member_instruction,
        ],
        Some(&authority.pubkey()),
        &[&authority, &member_mint],
        latest_blockhash,
    );

    // Send and confirm member transaction
    client
        .send_and_confirm_transaction(&member_transaction)
        .await?;

    println!("Group Mint: {}", group_mint.pubkey());
    // Fetch and deserialize group mint
    let group_mint_account = client.get_account(&group_mint.pubkey()).await?;
    let group_mint_state = StateWithExtensions::<Mint>::unpack(&group_mint_account.data)?;

    let group_extension_types = group_mint_state.get_extension_types()?;
    println!("Extensions enabled: {:?}", group_extension_types);

    let group_pointer = group_mint_state.get_extension::<GroupPointer>()?;
    println!("\n{:#?}", group_pointer);
    let token_group = group_mint_state.get_extension::<TokenGroup>()?;
    println!("\n{:#?}", token_group);

    println!("\nMember Mint: {}", member_mint.pubkey());
    // Fetch and deserialize member mint
    let member_mint_account = client.get_account(&member_mint.pubkey()).await?;
    let member_mint_state = StateWithExtensions::<Mint>::unpack(&member_mint_account.data)?;

    let member_extension_types = member_mint_state.get_extension_types()?;
    println!("Extensions enabled: {:?}", member_extension_types);

    let member_pointer = member_mint_state.get_extension::<GroupMemberPointer>()?;
    println!("\n{:#?}", member_pointer);
    let token_group_member = member_mint_state.get_extension::<TokenGroupMember>()?;
    println!("\n{:#?}", token_group_member);

    Ok(())
}