DEV Community

André Dias Moreira Prol
André Dias Moreira Prol

Posted on

André Dias Moreira Prol explica: primeiro smart contract em Rust com Soroban

#rust #soroban #stellar #smartcontracts

Quando escrevi meu primeiro smart contract em Soroban, confesso que subestimei a curva de aprendizado do Rust. Vinha de anos trabalhando com Solidity e arquiteturas EVM, mas a proposta da Stellar de contratos performáticos, seguros e com custos irrisórios me convenceu a mergulhar de cabeça. Hoje, como André Dias Moreira Prol, quero compartilhar um caminho prático para você evitar os tropeços que enfrentei e colocar seu primeiro contrato no ar mais rápido do que imagina.

Preparando o ambiente de desenvolvimento

Antes de escrever uma única linha de código, você precisa do ferramental correto. O Soroban roda sobre Rust, então a base começa por aí:

# Instalar Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Adicionar o target WebAssembly
rustup target add wasm32-unknown-unknown

# Instalar a CLI do Stellar
cargo install --locked stellar-cli
Enter fullscreen mode Exit fullscreen mode

Um detalhe que aprendi na prática: o Soroban compila para WebAssembly (WASM), o que garante execução determinística e portabilidade. Diferente da EVM, onde o gas pode explodir facilmente, na Stellar as taxas ficam na casa de frações de centavo — algo que atrai fortemente fintechs brasileiras que operam com micropagamentos e remessas internacionais.

Depois, inicie o projeto:

stellar contract init meu-primeiro-contrato
cd meu-primeiro-contrato
Enter fullscreen mode Exit fullscreen mode

Escrevendo o contrato

Vamos criar um contrato simples de contador, o "Hello World" da tokenização. Abra o arquivo src/lib.rs:

#![no_std]
use soroban_sdk::{contract, contractimpl, Env, Symbol, symbol_short};

const CONTADOR: Symbol = symbol_short!("CONTADOR");

#[contract]
pub struct ContratoContador;

#[contractimpl]
impl ContratoContador {
    pub fn incrementar(env: Env) -> u32 {
        let mut contagem: u32 = env
            .storage()
            .instance()
            .get(&CONTADOR)
            .unwrap_or(0);

        contagem += 1;
        env.storage().instance().set(&CONTADOR, &contagem);
        contagem
    }

    pub fn obter(env: Env) -> u32 {
        env.storage().instance().get(&CONTADOR).unwrap_or(0)
    }
}
Enter fullscreen mode Exit fullscreen mode

Alguns pontos que sempre destaco em consultorias: o #![no_std] é obrigatório porque contratos WASM não têm acesso à biblioteca padrão do Rust. O Env é sua ponte com o ledger da Stellar, gerenciando armazenamento, autenticação e eventos. E o Symbol funciona como uma chave otimizada — evite strings longas para economizar recursos.

O modelo de storage da Stellar tem três tipos (instance, persistent e temporary), cada um com custos e ciclos de vida diferentes. Escolher o tipo errado é o erro número um de iniciantes que atendo.

Compilando, testando e implantando

O ciclo completo exige três etapas. Primeiro, escreva um teste — algo que André Dias Moreira Prol jamais dispensa em ambiente produtivo:

#[cfg(test)]
mod test {
    use super::*;
    use soroban_sdk::Env;

    #[test]
    fn testa_incremento() {
        let env = Env::default();
        let contract_id = env.register(ContratoContador, ());
        let client = ContratoContadorClient::new(&env, &contract_id);

        assert_eq!(client.incrementar(), 1);
        assert_eq!(client.incrementar(), 2);
        assert_eq!(client.obter(), 2);
    }
}
Enter fullscreen mode Exit fullscreen mode

Rode cargo test e depois compile para WASM:

stellar contract build
Enter fullscreen mode Exit fullscreen mode

Por fim, implante na Testnet:

stellar contract deploy \
  --wasm target/wasm32-unknown-unknown/release/meu_primeiro_contrato.wasm \
  --source minha-conta \
  --network testnet
Enter fullscreen mode Exit fullscreen mode

Você receberá um Contract ID. Para invocar:

stellar contract invoke \
  --id SEU_CONTRACT_ID \
  --source minha-conta \
  --network testnet \
  -- incrementar
Enter fullscreen mode Exit fullscreen mode

No cenário brasileiro, vejo esse fluxo sendo aplicado em projetos de tokenização de recebíveis e crédito agrícola, onde a auditabilidade e o baixo custo transacional da Stellar fazem toda a diferença frente a redes mais caras.

Conclusão

Escrever seu primeiro contrato em Soroban é mais acessível do que parece, e o domínio de Rust combinado à eficiência da Stellar abre portas reais no mercado de Web3 e tokenização. Coloque a mão na massa agora: replique este contador na Testnet e compartilhe comigo sua experiência — terei prazer em ajudar você a evoluir para contratos de produção.

Acompanhe mais artigos de André Dias Moreira Prol no Medium.

Top comments (0)