20.11.2024

Aula 082: Desenvolvendo Soluções de Cadeia de Suprimentos na Solana

Nesta aula, vamos explorar como construir soluções de cadeia de suprimentos na blockchain Solana. A Solana é conhecida pela sua alta capacidade de processamento e baixa latência, tornando-se uma excelente escolha para desenvolver aplicações em tempo real, como sistemas de gerenciamento de cadeia de suprimentos. Vamos percorrer os componentes-chave necessários para criar uma aplicação simples de cadeia de suprimentos, incluindo a configuração do projeto, definição dos contratos inteligentes (também conhecidos como programas em cadeia na Solana), e a interação com os dados on-chain.

Configurando seu Ambiente

Antes de começarmos a construir, certifique-se de que você tem as seguintes ferramentas instaladas:

• Rust: A linguagem de programação usada para desenvolver programas na Solana. Você pode instalá-la através de rustup.rs.
• Solana CLI: A interface de linha de comando para interagir com a blockchain Solana. Siga o guia de instalação no site oficial.
• Anchor: Um framework para Solana que simplifica o processo de criação e implantação de programas. Você pode instalá-lo executando:

cargo install --git https://github.com/coral-xyz/anchor anchor-cli --locked

Criando um Novo Projeto

Crie um novo projeto Anchor para nossa aplicação de cadeia de suprimentos:

anchor init cadeia_suprimentos
cd cadeia_suprimentos

Esse comando inicializa uma nova estrutura de projeto Anchor para nós.

Definindo o Programa de Cadeia de Suprimentos

Vamos definir nosso programa de cadeia de suprimentos em programs/cadeia_suprimentos/src/lib.rs. Este programa irá gerenciar os produtos na cadeia de suprimentos, incluindo a adição de novos itens, atualização de seus status e consulta aos mesmos.

use anchor_lang::prelude::*;

declare_id!("SUPPLY_CHAIN_PROGRAM_ID");

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

    pub fn adicionar_item(ctx: Context<AdicionarItem>, nome_item: String) -> Result<()> {
        let conta_cadeia = &mut ctx.accounts.conta_cadeia;
        conta_cadeia.itens.push(Item {
            nome: nome_item,
            status: "Criado".to_string(),
        });
        Ok(())
    }

    pub fn atualizar_status_item(ctx: Context<AtualizarStatusItem>, indice_item: usize, novo_status: String) -> Result<()> {
        let conta_cadeia = &mut ctx.accounts.conta_cadeia;
        if indice_item >= conta_cadeia.itens.len() {
            return Err(CodigoErro::ItemNaoEncontrado.into());
        }
        conta_cadeia.itens[indice_item].status = novo_status;
        Ok(())
    }

    pub fn obter_itens(ctx: Context<ObterItens>) -> Result<Vec<Item>> {
        let conta_cadeia = &ctx.accounts.conta_cadeia;
        Ok(conta_cadeia.itens.clone())
    }
}

#[account]
pub struct ContaCadeia {
    pub itens: Vec<Item>,
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct Item {
    pub nome: String,
    pub status: String,
}

#[derive(Accounts)]
pub struct AdicionarItem<'info> {
    #[account(init, payer = usuario, space = 8 + 64 * 10)] // Alocando espaço para até 10 itens
    pub conta_cadeia: Account<'info, ContaCadeia>,
    #[account(mut)]
    pub usuario: Signer<'info>,
    pub sistema_programa: Program<'info, System>,
}

#[derive(Accounts)]
pub struct AtualizarStatusItem<'info> {
    #[account(mut)]
    pub conta_cadeia: Account<'info, ContaCadeia>,
}

#[derive(Accounts)]
pub struct ObterItens<'info> {
    pub conta_cadeia: Account<'info, ContaCadeia>,
}

#[error]
pub enum CodigoErro {
    #[msg("Item não encontrado.")]
    ItemNaoEncontrado,
}

Componentes-Chave Explicados

1. Adicionando Itens: A função adicionar_item permite que criemos um novo item na cadeia de suprimentos com um status inicial de "Criado".

2. Atualizando Status de Item: A função atualizar_status_item permite que mudemos o status de um item existente com base em seu índice.

3. Obtendo Itens: A função obter_itens recupera a lista de itens armazenados na cadeia de suprimentos.

Compilando e Implantando o Programa

Em seguida, precisamos compilar e implantar nosso programa. Execute os seguintes comandos:

anchor build
anchor deploy

Certifique-se de que seu Solana CLI esteja configurado para a rede correta, por exemplo, Devnet:

solana config set --url devnet

Interagindo com o Programa

Uma vez que o programa esteja implantado, você pode interagir com ele usando JavaScript e a biblioteca Solana Web3.js. Crie uma nova pasta para o código do frontend e inicialize-a:

mkdir frontend
cd frontend
npm init -y
npm install @solana/web3.js @project-serum/anchor

Em seguida, crie um arquivo chamado index.js:

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

const main = async () => {
    // Configurar o provider
    anchor.setProvider(anchor.AnchorProvider.env());

    const programa = anchor.workspace.CadeiaSuprimentos;

    // Criar ContaCadeia
    const contaCadeia = anchor.workspace.ContaCadeia;
    const [chavePublicaContaCadeia] = await anchor.web3.PublicKey.findProgramAddress(
        [Buffer.from("conta_cadeia")],
        programa.programId
    );

    await programa.rpc.adicionarItem("Produto A", {
        accounts: {
            contaCadeia: chavePublicaContaCadeia,
            usuario: anchor.getProvider().wallet.publicKey,
            sistemaPrograma: SystemProgram.programId,
        },
    });

    console.log("Item adicionado com sucesso");

    // Atualizar status do item
    await programa.rpc.atualizarStatusItem(0, "Em Trânsito", {
        accounts: {
            contaCadeia: chavePublicaContaCadeia,
        },
    });

    console.log("Status do item atualizado com sucesso");

    // Obter todos os itens
    const itens = await programa.account.contaCadeia.fetch(chavePublicaContaCadeia);
    console.log(itens);
};

main().catch(err => {
    console.error(err);
});

Executando a Aplicação

Por fim, você pode executar sua aplicação:

node index.js

Esse script irá criar uma conta de cadeia de suprimentos, adicionar um item a ela, atualizar o status desse item e buscar todos os itens da cadeia de suprimentos.

Conclusão

Nesta aula, abordamos o básico de desenvolver uma solução de cadeia de suprimentos na Solana usando Rust e Anchor. Construímos um programa simples que permite adicionar itens, atualizar seus status e recuperar a lista de itens de uma conta de cadeia de suprimentos. Esse conhecimento fundamental pode ser expandido para criar soluções de cadeia de suprimentos mais complexas, incorporando recursos como rastreamento de itens, registro de eventos e integração com dispositivos IoT.

Bom desenvolvimento na Solana!

Navigation