Pular para o conteúdo principal
Change page

Linguagens de contratos inteligentes

Última atualização da página: 26 de fevereiro de 2026

guilhermevendraminig (opens in a new tab)
rofisr (opens in a new tab)
rafarochar (opens in a new tab)
+20

Um grande aspecto sobre a Ethereum é que os contratos inteligentes podem ser programados usando linguagens relativamente amigáveis para o desenvolvedor. Se você tem experiência com Python ou qualquer linguagem de chaves (opens in a new tab), pode encontrar uma linguagem com sintaxe familiar.

As duas linguagens mais ativas e mantidas são:

  • Solidity
  • Vyper

O Remix IDE oferece um ambiente de desenvolvimento abrangente para a criação e teste de contratos em Solidity e Vyper. Experimente o Remix IDE no navegador (opens in a new tab) para começar a codificar.

Desenvolvedores mais experientes também podem querer usar o Yul, uma linguagem intermediária para a Máquina Virtual Ethereum, ou Yul+, uma extensão para Yul.

Se você está curioso e gosta de ajudar a testar novas linguagens que ainda estão em grande desenvolvimento, você pode experimentar com Fe, uma linguagem de contrato inteligente emergente que ainda está na sua infância.

Pré-requisitos

Conhecimento anterior de linguagens de programação, especialmente de JavaScript ou Python, pode ajudá-lo a entender as diferenças nas linguagens de contratos inteligentes. Nós também recomendamos que você entenda os contratos inteligentes como um conceito, antes de se aprofundar nas comparações de linguagem. Introdução aos contratos inteligentes.

Solidity

  • Linguagem de alto nível orientada para objetos para a implementação de contratos inteligentes.
  • Linguagem de marcações mais profundamente influenciada por C++.
  • Tipada estaticamente (o tipo de variável é conhecido em tempo de compilação).
  • Suporte:
    • Herança (você pode estender outros contratos).
    • Bibliotecas (você pode criar código reutilizável que pode ser chamado de diferentes contratos – como funções estáticas dentro de uma classe estática em outras linguagens de programação orientadas a objetos).
    • Tipos complexos definidos pelo usuário.

Links importantes

Contrato de exemplo

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // A palavra-chave "public" torna as variáveis
6    // acessíveis a partir de outros contratos
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Os eventos permitem que os clientes reajam a determinadas
11    // alterações de contrato que você declara
12    event Sent(address from, address to, uint amount);
13
14    // O código do construtor só é executado quando o contrato
15    // é criado
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Envia uma quantidade de moedas recém-criadas para um endereço
21    // Só pode ser chamado pelo criador do contrato
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // Envia uma quantidade de moedas existentes
29    // de qualquer chamador para um endereço
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "Saldo insuficiente.");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
Exibir tudo

Esse exemplo deve dar a você, uma ideia de como é a sintaxe de um contrato na Solidity. Para uma descrição mais detalhada das funções e variáveis, consulte a documentação (opens in a new tab).

Vyper

  • Linguagem de programação Pythonic
  • Digitação sólida
  • Código de compilador pequeno e compreensível
  • Geração de bytecode eficiente
  • Deliberadamente, tem menos recursos do que Solidity, com o objetivo de tornar os contratos mais seguros e mais fáceis de auditar. Vyper não suporta:
    • Modificadores
    • Herança
    • Montagem embutida
    • Sobrecarga de função
    • Sobrecarga do operador
    • Chamada recursiva
    • Repetições com comprimento infinito
    • Pontos fixos binários

Para mais informações, leia a justificativa do Vyper (opens in a new tab).

Links importantes

Exemplo

1# Leilão aberto
2
3# Parâmetros do leilão
4
5# O beneficiário recebe o dinheiro do maior lance
6
7beneficiary: public(address)
8auctionStart: public(uint256)
9auctionEnd: public(uint256)
10
11# Estado atual do leilão
12
13highestBidder: public(address)
14highestBid: public(uint256)
15
16# Definido como verdadeiro no final, não permite nenhuma alteração
17
18ended: public(bool)
19
20# Acompanhe os lances reembolsados para que possamos seguir o padrão de saque
21
22pendingReturns: public(HashMap[address, uint256])
23
24# Crie um leilão simples com tempo de lance de `_bidding_time`
25
26# segundos em nome do
27
28# endereço do beneficiário `_beneficiary`.
29
30@external
31def __init__(_beneficiary: address, _bidding_time: uint256):
32    self.beneficiary = _beneficiary
33    self.auctionStart = block.timestamp
34    self.auctionEnd = self.auctionStart + _bidding_time
35
36# Dê um lance no leilão com o valor enviado
37
38# junto com esta transação.
39
40# O valor só será reembolsado se o
41
42# leilão não for ganho.
43
44@external
45@payable
46def bid():
47    # Verifique se o período de lances terminou.
48    assert block.timestamp < self.auctionEnd
49    # Verifique se o lance é alto o suficiente
50    assert msg.value > self.highestBid
51    # Acompanhe o reembolso do licitante anterior com o lance mais alto
52    self.pendingReturns[self.highestBidder] += self.highestBid
53    # Acompanhe o novo lance mais alto
54    self.highestBidder = msg.sender
55    self.highestBid = msg.value
56
57# Saque um lance reembolsado anteriormente. O padrão de saque é
58
59# usado aqui para evitar um problema de segurança. Se os reembolsos fossem diretamente
60
61# enviados como parte do bid(), um contrato de lance malicioso poderia bloquear
62
63# esses reembolsos e, assim, impedir a entrada de novos lances mais altos.
64
65@external
66def withdraw():
67    pending_amount: uint256 = self.pendingReturns[msg.sender]
68    self.pendingReturns[msg.sender] = 0
69    send(msg.sender, pending_amount)
70
71# Encerre o leilão e envie o lance mais alto
72
73# para o beneficiário.
74
75@external
76def endAuction():
77    # É uma boa diretriz estruturar funções que interagem
78    # com outros contratos (ou seja, eles chamam funções ou enviam ether)
79    # em três fases:
80    # 1. verificação de condições
81    # 2. execução de ações (potencialmente alterando condições)
82    # 3. interação com outros contratos
83    # Se essas fases forem misturadas, o outro contrato poderá chamar
84    # de volta para o contrato atual e modificar o estado ou causar
85    # efeitos (pagamento de ether) a serem realizados várias vezes.
86    # Se as funções chamadas internamente incluírem interação com
87    # contratos externos, elas também deverão ser consideradas como interação com
88    # contratos externos.
89
90    # 1. Condições
91    # Verifique se o horário de término do leilão foi atingido
92    assert block.timestamp >= self.auctionEnd
93    # Verifique se esta função já foi chamada
94    assert not self.ended
95
96    # 2. Efeitos
97    self.ended = True
98
99    # 3. Interação
100    send(self.beneficiary, self.highestBid)
Exibir tudo

Esse exemplo deve dar-nos uma noção do que é a sintaxe do contrato Vyper. Para uma descrição mais detalhada das funções e variáveis, consulte a documentação (opens in a new tab).

Yul e Yul+

Se você é novo na Ethereum e ainda não fez qualquer codificação com linguagens de contrato inteligentes, recomendamos começar com Solidity ou Vyper. Apenas olhe para Yul ou Yul+ quando estiver familiarizado com as melhores práticas de segurança inteligente do contrato e com as especificações de trabalho com a EVM.

Yul

  • Linguagem intermediária para Ethereum.
  • Suporta a EVM e o Ewasm (opens in a new tab), um WebAssembly com sabor de Ethereum, e foi projetado para ser um denominador comum utilizável de ambas as plataformas.
  • Alvo para fases de otimização de alto nível que podem beneficiar tanto as plataformas EVM como Ewasm de forma igual.

Yul+

  • Uma extensão de baixo nível altamente eficiente para Yul.
  • Inicialmente projetado para um contrato de optimistic rollup.
  • Yul+ pode ser visto como uma proposta de atualização experimental para Yul, adicionando novos recursos.

Links importantes

Contrato de exemplo

O exemplo a seguir simples implementa uma função de energia. Pode ser compilado usando solc --strict-assembly --bin input.yul. O exemplo deve ser armazenado no arquivo input.yul.

1{
2    function power(base, exponent) -> result
3    {
4        switch exponent
5        case 0 { result := 1 }
6        case 1 { result := base }
7        default
8        {
9            result := power(mul(base, base), div(exponent, 2))
10            if mod(exponent, 2) { result := mul(base, result) }
11        }
12    }
13    let res := power(calldataload(0), calldataload(32))
14    mstore(0, res)
15    return(0, 32)
16}
Exibir tudo

Se você já tem bastante experiência com contratos inteligentes, uma implementação completa do ERC20 em Yul pode ser encontrada aqui (opens in a new tab).

Fe

  • Linguagem estaticamente digitada para a Máquina Virtual Ethereum (EVM).
  • Inspirado por Python e Rust.
  • O objetivo é ser fácil de aprender -- mesmo para desenvolvedores que são novos no ecossistema Ethereum.
  • Fe ainda está em seus estágios iniciais, a linguagem teve sua versão alfa em janeiro de 2021.

Links importantes

Contrato de exemplo

O seguinte é um contrato simples implementado em Fe.

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
16
Exibir tudo

Como escolher

Como com qualquer outra linguagem de programação, trata-se principalmente de escolher a ferramenta certa para o trabalho certo, assim como preferências pessoais.

Aqui estão algumas coisas a considerar se você ainda não tentou nenhuma das linguagens:

O que é que há de melhor em Solidity?

  • Se você for um iniciante, há muitos tutoriais e ferramentas de aprendizagem disponíveis. Veja mais sobre isso na seção Aprenda Programando.
  • Ótima ferramenta de desenvolvedor disponível.
  • Solidity tem uma grande comunidade de desenvolvedores, o que significa que você provavelmente encontrará respostas para as suas perguntas muito rapidamente.

O que há de melhor em Vyper?

  • Uma ótima maneira de começar para desenvolvedores de Python que querem escrever contratos inteligentes.
  • O Vyper tem um número menor de características que o torna ótimo para a rápida reprodução de ideias.
  • A Vyper visa ser fácil de controlar e o máximo legível ao ser humano.

O que é ótimo sobre Yul e Yul+?

  • Uma linguagem de baixo nível simples e funcional.
  • Permite aproximar-se muito mais da EVM bruta, o que pode ajudar a otimizar o uso de gás de seus contratos.

Comparações de linguagens

Para comparações de sintaxe básica, ciclo de vida do contrato, interfaces, operadores, estruturas de dados, funções, fluxo de controle e muito mais, confira esta folha de consulta da Auditless (opens in a new tab)

Leitura adicional

Este artigo foi útil?