Chuyển Token

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_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account,
};
use spl_token_interface::{
    id as token_program_id,
    instruction::{initialize_mint, mint_to, transfer_checked},
    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 second keypair for the token recipient
    let recipient = 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;
        }
    }

    // Airdrop 1 SOL to recipient for rent exemption
    let recipient_airdrop_signature = client
        .request_airdrop(&recipient.pubkey(), 1_000_000_000)
        .await?;
    client
        .confirm_transaction(&recipient_airdrop_signature)
        .await?;

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

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

    // 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
        2,                         // decimals
    )?;

    // Calculate the associated token account address for fee_payer
    let source_token_address = get_associated_token_address(
        &fee_payer.pubkey(), // owner
        &mint.pubkey(),      // mint
    );

    // Instruction to create associated token account for fee_payer
    let create_source_ata_instruction = create_associated_token_account(
        &fee_payer.pubkey(), // funding address
        &fee_payer.pubkey(), // wallet address
        &mint.pubkey(),      // mint address
        &token_program_id(), // program id
    );

    // Calculate the associated token account address for recipient
    let destination_token_address = get_associated_token_address(
        &recipient.pubkey(), // owner
        &mint.pubkey(),      // mint
    );

    // Instruction to create associated token account for recipient
    let create_destination_ata_instruction = create_associated_token_account(
        &fee_payer.pubkey(), // funding address
        &recipient.pubkey(), // wallet address
        &mint.pubkey(),      // mint address
        &token_program_id(), // program id
    );

    // Amount of tokens to mint (100 tokens with 2 decimal places)
    let amount = 100_00;

    // Create mint_to instruction to mint tokens to the source token account
    let mint_to_instruction = mint_to(
        &token_program_id(),
        &mint.pubkey(),         // mint
        &source_token_address,  // destination
        &fee_payer.pubkey(),    // authority
        &[&fee_payer.pubkey()], // signer
        amount,                 // amount
    )?;

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

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

    // Amount of tokens to transfer (0.50 tokens with 2 decimals)
    let transfer_amount = 50;

    // Create transfer_checked instruction to send tokens from source to destination
    let transfer_instruction = transfer_checked(
        &token_program_id(),        // program id
        &source_token_address,      // source
        &mint.pubkey(),             // mint
        &destination_token_address, // destination
        &fee_payer.pubkey(),        // owner of source
        &[&fee_payer.pubkey()],     // signers
        transfer_amount,            // amount
        2,                          // decimals
    )?;

    // Create transaction for transferring tokens
    let transaction = Transaction::new_signed_with_payer(
        &[transfer_instruction],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

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

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

    // Get token account balances to verify the transfer
    let source_token_account = client.get_token_account(&source_token_address).await?;
    let destination_token_account = client.get_token_account(&destination_token_address).await?;

    println!("Successfully transferred 0.50 tokens from sender to recipient");

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

    println!("\nSource Token Account Address: {}", source_token_address);
    if let Some(source_account) = source_token_account {
        println!("TokenBalance: {}", source_account.token_amount.amount);
        println!("{:#?}", source_account);
    }

    println!(
        "\nDestination Token Account Address: {}",
        destination_token_address
    );
    if let Some(destination_account) = destination_token_account {
        println!("Token Balance: {}", destination_account.token_amount.amount);
        println!("{:#?}", destination_account);
    }

    println!("Transaction Signature: {}", transaction_signature);

    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 transfer_checked, TransferCheckedParams
from spl.token.instructions import get_associated_token_address
from spl.token.constants import TOKEN_PROGRAM_ID

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

    # Example keypairs and addresses
    payer = Keypair()
    owner = Keypair()
    receiver = Keypair()
    mint_address = Pubkey.from_string("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU")

    # Token decimals (usually 9 for most tokens)
    decimals = 9

    # Amount to transfer (in smallest unit)
    amount_to_transfer = 10_000_000_000  # 10 tokens with 9 decimals

    async with rpc:
        # Get associated token addresses
        source_token_account = get_associated_token_address(
            owner=owner.pubkey(),
            mint=mint_address,
            token_program_id=TOKEN_PROGRAM_ID
        )

        destination_token_account = get_associated_token_address(
            owner=receiver.pubkey(),
            mint=mint_address,
            token_program_id=TOKEN_PROGRAM_ID
        )

        # Create transfer checked instruction
        transfer_instruction = transfer_checked(
            TransferCheckedParams(
                program_id=TOKEN_PROGRAM_ID,
                source=source_token_account,
                mint=mint_address,
                dest=destination_token_account,
                owner=owner.pubkey(),
                amount=amount_to_transfer,
                decimals=decimals
            )
        )

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

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

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

        print(f"Mint: {mint_address}")
        print(f"Source: {source_token_account}")
        print(f"Destination: {destination_token_account}")
        print(f"Amount: {amount_to_transfer}")
        print(f"Decimals: {decimals}")
        print(f"Owner: {owner.pubkey()}")
        print(f"Receiver: {receiver.pubkey()}")
        print(f"Transfer transaction created successfully")

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