16.11.2024

Lição 043: Desenvolvendo Plataformas de NFT na Solana

Nesta lição, vamos explorar como desenvolver uma plataforma de Token Não Fungível (NFT) na blockchain Solana usando Rust. A alta capacidade de processamento e os baixos custos de transação da Solana tornam-na uma escolha ideal para a criação de plataformas de NFT. Vamos passar por um exemplo simples para mostrar a criação e a emissão de NFTs, bem como como armazenar os metadados associados a cada NFT.

Pré-requisitos

Antes de começarmos, certifique-se de ter o seguinte instalado:

1. Rust: Você pode instalar o Rust usando o rustup.
2. Solana CLI: Siga as instruções na documentação da Solana.
3. Anchor: Instale o Anchor, um framework para o desenvolvimento de contratos inteligentes na Solana. Você pode instalá-lo usando o comando:

   cargo install --git https://github.com/project-serum/anchor anchor-cli --locked

Configurando o Projeto

Vamos criar um novo projeto Anchor:

anchor init plataforma_nft
cd plataforma_nft

Esse comando configura um novo programa Solana com uma estrutura padrão.

Escrevendo o Contrato Inteligente

Abra o arquivo lib.rs localizado no diretório programs/plataforma_nft/src/ e substitua seu conteúdo pelo seguinte código:

use anchor_lang::prelude::*;
use anchor_spl::token::{Token, TokenAccount, Mint};
use mpl_token_metadata::state::{Metadata, Key};

declare_id!("SeuIdDoProgramaAqui"); // substitua pelo seu ID do programa

#[program]
pub mod plataforma_nft {
    use super::*;

    pub fn criar_nft(
        ctx: Context<CriarNft>,
        nome: String,
        simbolo: String,
        uri: String,
    ) -> ProgramResult {
        // Cria a Mint do NFT
        let mint = &mut ctx.accounts.mint;
        let autoridade = &ctx.accounts.autoridade;

        // Inicializa a mint
        Mint::initialize(mint, autoridade.key, None, 0)?;

        // Cria os metadados
        let metadados = Metadata {
            key: Key::MetadataV1,
            update_authority: autoridade.key(),
            mint: mint.key(),
            data: mpl_token_metadata::state::Data {
                name: nome,
                symbol: simbolo,
                uri: uri,
                seller_fee_basis_points: 500, // taxa de 5% para o vendedor
                creators: None,
            },
            primary_sale_happened: false,
            is_mutable: true,
        };

        // Aqui, você normalmente chamaria uma função externa para criar os metadados na cadeia

        Ok(())
    }
}

#[derive(Accounts)]
pub struct CriarNft<'info> {
    #[account(init)]
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    pub autoridade: Signer<'info>,
    pub system_program: Program<'info, System>,
}

Explicação do Código

1. Dependências: Usamos a crate mpl_token_metadata para lidar com metadados de NFT e a crate anchor_spl para transações de token SPL.

2. A função criar_nft: Essa função inicializa uma nova mint para o NFT e prepara seus metadados.

3. Estrutura de Contas: A estrutura CriarNft define as contas necessárias para esta instrução. Ela consiste em uma mint, autoridade (a conta que cria o NFT) e o programa do sistema.

Compilando e Implantando o Programa

Em seguida, precisamos compilar o programa.

anchor build

Se a compilação for bem-sucedida, você pode implantar o programa na devnet da Solana:

anchor deploy --provider.cluster devnet

Certifique-se de substituir SeuIdDoProgramaAqui pelo ID do programa que você receber após a implantação.

Interagindo com o Contrato Inteligente

Vamos criar um script para interagir com nosso programa implantado. Crie um novo arquivo chamado criar_nft.js no diretório raiz do seu projeto:

const anchor = require('@project-serum/anchor');
const { SystemProgram } = anchor.web3;

async function main() {
    // Conecta-se ao cluster
    const provider = anchor.Provider.local();
    anchor.setProvider(provider);

    // ID do programa do NFT implantado
    const programId = new anchor.web3.PublicKey('SeuIdDoProgramaAqui');

    const program = new anchor.Program(idl, programId, provider);

    const mint = anchor.web3.Keypair.generate();
    const autoridade = provider.wallet.publicKey;

    await program.rpc.criarNft("Meu NFT", "MEUNFT", "https://exemplo.com/metadados-nft.json", {
        accounts: {
            mint: mint.publicKey,
            authority: autoridade,
            systemProgram: SystemProgram.programId,
        },
        signers: [mint],
    });

    console.log("NFT Criado com Mint:", mint.publicKey.toString());
}

main().then(() => console.log("Sucesso")).catch(console.error);

Explicação do Código para o Script

1. Configuração: Configuramos a conexão com o cluster da Solana e instanciamos nosso programa.

2. Geração da Mint: Geramos um novo par de chaves para a mint e definimos a autoridade a partir da carteira.

3. Criando o NFT: Chamamos a função criarNft com os parâmetros para o NFT (nome, simbolo e uri).

4. Executando o Script: Execute o script usando Node.js:

   node criar_nft.js

Conclusão

Parabéns! Você criou com sucesso uma plataforma básica de NFTs na Solana. Você pode expandir essa implementação adicionando funcionalidade para listar NFTs, transferir propriedade e configurar um marketplace.

À medida que você se aprofunda, considere explorar como integrar sua plataforma com padrões como o protocolo Metaplex para uma experiência NFT mais robusta. Continue experimentando e construindo sobre os poderosos recursos da Solana!

Navigation