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_checked, transfer_checked},
    state::{Account, Mint},
};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );
    let recipient = Keypair::new();

    // Setup: create a mint, fund the payer's ATA, and create the recipient's ATA.

    let transfer_amount = 25;
    let transaction = Transaction::new_signed_with_payer(
        &[
            transfer_checked(
                &token_program_id(), // Token program to invoke.
                &source_token_address, // Token account sending the tokens.
                &mint.pubkey(), // Mint for the token being transferred.
                &destination_token_address, // Token account receiving the tokens.
                &fee_payer.pubkey(), // Owner or delegate approving the transfer.
                &[], // Additional multisig signers.
                transfer_amount, // Token amount in base units.
                decimals, // Decimals defined on the mint account.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let source_token_account = client.get_account(&source_token_address).await?;
    let source_token_data = Account::unpack(&source_token_account.data)?;
    let destination_token_account = client.get_account(&destination_token_address).await?;
    let destination_token_data = Account::unpack(&destination_token_account.data)?;

    println!("Mint Address: {}", mint.pubkey());
    println!("\nSource Token Account Address: {}", source_token_address);
    println!("Source Token Account: {:#?}", source_token_data);
    println!(
        "\nDestination Token Account Address: {}",
        destination_token_address
    );
    println!("Destination Token Account: {:#?}", destination_token_data);
    println!("\nTransaction Signature: {}", transaction_signature);

    Ok(())
}

#!/usr/bin/env python3

import asyncio
import json
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.message import Message
from solders.pubkey import Pubkey
from solders.system_program import create_account, CreateAccountParams
from solders.transaction import Transaction
from spl.token.async_client import AsyncToken
from spl.token.instructions import (
    create_associated_token_account,
    get_associated_token_address,
    initialize_mint,
    InitializeMintParams,
    mint_to_checked,
    MintToCheckedParams,
    transfer_checked,
    TransferCheckedParams,
)
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

DECIMALS = 2
AMOUNT_TO_MINT = 100
AMOUNT_TO_TRANSFER = 25

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

    receiver = Keypair()

    async with rpc:
        # Setup: create a mint, source token account, destination token account, and source token balance.

        transfer_tokens_instruction = transfer_checked(
            TransferCheckedParams(
                program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                source=source_token_account,  # Token account sending the tokens.
                mint=mint.pubkey(),  # Mint for the token being transferred.
                dest=destination_token_account,  # Token account receiving the tokens.
                owner=fee_payer.pubkey(),  # Account that owns the source token account.
                amount=AMOUNT_TO_TRANSFER,  # Token amount in base units.
                decimals=DECIMALS,  # Decimals defined on the mint account.
            )
        )
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message([transfer_tokens_instruction], fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        source_token_account_info = await token.get_account_info(source_token_account)
        destination_token_account_info = await token.get_account_info(destination_token_account)
        source_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in source_token_account_info._asdict().items()
        }
        destination_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in destination_token_account_info._asdict().items()
        }

        print("Mint Address:", mint.pubkey())
        print("\nSource Token Account Address:", source_token_account)
        print("Source Token Account:")
        print(json.dumps(source_account, indent=2))
        print("\nDestination Token Account Address:", destination_token_account)
        print("Destination Token Account:")
        print(json.dumps(destination_account, indent=2))
        print("\nTransaction Signature:", result.value)

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