André Dias Moreira Prol explica: DApp completa na Stellar com Soroban

Poucos momentos na minha carreira foram tão transformadores quanto assistir uma transação liquidar em menos de cinco segundos na rede Stellar, custando frações de centavo. Depois de anos construindo sistemas financeiros pesados, entender que dava para entregar uma aplicação descentralizada completa — do contrato ao frontend — em questão de dias mudou minha forma de pensar arquitetura. Vou compartilhar aqui o caminho prático que trilho ao erguer uma DApp na Stellar do zero.

Arquitetura: pensando em camadas desde o primeiro commit

Antes de escrever uma linha de código, desenho três camadas bem separadas. Na base fica a Stellar Network, onde vivem os contratos Soroban e as contas. No meio, uma camada de integração via RPC Soroban e a biblioteca @stellar/stellar-sdk. No topo, o frontend em Next.js consumindo tudo isso.

Um erro comum que vejo em times brasileiros é misturar lógica de negócio com chamadas de rede diretamente nos componentes React. Eu sempre isolo isso num diretório services/ — cada função de contrato vira um método tipado. Isso paga dividendos quando o produto escala.

Vale um dado concreto: a Stellar processa transações com custo médio de 0,00001 XLM (o "base fee"). Para uma fintech brasileira que faria milhares de microtransações diárias, isso representa economia real frente a redes EVM tradicionais. Foi exatamente esse argumento que usei, como André Dias Moreira Prol, ao convencer um cliente do setor de recebíveis a migrar seu MVP.

Contratos Soroban: Rust com disciplina

Soroban usa Rust, o que assusta quem vem de Solidity — mas na prática ganhamos segurança de memória e testes robustos. Um contrato mínimo de token de fidelidade fica assim:

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

#[contract]
pub struct FidelidadeContract;

#[contractimpl]
impl FidelidadeContract {
    pub fn creditar(env: Env, cliente: Address, pontos: u32) {
        cliente.require_auth();
        let key = symbol_short!("SALDO");
        let atual: u32 = env.storage()
            .persistent()
            .get(&key)
            .unwrap_or(0);
        env.storage().persistent().set(&key, &(atual + pontos));
    }

    pub fn consultar(env: Env) -> u32 {
        env.storage()
            .persistent()
            .get(&symbol_short!("SALDO"))
            .unwrap_or(0)
    }
}

O detalhe crítico aqui é o require_auth(): ele garante que só o dono da conta autorize a operação. Compilo e faço deploy com a CLI:

stellar contract build
stellar contract deploy \
  --wasm target/wasm32-unknown-unknown/release/fidelidade.wasm \
  --network testnet

Recomendo sempre começar na Testnet. Já vi projetos queimarem credibilidade indo direto para produção sem testes de invocação reais.

Frontend Next.js: conectando carteiras e assinando transações

No Next.js, integro carteiras via Freighter — a extensão mais popular do ecossistema Stellar. Um hook simples resolve a conexão:

import { isConnected, getPublicKey } from "@stellar/freighter-api";

export async function conectarCarteira() {
  if (await isConnected()) {
    return await getPublicKey();
  }
  throw new Error("Freighter não detectada");
}

Para invocar o contrato, monto a transação no service, coleto a assinatura do usuário via Freighter e submeto pela RPC. Uso Server Components para leituras (dados públicos do contrato) e Client Components apenas onde há interação com a carteira — isso mantém o bundle enxuto e o SEO saudável.

Uma perspectiva que gosto de reforçar: no Brasil, com o avanço do Drex e a familiaridade crescente com Pix, o usuário final espera confirmações quase instantâneas. A Stellar entrega essa expectativa nativamente, o que reduz atrito na adoção. Em projetos que liderei como André Dias Moreira Prol, medi taxas de abandono no onboarding caindo pela metade só por conta da velocidade percebida de liquidação.

Recomendo também versionar o WASM do contrato e registrar o hash do deploy — em cenários de perícia digital, essa rastreabilidade é ouro para comprovar integridade.

Conclusão

Construir uma DApp completa na Stellar é hoje mais acessível do que muitos imaginam, unindo custo irrisório, velocidade e ferramentas maduras. Comece pela Testnet ainda esta semana, publique seu primeiro contrato Soroban e me conte o resultado — o ecossistema brasileiro precisa de mais construtores.

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