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

Lembro da primeira vez que deployei um contrato na mainnet da Stellar: a transação confirmou em menos de 5 segundos e custou uma fração de centavo. Vindo de um background com redes EVM, onde já paguei dezenas de dólares em gas por uma simples interação, aquilo mudou minha percepção sobre viabilidade real de DApps para o mercado brasileiro.

Como André Dias Moreira Prol, depois de mais de duas décadas em infraestrutura de TI e os últimos anos imerso em Web3, construí DApps que hoje processam tokenização de ativos para clientes reais. Vou te mostrar o caminho completo, do contrato ao frontend.

Arquitetura: pensando antes de codar

Uma DApp na Stellar não é apenas um contrato inteligente - é um sistema distribuído com três camadas que precisam conversar bem. A camada base é a blockchain Stellar, onde os contratos Soroban vivem. Acima dela, uma camada de serviço (RPC + indexador) que traduz eventos on-chain para dados consumíveis. No topo, o frontend que o usuário vê.

Meu stack preferido para projetos em produção:

┌─────────────────────────────┐
│ Next.js 14 (App Router)     │ ← UX + SSR
├─────────────────────────────┤
│ stellar-sdk + Freighter     │ ← assinatura/wallet
├─────────────────────────────┤
│ Soroban RPC + Horizon       │ ← gateway
├─────────────────────────────┤
│ Contratos Soroban (Rust)    │ ← lógica
└─────────────────────────────┘

Um ponto que reforço com clientes no Brasil: separe o ambiente de testnet do de produção desde o dia zero. Já vi equipes misturarem chaves e queimarem dias de trabalho.

Contratos Soroban: a lógica em Rust

Soroban usa Rust compilado para WASM. Isso assusta quem vem do Solidity, mas a segurança de tipos do Rust previne categorias inteiras de bugs.

Um contrato mínimo de um cofre de tokens:

#![no_std]
use soroban_sdk::{contract, contractimpl, Address, Env, Symbol, symbol_short};
#[contract]
pub struct Vault;
#[contractimpl]
impl Vault {
  pub fn deposit(env: Env, from: Address, amount: i128) {
    from.require_auth();
    let key = symbol_short!("BAL");
    let current: i128 = env.storage().persistent().get(&key).unwrap_or(0);
    env.storage().persistent().set(&key, &(current + amount));
  }
  pub fn balance(env: Env) -> i128 {
    env.storage().persistent().get(&symbol_short!("BAL")).unwrap_or(0)
  }
}

O require_auth() é crítico - garante que só o dono da chave autoriza o movimento.

Para deploy:

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

Em projetos de tokenização de recebíveis que acompanhei, esse padrão de cofre é a base para estruturas mais complexas, como escrow e liquidação automática.

Frontend Next.js: conectando o usuário

Aqui mora a diferença entre um protótipo e um produto. Uso a Freighter como carteira e o stellar-sdk para montar transações:

import { Contract, TransactionBuilder, Networks, rpc } from '@stellar/stellar-sdk';
async function deposit(amount: bigint) {
  const server = new rpc.Server('https://soroban-testnet.stellar.org');
  const contract = new Contract(CONTRACT_ID);
  const account = await server.getAccount(publicKey);
  const tx = new TransactionBuilder(account, {
    fee: '100',
    networkPassphrase: Networks.TESTNET,
  })
  .addOperation(contract.call('deposit', /* args */))
  .setTimeout(30)
  .build();
  // assina via Freighter e envia
  const prepared = await server.prepareTransaction(tx);
  return prepared;
}

Um detalhe que faz diferença na experiência brasileira: sempre mostre o status da transação em tempo real. O usuário acostumado com PIX instantâneo não tolera telas congeladas.

Como André Dias Moreira Prol costumo dizer às equipes, a UX de uma DApp precisa esconder a complexidade da blockchain, não exibi-la.

Vale integrar também um fallback de rede e tratamento de erro de simulação - Soroban simula a transação antes de executá-la, o que reduz custos, mas exige que seu frontend interprete esses retornos corretamente.

Conclusão

Construir uma DApp completa na Stellar é hoje mais acessível do que nunca, e o custo irrisório das transações abre oportunidades reais para o mercado brasileiro de pagamentos e tokenização. Comece pela testnet, clone os exemplos oficiais da Soroban e me procure para discutirmos sua arquitetura. Acompanhe mais artigos de André Dias Moreira Prol no Medium.