Утвердить делегата

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::{approve_checked, initialize_mint, mint_to},
    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 keypair for the delegate
    let delegate = 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
    )?;

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

    // Instruction to create associated token account
    let create_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
    );

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

    // Create mint_to instruction to mint tokens to the associated token account
    let mint_to_instruction = mint_to(
        &token_program_id(),
        &mint.pubkey(),            // mint
        &associated_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_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 approve (1 token with 2 decimals)
    let approve_amount = 1_00;

    // Create approve_checked instruction
    let approve_instruction = approve_checked(
        &token_program_id(),       // program id
        &associated_token_address, // source token account
        &mint.pubkey(),            // mint
        &delegate.pubkey(),        // delegate
        &fee_payer.pubkey(),       // owner
        &[&fee_payer.pubkey()],    // signers
        approve_amount,            // amount
        decimals,                  // decimals
    )?;

    // Create transaction for approving delegate
    let transaction = Transaction::new_signed_with_payer(
        &[approve_instruction],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

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

    let token = client.get_token_account(&associated_token_address).await?;

    println!("Successfully approved delegate for 1.0 token");

    println!("\nDelegate Address: {}", delegate.pubkey());

    println!("\nToken Account Address: {}", associated_token_address);
    if let Some(token) = token {
        println!("{:#?}", token);
    }
    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.transaction import VersionedTransaction
from solders.message import MessageV0
from solders.system_program import create_account, CreateAccountParams
from spl.token.instructions import (
    initialize_mint, InitializeMintParams,
    create_associated_token_account,
    mint_to_checked, MintToCheckedParams,
    approve_checked, ApproveCheckedParams,
    get_associated_token_address
)
from spl.token.constants import TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID

# Constants
DECIMALS = 9

async def setup(rpc, mint_authority):
    """
    The setup function initializes the mint and associated token accounts,
    and mints tokens to said associated token account
    """
    mint = Keypair()

    space = 82  # getMintSize() equivalent for SPL Token

    # Get minimum balance for rent exemption
    rent = await rpc.get_minimum_balance_for_rent_exemption(space)

    # Create & initialize mint account
    create_account_instruction = create_account(
        CreateAccountParams(
            from_pubkey=mint_authority.pubkey(),
            to_pubkey=mint.pubkey(),
            lamports=rent.value,
            space=space,
            owner=TOKEN_PROGRAM_ID
        )
    )

    initialize_mint_instruction = initialize_mint(
        InitializeMintParams(
            program_id=TOKEN_PROGRAM_ID,
            mint=mint.pubkey(),
            decimals=DECIMALS,
            mint_authority=mint_authority.pubkey(),
            freeze_authority=None
        )
    )

    # Create associated token account
    authority_ata = get_associated_token_address(
        owner=mint_authority.pubkey(),
        mint=mint.pubkey(),
        token_program_id=TOKEN_PROGRAM_ID
    )

    create_authority_ata_instruction = create_associated_token_account(
        payer=mint_authority.pubkey(),
        owner=mint_authority.pubkey(),
        mint=mint.pubkey()
    )

    # Mint to token account
    mint_to_instruction = mint_to_checked(
        MintToCheckedParams(
            program_id=TOKEN_PROGRAM_ID,
            mint=mint.pubkey(),
            dest=authority_ata,
            mint_authority=mint_authority.pubkey(),
            amount=1_000_000_000_000,  # 1000 tokens
            decimals=DECIMALS
        )
    )

    instructions = [
        create_account_instruction,
        initialize_mint_instruction,
        create_authority_ata_instruction,
        mint_to_instruction
    ]

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

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

    # Create and sign transaction
    signed_transaction = VersionedTransaction(transaction_message, [mint_authority, mint])

    print("Setup transaction created successfully")
    print(f"Mint: {mint.pubkey()}")
    print(f"Authority ATA: {authority_ata}")

    return {
        "mint": mint.pubkey(),
        "authority_ata": authority_ata
    }

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

    # Constants
    mint_authority = Keypair()
    delegate = Keypair()

    async with rpc:
        # Get latest blockhash
        latest_blockhash = await rpc.get_latest_blockhash()

        # Setup mint and associated token accounts
        setup_result = await setup(rpc, mint_authority)
        mint = setup_result["mint"]
        authority_ata = setup_result["authority_ata"]

        # Create delegate instruction
        delegate_instruction = approve_checked(
            ApproveCheckedParams(
                program_id=TOKEN_PROGRAM_ID,
                source=authority_ata,
                mint=mint,
                delegate=delegate.pubkey(),
                owner=mint_authority.pubkey(),
                amount=1_000_000_000,  # 1 token
                decimals=DECIMALS
            )
        )

        # Create transaction message
        transaction_message = MessageV0.try_compile(
            payer=mint_authority.pubkey(),
            instructions=[delegate_instruction],
            address_lookup_table_accounts=[],
            recent_blockhash=latest_blockhash.value.blockhash
        )

        # Create and sign transaction
        signed_transaction = VersionedTransaction(transaction_message, [mint_authority])

        print(f"\nDelegate Transaction:")
        print(f"Source: {authority_ata}")
        print(f"Mint: {mint}")
        print(f"Delegate: {delegate.pubkey()}")
        print(f"Owner: {mint_authority.pubkey()}")
        print(f"Amount: 1_000_000_000 (1 token)")
        print(f"Decimals: {DECIMALS}")
        print(f"Delegation transaction created successfully")

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