Como usar a programação do Solidity

O Solidity é usado para criar contratos inteligentes complexos projetados para operar no Ethereum 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 é 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:

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 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. 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 (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:

// 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:

// 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:

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++:

// 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:

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:

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:

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:

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.

// Define a function
function addNumbers(int a, int b) returns (int) {
    return a + b;
}

A chamada de uma função é feita como de costume:

// 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:

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.

// 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:

// 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:

// 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:

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:

// 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:

// Using `require()` function
if (!condition) revert("Error message");
// Equivalent to
require(condition, "Error message");