Ein Token-Konto erstellen

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

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

    // Setup: create a mint before creating the associated token account.

    let transaction = Transaction::new_signed_with_payer(
        &[
            create_associated_token_account(
                &fee_payer.pubkey(), // Account funding account creation.
                &fee_payer.pubkey(), // Account that owns the token account.
                &mint.pubkey(), // Mint for the token this account holds.
                &token_program_id(), // Token program that owns the account.
            ),
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let associated_token_account = get_associated_token_address(&fee_payer.pubkey(), &mint.pubkey());
    let token_account = client.get_account(&associated_token_account).await?;
    let token_data = Account::unpack(&token_account.data)?;

    println!("Mint Address: {}", mint.pubkey());
    println!(
        "\nAssociated Token Account Address: {}",
        associated_token_account
    );
    println!("Associated Token Account: {:#?}", 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,
)
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

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

    fee_payer = Keypair()
    owner = Keypair()

    async with rpc:
        # Setup: create and initialize a mint before creating the ATA.

        create_associated_token_account_instruction = create_associated_token_account(
            payer=fee_payer.pubkey(),  # Account funding account creation.
            owner=owner.pubkey(),  # Account that owns the token account.
            mint=mint.pubkey(),  # Mint for the token this account holds.
            token_program_id=TOKEN_PROGRAM_ID,  # Token program that owns the new token account.
        )
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message([create_associated_token_account_instruction], fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        token_account_info = await token.get_account_info(associated_token_account)
        token_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in token_account_info._asdict().items()
        }

        print("Mint Address:", mint.pubkey())
        print("\nToken Account Address:", associated_token_account)
        print("Token Account:")
        print(json.dumps(token_account, indent=2))
        print("\nTransaction Signature:", result.value)

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

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

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

    // Setup: create a mint before creating the token account.

    let token_account = Keypair::new();
    let token_account_rent = client
        .get_minimum_balance_for_rent_exemption(Account::LEN)
        .await?;

    let transaction = Transaction::new_signed_with_payer(
        &[
            create_account(
                &fee_payer.pubkey(), // Account funding account creation.
                &token_account.pubkey(), // New token account to create.
                token_account_rent, // Lamports funding the new account rent.
                Account::LEN as u64, // Account size in bytes.
                &token_program_id(), // Program that owns the new account.
            ),
            initialize_account(
                &token_program_id(),
                &token_account.pubkey(), // Token account to initialize.
                &mint.pubkey(), // Mint for the token this account holds.
                &fee_payer.pubkey(), // Account that owns the token account.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer, &token_account],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let token_account_data = client.get_account(&token_account.pubkey()).await?;
    let token_data = Account::unpack(&token_account_data.data)?;

    println!("Mint Address: {}", mint.pubkey());
    println!("\nToken Account Address: {}", token_account.pubkey());
    println!("Token Account: {:#?}", 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 (
    initialize_account,
    InitializeAccountParams,
    initialize_mint,
    InitializeMintParams,
)
from spl.token.constants import ACCOUNT_LEN, MINT_LEN, TOKEN_PROGRAM_ID

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

    async with rpc:
        # Setup: create and initialize a mint before creating the token account.

        token_account = Keypair()
        token_account_rent = (await rpc.get_minimum_balance_for_rent_exemption(ACCOUNT_LEN)).value

        create_token_account_instructions = [
            create_account(
                CreateAccountParams(
                    from_pubkey=fee_payer.pubkey(),  # Account funding account creation.
                    to_pubkey=token_account.pubkey(),  # New token account to create.
                    lamports=token_account_rent,  # Lamports funding the new account rent.
                    space=ACCOUNT_LEN,  # Account size in bytes.
                    owner=TOKEN_PROGRAM_ID,  # Program that owns the new token account.
                )
            ),
            initialize_account(
                InitializeAccountParams(
                    program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                    account=token_account.pubkey(),  # Token account to initialize.
                    mint=mint.pubkey(),  # Mint for the token this account holds.
                    owner=fee_payer.pubkey(),  # Account that owns the token account.
                )
            ),
        ]
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer, token_account],
            Message(create_token_account_instructions, fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        token_account_info = await token.get_account_info(token_account.pubkey())
        token_account_data = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in token_account_info._asdict().items()
        }

        print("Mint Address:", mint.pubkey())
        print("\nToken Account Address:", token_account.pubkey())
        print("Token Account:")
        print(json.dumps(token_account_data, indent=2))
        print("\nTransaction Signature:", result.value)

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