Crear un Token Mint

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

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

    // Setup: create and fund the fee payer before creating the mint.

    let latest_blockhash = client.get_latest_blockhash().await?;
    let transaction = Transaction::new_signed_with_payer(
        &[
            create_account(
                &fee_payer.pubkey(), // Account funding account creation.
                &mint.pubkey(), // New mint account to create.
                mint_rent, // Lamports funding the new account rent.
                Mint::LEN as u64, // Account size in bytes.
                &token_program_id(), // Program that owns the new account.
            ),
            initialize_mint(
                &token_program_id(),
                &mint.pubkey(), // Mint account to initialize.
                &fee_payer.pubkey(), // Authority allowed to mint new tokens.
                Some(&fee_payer.pubkey()), // Authority allowed to freeze token accounts.
                9, // Decimals to define on the mint account.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer, &mint],
        latest_blockhash,
    );

    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)?;

    println!("Mint Address: {}", mint.pubkey());
    println!("Mint Account: {:#?}", mint_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.system_program import create_account, CreateAccountParams
from solders.transaction import Transaction
from spl.token.async_client import AsyncToken
from spl.token.instructions import initialize_mint, InitializeMintParams
from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID

DECIMALS = 9

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

    async with rpc:
        # Setup: create and fund the fee payer before creating the mint.

        create_mint_instructions = [
            create_account(
                CreateAccountParams(
                    from_pubkey=fee_payer.pubkey(),  # Account funding account creation.
                    to_pubkey=mint.pubkey(),  # New mint account to create.
                    lamports=mint_rent,  # Lamports funding the new account rent.
                    space=MINT_LEN,  # Account size in bytes.
                    owner=TOKEN_PROGRAM_ID,  # Program that owns the new account.
                )
            ),
            initialize_mint(
                InitializeMintParams(
                    program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                    mint=mint.pubkey(),  # Mint account to initialize.
                    decimals=DECIMALS,  # Decimals to define on the mint account.
                    mint_authority=fee_payer.pubkey(),  # Authority allowed to mint new tokens.
                    freeze_authority=fee_payer.pubkey(),  # Authority allowed to freeze token accounts.
                )
            ),
        ]
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer, mint],
            Message(create_mint_instructions, fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        token = AsyncToken(rpc, mint.pubkey(), TOKEN_PROGRAM_ID, fee_payer)
        mint_info = await token.get_mint_info()
        mint_account = {
            "mint_authority": None if mint_info.mint_authority is None else str(mint_info.mint_authority),
            "supply": mint_info.supply,
            "decimals": mint_info.decimals,
            "is_initialized": mint_info.is_initialized,
            "freeze_authority": None if mint_info.freeze_authority is None else str(mint_info.freeze_authority),
        }

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

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