Ορισμός Εξουσιοδότησης

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    program_pack::Pack,
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::create_account;
use spl_token_interface::{
    id as token_program_id,
    instruction::{initialize_mint, set_authority, AuthorityType},
    state::Mint,
};

#[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 a new keypair for the fee payer
    let fee_payer = Keypair::new();

    // Generate a new keypair for the new authority
    let new_authority = Keypair::new();

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

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

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

    // Number of decimals for the mint
    let decimals = 2;

    // Get default mint account size (in bytes), no extensions enabled
    let mint_space = Mint::LEN;
    let mint_rent = client
        .get_minimum_balance_for_rent_exemption(mint_space)
        .await?;

    // Instruction to create new account for mint (token program)
    let create_account_instruction = create_account(
        &fee_payer.pubkey(), // payer
        &mint.pubkey(),      // new account (mint)
        mint_rent,           // lamports
        mint_space as u64,   // space
        &token_program_id(), // program id
    );

    // Instruction to initialize mint account data
    let initialize_mint_instruction = initialize_mint(
        &token_program_id(),
        &mint.pubkey(),            // mint
        &fee_payer.pubkey(),       // mint authority
        Some(&fee_payer.pubkey()), // freeze authority
        decimals,                  // decimals
    )?;

    // Create transaction and add instructions
    let transaction = Transaction::new_signed_with_payer(
        &[create_account_instruction, initialize_mint_instruction],
        Some(&fee_payer.pubkey()),
        &[&fee_payer, &mint],
        latest_blockhash,
    );

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

    let mint_account = client.get_account(&mint.pubkey()).await?;
    let mint_data = Mint::unpack(&mint_account.data)?;

    println!("Mint Address: {}", mint.pubkey());
    println!("{:#?}", mint_data);

    // 1. Change Mint Authority (MintTokens)
    let set_mint_authority_ix = set_authority(
        &token_program_id(),           // program id
        &mint.pubkey(),                // mint account
        Some(&new_authority.pubkey()), // new authority
        AuthorityType::MintTokens,     // authority type
        &fee_payer.pubkey(),           // current authority
        &[&fee_payer.pubkey()],        // signers
    )?;

    // 2. Change Freeze Authority (FreezeAccount)
    let set_freeze_authority_ix = set_authority(
        &token_program_id(),           // program id
        &mint.pubkey(),                // mint account
        Some(&new_authority.pubkey()), // new authority
        AuthorityType::FreezeAccount,  // authority type
        &fee_payer.pubkey(),           // current authority
        &[&fee_payer.pubkey()],        // signers
    )?;

    // Create transaction for authority changes
    let transaction = Transaction::new_signed_with_payer(
        &[set_mint_authority_ix, set_freeze_authority_ix],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

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

    let mint_account = client.get_account(&mint.pubkey()).await?;
    let mint_data = Mint::unpack(&mint_account.data)?;
    println!("\nMint and Freeze Authorities Updated");
    println!("{:#?}", mint_data);

    // 3. Example of revoking authority (setting to null)
    let revoke_mint_authority_ix = set_authority(
        &token_program_id(),        // program id
        &mint.pubkey(),             // mint account
        None,                       // new authority (None to revoke)
        AuthorityType::MintTokens,  // authority type
        &new_authority.pubkey(),    // current authority
        &[&new_authority.pubkey()], // signers
    )?;

    // Create transaction for revoking
    let transaction = Transaction::new_signed_with_payer(
        &[revoke_mint_authority_ix],
        Some(&fee_payer.pubkey()),
        &[&fee_payer, &new_authority], // new_authority needs to sign
        latest_blockhash,
    );

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

    let mint_account = client.get_account(&mint.pubkey()).await?;
    let mint_data = Mint::unpack(&mint_account.data)?;
    println!("\nMint Authority Revoked");
    println!("{:#?}", mint_data);

    Ok(())
}

#!/usr/bin/env python3

import asyncio
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.transaction import VersionedTransaction
from solders.message import MessageV0
from spl.token.instructions import set_authority, SetAuthorityParams
from spl.token.constants import TOKEN_PROGRAM_ID
from spl.token.instructions import AuthorityType

async def main():
    rpc = AsyncClient("http://localhost:8899")

    # Example keypairs and addresses
    payer = Keypair()
    current_authority = Keypair()
    new_authority = Keypair()
    mint_or_account = Pubkey.from_string("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU")

    async with rpc:
        # Set new mint authority
        set_mint_authority_instruction = set_authority(
            SetAuthorityParams(
                program_id=TOKEN_PROGRAM_ID,
                account=mint_or_account,
                authority=AuthorityType.MINT_TOKENS,
                current_authority=current_authority.pubkey(),
                new_authority=new_authority.pubkey()
            )
        )

        # Get latest blockhash
        recent_blockhash = await rpc.get_latest_blockhash()

        # Create message
        message = MessageV0.try_compile(
            payer=payer.pubkey(),
            instructions=[set_mint_authority_instruction],
            address_lookup_table_accounts=[],
            recent_blockhash=recent_blockhash.value.blockhash
        )

        # Create transaction
        transaction = VersionedTransaction(message, [payer, current_authority])

        print(f"Account/Mint: {mint_or_account}")
        print(f"Current Authority: {current_authority.pubkey()}")
        print(f"New Authority: {new_authority.pubkey()}")
        print(f"Authority Type: MintTokens")
        print(f"Payer: {payer.pubkey()}")
        print(f"Set authority transaction created successfully")

async def set_freeze_authority_example():
    """Example of setting freeze authority"""
    rpc = AsyncClient("http://localhost:8899")

    payer = Keypair()
    current_authority = Keypair()
    new_authority = Keypair()
    mint_address = Pubkey.from_string("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU")

    async with rpc:
        # Set freeze authority
        set_freeze_authority_instruction = set_authority(
            SetAuthorityParams(
                program_id=TOKEN_PROGRAM_ID,
                account=mint_address,
                authority=AuthorityType.FREEZE_ACCOUNT,
                current_authority=current_authority.pubkey(),
                new_authority=new_authority.pubkey()
            )
        )

        recent_blockhash = await rpc.get_latest_blockhash()
        message = MessageV0.try_compile(
            payer=payer.pubkey(),
            instructions=[set_freeze_authority_instruction],
            address_lookup_table_accounts=[],
            recent_blockhash=recent_blockhash.value.blockhash
        )

        transaction = VersionedTransaction(message, [payer, current_authority])

        print(f"\nFreeze Authority Example:")
        print(f"Mint: {mint_address}")
        print(f"Current Freeze Authority: {current_authority.pubkey()}")
        print(f"New Freeze Authority: {new_authority.pubkey()}")
        print(f"Set freeze authority transaction created successfully")

if __name__ == "__main__":
    asyncio.run(main())
    asyncio.run(set_freeze_authority_example())