16.11.2024

Lição: 040: Interagindo com o Programa de Tokens do Solana

Nesta aula, vamos explorar como interagir com o Programa de Tokens do Solana. O Programa de Tokens é uma parte essencial do ecossistema Solana, pois permite a criação e gestão de tokens fungíveis. Neste artigo, abordaremos os fundamentos do Programa de Tokens, como criar tokens e como transferi-los entre contas.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Um ambiente de desenvolvimento Rust funcionando.
• O Solana CLI instalado e configurado.
• Compreensão dos conceitos básicos do Solana, como contas e transações.

Configurando Seu Projeto

Vamos criar um novo projeto em Rust que irá interagir com o Programa de Tokens do Solana.

1. Crie um novo diretório para seu projeto e navegue até ele:

   mkdir interacao_token_solana
   cd interacao_token_solana

2. Inicialize um novo projeto Rust:

   cargo init

3. Adicione as dependências necessárias ao seu Cargo.toml:

   [dependencies]
   solana-client = "1.12.0" # Verifique a versão mais recente
   solana-sdk = "1.12.0"
   spl-token = "3.2.0"

Conectando ao Cluster Solana

Para interagir com o Programa de Tokens do Solana, precisamos nos conectar a um cluster Solana. Para fins de desenvolvimento, podemos usar o devnet.

use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::signature::{Keypair, Signer};
use solana_sdk::pubkey::Pubkey;

#[tokio::main]
async fn main() {
    let rpc_url = "https://api.devnet.solana.com";
    let client = RpcClient::new(rpc_url);

    println!("Conectado ao devnet do Solana!");
}

Criando um Novo Token

Para criar um novo token, usaremos a biblioteca SPL Token. O código a seguir demonstra como criar um novo token e gerar alguns tokens para sua carteira.

use spl_token::{instruction::initialize_mint, state::Mint};

async fn create_token(client: &RpcClient, payer: &Keypair) -> Pubkey {
    // Criação de uma nova conta mint (token)
    let mint = Keypair::new();
    let lamports = client
        .get_minimum_balance_for_rent_exemption(Mint::get_packed_len())
        .await
        .expect("Falha ao obter isenção de aluguel");

    let create_account_ix = solana_sdk::system_instruction::create_account(
        &payer.pubkey(),
        &mint.pubkey(),
        lamports,
        Mint::get_packed_len() as u64,
        &spl_token::id(),
    );

    let mut transaction = solana_sdk::transaction::Transaction::new_with_payer(
        &[create_account_ix],
        Some(&payer.pubkey()),
    );

    let tx = client
        .send_and_confirm_transaction_with_spinner(&mut transaction, &payer)
        .await
        .expect("A transação falhou");

    // Inicializando a conta mint
    let initialize_mint_ix = initialize_mint(
        &spl_token::id(),
        &mint.pubkey(),
        &payer.pubkey(),
        None,
        9, // Decimal
    )
    .expect("Falha ao criar a instrução de inicialização do mint");

    transaction.add(initialize_mint_ix);

    client
        .send_and_confirm_transaction(&transaction)
        .await
        .expect("Falha ao inicializar o mint");

    mint.pubkey()
}

Criando Tokens

Depois de criar um token, precisamos gerar alguns tokens para uma conta específica. O exemplo a seguir gera tokens para a conta associada do token criado.

use spl_token::instruction::mint_to;

async fn mint_tokens(client: &RpcClient, payer: &Keypair, mint_pubkey: &Pubkey, recipient: &Pubkey, amount: u64) {
    let mint_to_ix = mint_to(
        &spl_token::id(),
        mint_pubkey,
        recipient,
        &payer.pubkey(),
        &[],
        amount,
    )
    .expect("Falha ao criar a instrução mint_to");

    let transaction = Transaction::new_signed_with_payer(
        &[mint_to_ix],
        Some(&payer.pubkey()),
        &[payer],
        client.get_recent_blockhash().await.unwrap().0,
    );

    client
        .send_and_confirm_transaction(&transaction)
        .await
        .expect("Falha ao gerar tokens");
}

Transferindo Tokens

Para transferir tokens de uma conta para outra, utilizaremos a função transfer da biblioteca SPL Token.

use spl_token::instruction::transfer;

async fn transfer_tokens(client: &RpcClient, payer: &Keypair, source: &Pubkey, destination: &Pubkey, amount: u64) {
    let transfer_ix = transfer(
        &spl_token::id(),
        source,
        destination,
        &payer.pubkey(),
        &[],
        amount,
    )
    .expect("Falha ao criar a instrução de transferência");

    let transaction = Transaction::new_signed_with_payer(
        &[transfer_ix],
        Some(&payer.pubkey()),
        &[payer],
        client.get_recent_blockhash().await.unwrap().0,
    );

    client
        .send_and_confirm_transaction(&transaction)
        .await
        .expect("Falha ao transferir tokens");
}

Conclusão

Nesta aula, aprendemos a interagir com o Programa de Tokens do Solana criando um novo token, gerando tokens e transferindo-os entre contas. Este é apenas o começo do que você pode fazer com tokens no Solana. À medida que você se familiariza mais com o ecossistema Solana, pode explorar recursos avançados de tokens, como queimar tokens, contas congeladas e muito mais.

Sinta-se à vontade para expandir este exemplo e explorar as vastas possibilidades com tokens no Solana!

Navigation