# Como usar a programação do Solidity O Solidity é usado para criar contratos inteligentes complexos projetados para operar no Ethereum [blockchain](https://www.ionos.com/digitalguide/online-marketing/online-sales/blockchain/ "Blockchain")\*\*. Essa linguagem apresenta estratégias exclusivas que a diferenciam de outras linguagens de programação. ## O que é Solidity? Solidity é uma linguagem de programação de alto nível para a criação de contratos inteligentes na blockchain da Ethereum. Os contratos inteligentes são **contratos autoexecutáveis que automatizam a troca de ativos entre as partes**. O que há de especial neles é que não são necessários intermediários para garantir a conformidade com o contrato inteligente. Solidity [source code](https://www.ionos.com/digitalguide/websites/web-development/source-code-explained-definition-examples/ "Código-fonte explicado: Definition & Examples") é compilado em bytecode e **implantado** no blockchain da Ethereum como um contrato inteligente. Uma vez concluído, o contrato inteligente pode ser executado por qualquer nó da rede, e o estado é armazenado no blockchain. Mostramos um exemplo de um contrato simples que modela uma máquina de venda automática de NFT: ```solidity pragma Solidity 0.8.7; contract NFTVendingMachine { // Declare state variables address public owner; mapping (address => uint) public nftBalance; // Run on deployment constructor() { owner = msg.sender; nftBalance[address(this)] = 100; } // Allow the owner to restock the NFT balance function restock(uint amount) public { require(msg.sender == owner, "Only the owner can restock."); nftBalance[address(this)] += amount; } // Allow anyone to purchase NFTs function purchase(uint amount) public payable { require(msg.value >= amount * 1 ether, "You must pay at least 1 ETH per NFT"); require(nftBalance[address(this)] >= amount, "Not enough NFTs in stock to complete this purchase"); nftBalance[address(this)] -= amount; nftBalance[msg.sender] += amount; } } ``` ## Para quais aplicativos o Solidity é adequado? O Solidity foi projetado especificamente para **criar aplicativos distribuídos** ou [DApps](https://www.ionos.com/digitalguide/websites/web-development/dapp/) executados na Máquina Virtual Ethereum (EVM). Os contratos inteligentes são adequados para gerenciar ativos digitais, criar trocas descentralizadas e implementar sistemas de votação, entre outras coisas. ### Finanças descentralizadas (DeFi) O Solidity está sendo usado para desenvolver aplicativos DeFi, tais como **câmbios descentralizados, plataformas de crédito e empréstimo, mercados de previsão e [cryptocurrencies](https://www.ionos.com/digitalguide/online-marketing/online-sales/cryptocurrency/ "Cryptocurrency")**. O DeFi se tornou um dos casos de uso mais populares da tecnologia blockchain. Nesse processo, o Solidity se tornou uma ferramenta indispensável para a criação de aplicativos DeFi na rede Ethereum. ### Tokens não fungíveis O [non-fungible token](https://www.ionos.com/digitalguide/online-marketing/online-sales/nft-non-fungible-token/ "NFT - Non-Fungible Token") (NFT), tem desfrutado de grande popularidade desde a década de 2020. Os NFTs são ativos digitais exclusivos armazenados no blockchain. Eles podem ser **obras de arte digital, memorabilia esportiva ou artefatos do setor de jogos**. O Solidity é usado para criar os contratos inteligentes que alimentam os NFTs. ### Gerenciamento da cadeia de entrega O Solidity pode ser usado para criar contratos inteligentes para **monitorar e gerenciar cadeias de suprimentos**. Os contratos são usados para automatizar vários processos da cadeia de suprimentos. Isso inclui o rastreamento da movimentação de mercadorias, a verificação da autenticidade dos produtos e o processamento de pagamentos entre as partes. ### Sistemas de reconciliação O Solidity pode ser usado para criar contratos inteligentes que **implementam sistemas de votação seguros e transparentes no blockchain**. Os contratos podem ser usados para garantir que os votos sejam contados corretamente e que o processo de votação seja justo e transparente. ## Quais são os prós e os contras do Solidity? Embora a Solidity seja uma linguagem poderosa para a criação de contratos inteligentes no blockchain da Ethereum, ela tem suas vantagens e desvantagens específicas que os desenvolvedores devem considerar ao desenvolver contratos inteligentes. No entanto, a criação de contratos inteligentes seguros exige um nível específico de **proficiência e cautela**. Como ilustração, abaixo está um **contrato inteligente que funciona como um buraco negro**. Qualquer Ether enviado para o contrato é consumido permanentemente, sem possibilidade de recuperar o Ether ou fazer um pagamento: ```solidity // SPDX-License-Identifier: GPL-3.0 pragma solidity >= 0.9.0; // This contract swallows all Ether sent to it contract Blackhole { event Received(address, uint); receive() external payable { emit Received(msg.sender, msg.value); } } ``` ### Vantagens da Solidez - **Flexibilidade**: o Solidity é uma linguagem versátil. Ela pode ser usada para desenvolver diferentes contratos inteligentes com uma variedade de casos de uso. - **Segurança**: o Solidity foi criado com foco na segurança, incorporando características como controles de acesso, tratamento de exceções e mecanismos de falha para ajudar os desenvolvedores a criar contratos seguros. - **Compatibilidade com Ethereum**: Atualmente, a Solidity é a linguagem preferida para a produção de contratos inteligentes no blockchain da Ethereum. - **Comunidade distinta**: Uma grande comunidade de desenvolvedores de blockchain trabalha com o Solidity, o que resulta em uma infinidade de recursos para aprendizado e solução de problemas. ### Desvantagens do Solidity - **Curva de aprendizado**: Para os desenvolvedores que são novos no desenvolvimento de blockchain e contratos inteligentes, o Solidity tem uma curva de aprendizado relativamente acentuada. - **Unchangeability**: Depois que um contrato inteligente é implantado no blockchain, ele não pode mais ser modificado. Portanto, os desenvolvedores precisam ser extremamente cuidadosos ao escrever e testar. - **Falta de verificação formal**: o Solidity não tem ferramentas integradas para revisão formal de código. Isso exige que os desenvolvedores utilizem ferramentas externas para garantir a precisão de seus contratos. - **Ferramentas limitadas**: o ecossistema de ferramentas do Solidity ainda está em seus estágios iniciais, o que pode resultar em problemas com ambientes de desenvolvimento integrado (IDEs), estruturas de teste e outras ferramentas de desenvolvimento. ## Qual é a sintaxe básica do Solidity? O Solidity é uma **linguagem de programação orientada a objetos projetada para contratos inteligentes**. Ela se inspira em JavaScript, Python e C++. A sintaxe da linguagem é semelhante à do JavaScript, embora com algumas idiossincrasias intrigantes. ### Variáveis no Solidity À primeira vista, o manuseio de variáveis do Solidity pode parecer semelhante ao de outras linguagens de programação. No entanto, uma distinção fundamental surge do fato de que a Máquina Virtual Ethereum (EVM) serve como ambiente de execução. Todas as **operações no EVM, inclusive o armazenamento de dados, incorrem em uma certa quantidade de custo de “gás”**. Consequentemente, durante a programação, é preciso avaliar a eficiência de uma operação e determinar como ela pode ser implementada da forma mais eficiente possível. Além das variáveis regulares, o Solidity tem **constantes, que devem ser definidas** durante a compilação. As constantes requerem menos gás para armazenamento: ```solidity // Regular variable can be declared without defining int a; // Constant needs to be defined at declaration int constant b = 51; ``` O mesmo se aplica às `immutable` variáveis, pois elas exigem menos gás e **não podem ser alteradas após a atribuição**. Ao contrário das `constant` variáveis, a atribuição de variáveis imutáveis pode ser feita em tempo de execução. ### Declarações de controle no Solidity Como uma linguagem de programação imperativa, o Solidity oferece suporte a instruções de controle familiares, como **branches e loops**. Mostramos o código para selecionar o maior de dois números, `a` e `b`: ```solidity int largerNumber = 0; // If-else statement if (a > b) { largerNumber = a; } else { largerNumber = b; } ``` O `for` **loop no Solidity** corresponde à sintaxe conhecida do JavaScript ou do C++: ```solidity // Loop 10 times for (int i = 0; i < 10; i++) { // … } ``` O `while` **loop também funciona normalmente**. Combinamos uma condição de encerramento com uma variável de contador numérico: ```solidity bool continueLoop = true; int counter = 0; // Loop at most 10 times while (continueLoop && counter < 10) { // … counter++; } ``` ### Tipos simples no Solidity O Solidity é uma **linguagem de tipagem estática** e suporta os tipos comumente encontrados em linguagens de programação. Os tipos simples que representam valores únicos incluem booleanos, números e strings. Os booleanos no Solidity mapeiam os valores `true` e `false`. Eles podem ser vinculados usando os **operadores booleanos conhecidos** e usados em `if` declarações: ```solidity bool paymentReceived = true; bool itemsStocked = true; bool continueTransaction = paymentReceived && itemsStocked; if (continueTransaction) { // ... } ``` O Solidity suporta uma **ampla gama de tipos numéricos**. Os números inteiros podem ser diferenciados entre números assinados (`int`) e números não assinados (`uint`) , sendo que o último só pode ser positivo. Além disso, o intervalo de um número pode ser especificado em etapas de 8 bits, de `int8` via `int16` até `int265`: ```solidity uint8 smallNumber = 120; int8 negativeNumber = -125; int8 result = smallNumber + negativeNumber; assert(result == -5) ``` As strings são usadas no Solidity principalmente para gerar mensagens de status. A linguagem suporta **aspas simples e duplas** , bem como caracteres Unicode: ```Solidity string message = 'Hello World'; string success = unicode"Transfer sent"; ``` ### Funções no Solidity **As funções são um aspecto fundamental** do Solidity, como na maioria das linguagens de programação. A definição de uma função é semelhante à do JavaScript, em que os tipos de argumentos devem ser explicitamente especificados. Além disso, uma palavra-chave returns é utilizada para indicar os tipos de valores. ```solidity // Define a function function addNumbers(int a, int b) returns (int) { return a + b; } ``` A **chamada de uma função** é feita como de costume: ```solidity // Call the function int result = addNumbers(2, 3); ``` É interessante notar que, **analogamente aos argumentos nomeados, os valores de retorno no Solidity também podem ser nomeados**. Nessa situação, a atribuição das variáveis correspondentes no corpo da função é suficiente, e um retorno explícito via `return` é desnecessário: ```solidity function divideNumbers(int dividend, int divisor) returns (int quotient) { quotient = dividend / divisor; // No `return` necessary } ``` Semelhante a `constant` ou `immutable` variáveis, no Solidity **as funções podem ser marcadas como não modificadoras de estado**. As palavras-chave `view` e `pure` são usadas para essa finalidade. Uma `view` função não altera o estado, enquanto uma `pure` função garante adicionalmente que não lerá as variáveis de estado. ### Contratos inteligentes no Solidity Além dos tipos padrão, o Solidity conhece um punhado de **tipos especializados em contratos inteligentes**. O tipo básico é `address` e mapeia endereços Ethereum. Os endereços que são `payable` podem receber transferências em Ether. Para essa finalidade, `payable` os endereços fornecem `balance()` e `transfer()` métodos. ```solidity // Get address of this contract address mine = address(this); // Get payable external address address payable other = payable(0x123); // Transfer if balances fulfill conditions if (other.balance < 10 && mine.balance >= 100) { other.transfer(10); } ``` Com base no `address` tipo, o `contract` tipo existe como uma construção central da linguagem. **Os contratos correspondem aproximadamente às classes em linguagens de programação orientadas a objetos**. Assim, os contratos agrupam dados e funções de estado e os protegem do mundo externo. Os contratos oferecem suporte à herança múltipla, como é conhecido em Python ou C++. Os contratos **geralmente começam com uma `pragma` linha** especificando a versão permitida do Solidity, seguida pela definição real: ```solidity // Make sure Solidity version matches pragma Solidity >=0.7.1 <0.9.0; // Contract definition contract Purchase { // Public state variables address seller; address buyer; // View-function function getSeller() external view returns (address) { return seller; } } ``` Os contratos inteligentes podem definir **dados e funções de estado**. Como é sabido em C++ e Java, um dos três níveis de acesso pode ser definido em cada caso: - `public`: A variável pode ser acessada **pela leitura e gravação de dentro do contrato**. Além disso, uma `view` função é gerada automaticamente como um getter para acesso de leitura externa. - `internal`: a variável está **protegida** do acesso externo. O acesso de leitura e gravação é possível de dentro do contrato, bem como de contratos herdados. - `private`: como `internal`, mas não há **acesso de contratos herdados** As funções podem ainda ser caracterizadas como `external`. Uma `external` função **atua como parte da interface do contrato** e é usada para acesso externo. A `receive` função para receber éter é um exemplo bem conhecido: ```solidity // Define without `function` keyword receive() external payable { // Handle Ether } ``` ### Modificadores no Solidity O Solidity tem uma construção de linguagem intrigante na forma de modificadores, que se assemelham aos decoradores do Python. Assim como no Python, os modificadores no Solidity são utilizados para **alterar a invocação de uma função**. Elas são frequentemente empregadas para garantir que uma condição específica seja atendida antes da execução de uma função: ```solidity contract Sale { uint price; address payable owner; modifier onlyOwner { // Will throw error if called by anyone other than the owner require( msg.sender == owner, "Only owner can call this function." ); // The wrapped function's body is inserted here _; } // `onlyOwner` wraps `changePrice` function changePrice(uint newPrice) public onlyOwner { // We'll only get here if the owner called this function price = newPrice; } } ``` ### Gerenciamento de transações com o Solidity O Solidity tem um gerenciamento de transações integrado. Ele pode ser usado para garantir que uma transferência de éter seja completamente liquidada ou não seja liquidada. A linguagem entende a `revert` palavra-chave, que aciona uma “reversão” de uma transação. Com a palavra-chave `error` , você pode definir seus próprios códigos de erro: ```solidity // Custom error definition error InsufficientPayment(uint256 paid, uint256 required); // Contract representing a sale contract Sale { uint price; // Purchase if enough ether transferred function purchase() public payable { if (msg.value < price) { revert InsufficientPayment(msg.value, price); } // Complete purchase } } ``` Outro **padrão encontrado com frequência** é o uso da `require()` função. Ela pode ser usada de forma análoga a `revert`: ```solidity // Using `require()` function if (!condition) revert("Error message"); // Equivalent to require(condition, "Error message"); ``` This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/programacao-solidity/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/programacao-solidity/) for AI/LLM consumption.