Diamonds: A Revolução dos Contratos Inteligentes Atualizáveis no Brasil

Em 2025, a comunidade de desenvolvedores de blockchain no Brasil está cada vez mais focada em criar soluções que sejam ao mesmo tempo seguras, escaláveis e fáceis de manter. Dentro desse contexto, os chamados Diamonds (padrão EIP‑2535) surgem como uma alternativa poderosa aos tradicionais contratos proxy, permitindo contratos inteligentes atualizáveis e mais organizados. Neste artigo, vamos mergulhar nos detalhes técnicos dos Diamonds, explicar como eles funcionam, comparar com outras abordagens de upgrade e mostrar como você pode implementá‑los nos seus projetos.

Principais Pontos

• Diamonds utilizam o padrão facet para dividir a lógica em módulos reutilizáveis.
• Atualizações são feitas adicionando, removendo ou substituindo facets, sem necessidade de migrar estado.
• Redução de custos de gas em comparação com proxies tradicionais.
• Melhor organização de código, facilitando auditorias e manutenção.
• Aplicações práticas no Brasil: DeFi, NFTs, governança corporativa.

O que são Diamonds?

O termo Diamond refere‑se a um contrato inteligente que segue a especificação da EIP‑2535. Em vez de armazenar toda a lógica em um único contrato, o Diamond delega chamadas para múltiplos contratos auxiliares chamados facets. Cada facet contém um conjunto de funções relacionadas, e o Diamond mantém um lookup table que associa selectors de função (os primeiros 4 bytes do hash da assinatura) ao endereço da facet responsável.

Essa arquitetura permite que o contrato principal (o “Diamond”) permaneça estático em termos de endereço, enquanto sua funcionalidade pode ser expandida ou modificada simplesmente alterando a tabela de facets. O resultado é um contrato modular, upgradeable e mais legível.

Como funcionam os Facets?

Um facet é, na prática, um contrato Solidity que implementa um conjunto de funções públicas ou externas. Quando o Diamond recebe uma chamada, ele executa os seguintes passos:

1. Extrai o selector da chamada (os 4 bytes iniciais do calldata).
2. Consulta a Diamond Storage para encontrar o endereço da facet associada.
3. Usa delegatecall para executar a função na facet, preservando o contexto de armazenamento do Diamond.

Como o delegatecall mantém o storage slot do contrato chamador, todas as facets compartilham o mesmo estado, evitando a necessidade de migração de dados ao atualizar funcionalidades.

Estrutura da Diamond Storage

A Diamond Storage é um layout de armazenamento padronizado que contém, entre outros, os seguintes mapeamentos:

• mapping(bytes4 => address) selectorToFacet; – associa cada selector ao endereço da facet.
• mapping(address => bytes4[]) facetToSelectors; – lista de selectors implementados por cada facet.
• address[] facets; – array de facets registradas.

Esses mapeamentos são armazenados em slots de armazenamento fixos (geralmente utilizando keccak256('diamond.standard.diamond.storage')) para garantir que nenhuma facet sobrescreva acidentalmente o layout.

Vantagens de usar Diamonds

A adoção de Diamonds traz benefícios tangíveis tanto para desenvolvedores quanto para usuários finais:

1. Atualizações Granulares

Em vez de substituir um contrato inteiro, você pode atualizar apenas a facet que contém a lógica problemática. Isso reduz o risco de introduzir bugs em áreas não relacionadas.

2. Redução de Gas

Ao dividir a lógica em facets menores, o tamanho do bytecode de cada facet é reduzido, tornando o delegatecall mais barato que a chamada a um contrato proxy que contém toda a lógica em um único bytecode.

3. Organização e Legibilidade

Facets permitem que equipes trabalhem em módulos independentes (por exemplo, token management, governance, staking), facilitando revisões de código e auditorias de segurança.

4. Compatibilidade com Ferramentas Existentes

Ferramentas como Hardhat e OpenZeppelin Upgrades já oferecem plugins para gerar e testar Diamonds, simplificando a curva de aprendizado.

Comparação: Diamonds vs. Proxy Pattern

O padrão de upgrade mais conhecido no ecossistema Ethereum é o Proxy Pattern, popularizado pela OpenZeppelin. Embora ambos permitam atualizações, eles divergem em alguns pontos críticos:

Critério	Proxy (OpenZeppelin)	Diamond (EIP‑2535)
Complexidade de código	Baixa (um único implementation)	Alta (gerenciamento de facets)
Custo de deployment	Alto (bytecode grande)	Mais baixo (bytecode dividido)
Granularidade de upgrade	Todo o contrato	Facets individuais
Limite de funções	~2.000 selectors (limite de tamanho do bytecode)	Praticamente ilimitado (múltiplas facets)
Risco de colisão de storage	Alto se não usar storage gaps	Minimizado por layout padronizado

Para projetos que exigem expansão contínua (por exemplo, plataformas DeFi que lançam novos módulos a cada trimestre), os Diamonds se mostram mais adequados.

Implementação Prática no Solidity

A seguir, apresentamos um exemplo simplificado de como criar um Diamond usando a biblioteca @solidstate/contracts, que já incorpora a EIP‑2535.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@solidstate/contracts/proxy/diamond/Diamond.sol";
import "@solidstate/contracts/proxy/diamond/DiamondCutFacet.sol";
import "@solidstate/contracts/proxy/diamond/DiamondLoupeFacet.sol";
import "@solidstate/contracts/access/ownership/Ownable.sol";

contract MyDiamond is Diamond, DiamondCutFacet, DiamondLoupeFacet, Ownable {
    constructor(address _owner, address[] memory _facets, bytes4[][] memory _selectors) {
        // Configura o proprietário
        _transferOwnership(_owner);
        // Executa o cut inicial
        IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](_facets.length);
        for (uint256 i = 0; i < _facets.length; i++) {
            cut[i] = IDiamondCut.FacetCut({
                facetAddress: _facets[i],
                action: IDiamondCut.FacetCutAction.Add,
                functionSelectors: _selectors[i]
            });
        }
        IDiamondCut(address(this)).diamondCut(cut, address(0), "");
    }
}

O código acima demonstra:

• Como herdar as facets padrão (Cut e Loupe).
• Como registrar facets adicionais no construtor.
• Como proteger a administração usando Ownable.

Para quem prefere frameworks mais completos, a OpenZeppelin ainda não oferece suporte nativo a Diamonds, mas a comunidade tem criado templates Hardhat que facilitam a integração.

Segurança e Auditoria de Diamonds

Embora o padrão ofereça vantagens, ele também introduz novos vetores de risco que precisam ser mitigados:

1. Controle de Acesso ao Diamond Cut

Somente endereços autorizados (geralmente o proprietário ou um DAO) devem poder chamar diamondCut. Caso contrário, um atacante poderia substituir facets críticas e roubar fundos.

2. Consistência de Storage

Cada facet deve respeitar o layout de Diamond Storage. Um erro de sobrescrita pode corromper o estado global. Recomenda‑se usar bibliotecas como LibDiamond para encapsular o acesso ao storage.

3. Verificação de Selectors Duplicados

Ao adicionar uma nova facet, o sistema verifica se os selectors já existem. Falhas nessa verificação podem gerar comportamentos inesperados.

4. Testes de Integração

É fundamental escrever tests que cubram cenários de upgrade, remoção e substituição de facets. Ferramentas como forge (Foundry) e hardhat-deploy permitem simular upgrades em ambientes locais.

Custos Operacionais: Gas e Manutenção

Um estudo de caso realizado em 2024 por CryptoAnalytics BR comparou o consumo de gas de um contrato proxy tradicional com um Diamond contendo 10 facets. Os resultados foram:

• Deploy inicial: Proxy – R$ 1.200; Diamond – R$ 800.
• Chamada de função (média): Proxy – 45.000 gas; Diamond – 38.000 gas.
• Upgrade (adicionar facet): Proxy – R$ 250; Diamond – R$ 150.

Esses números mostram que, apesar da complexidade adicional, os Diamonds podem gerar economia de até 30% em custos de gas ao longo do tempo, especialmente em projetos que realizam múltiplas atualizações.

Casos de Uso no Brasil

Várias startups brasileiras já adotaram o padrão Diamond para seus produtos:

• CryptoBank BR: Plataforma de empréstimos DeFi que adiciona novos módulos de garantia sem interromper os contratos existentes.
• ArtNFT: Marketplace que incorpora funcionalidades de royalties dinâmicos, permitindo que artistas atualizem a lógica de distribuição de forma transparente.
• GovChain: Solução de governança corporativa que usa facets distintas para votação, delegação e execução de propostas.

Esses exemplos demonstram como a modularidade dos Diamonds facilita a inovação contínua, um ponto crucial em um mercado tão dinâmico quanto o cripto.

Como Começar a Usar Diamonds

1. Estude a EIP‑2535: Leia a especificação oficial e entenda os requisitos de storage.
2. Escolha um framework: Hardhat + @solidstate/contracts ou Foundry com templates de Diamond.
3. Defina suas facets: Separe a lógica por domínio (token, governança, staking, etc.).
4. Implemente o controle de acesso: Use Ownable ou um contrato DAO para gerenciar o diamondCut.
5. Teste extensivamente: Simule upgrades, remoções e conflitos de selectors.
6. Audite o código: Contrate auditorias especializadas em padrões de upgrade.

Para quem já possui contratos legacy, a migração pode ser feita criando um novo Diamond que delega chamadas para os contratos antigos via facets de wrapper, preservando o estado existente.

Conclusão

Os Diamonds representam uma evolução natural dos contratos inteligentes no Brasil, oferecendo upgradeability granular, melhor organização de código e redução de custos de gas. Embora exijam disciplina na implementação e auditoria cuidadosa, os benefícios superam os desafios, especialmente para projetos que pretendem crescer e evoluir continuamente. Ao adotar o padrão EIP‑2535, desenvolvedores brasileiros podem construir soluções mais robustas, seguras e preparadas para o futuro da Web3.

Perguntas Frequentes