Solidity

Solidity é uma linguagem de alto nível orientada a objetos para implementação de contratos inteligentes. Contratos inteligentes são programas que governam o comportamento de contas dentro do estado Ethereum.

Solidity é uma linguagem de colchetes projetada para atingir a Ethereum Virtual Machine (EVM). É influenciado por C++, Python e JavaScript. Você pode encontrar mais detalhes sobre quais idiomas o Solidity foi inspirado na seção de influências de idiomas .

O Solidity é tipado estaticamente, suporta herança, bibliotecas e tipos complexos definidos pelo usuário, entre outros recursos.

Com Solidity você pode criar contratos para usos como votação, crowdfunding, leilões cegos e carteiras multi-assinatura.

Um contrato no sentido de Solidity é uma coleção de código (suas funções ) e dados (seu estado ) que reside em um endereço específico na blockchain Ethereum. A linha declara uma variável de estado chamada do tipo ( unsigned integer de 256 bits ). Você pode pensar nisso como um único slot em um banco de dados que pode ser consultado e alterado chamando funções do código que gerencia o banco de dados. 

Estrutura de um Contrato:

Os contratos no Solidity são semelhantes às classes em linguagens orientadas a objetos. Cada contrato pode conter declarações de variáveis ​​de estado , funções , modificadores de função , eventos , erros , tipos de estrutura e tipos de enumeração . Além disso, os contratos podem herdar de outros contratos. Existem também tipos especiais de contratos chamados bibliotecas e interfaces .A seção sobre contratos contém mais detalhes do que esta seção, que serve para fornecer uma visão geral rápida.

Variáveis ​​de Estado:

Variáveis ​​de estado são variáveis ​​cujos valores são armazenados permanentemente no armazenamento de contrato.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract SimpleStorage {
  uint storedData; // State variable
  // ...
}

Funções:

As funções são as unidades executáveis ​​do código. As funções geralmente são definidas dentro de um contrato, mas também podem ser definidas fora dos contratos.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.1 <0.9.0;

contract SimpleAuction {
  function bid() public payable { // Function
      // ...
  }
}

// Helper function defined outside of a contract
function helper(uint x) pure returns (uint) {
  return x * 2;
}

As Chamadas de Função podem acontecer interna ou externamente e possuem diferentes níveis de visibilidade em relação a outros contratos. As funções aceitam parâmetros e retornam variáveis ​​para passar parâmetros e valores entre eles.

Modificadores de Função:

Modificadores de função podem ser usados ​​para alterar a semântica de funções de forma declarativa.

A sobrecarga, ou seja, ter o mesmo nome de modificador com parâmetros diferentes, não é possível. Assim como as funções, os modificadores podem ser substituídos .

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;

contract Purchase {
  address public seller;

  modifier onlySeller() { // Modifier
      require(
          msg.sender == seller,
          "Only seller can call this."
      );
      _;
  }

  function abort() public view onlySeller { // Modifier usage
      // ...
  }
}

Eventos:

Os eventos são interfaces de conveniência com os recursos de registro do EVM.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.21 <0.9.0;

contract SimpleAuction {
  event HighestBidIncreased(address bidder, uint amount); // Event

  function bid() public payable {
      // ...
      emit HighestBidIncreased(msg.sender, msg.value); // Triggering event
  }
}

Erros:

Os erros permitem definir nomes e dados descritivos para situações de falha. Erros podem ser usados ​​em instruções de reversão . Em comparação com as descrições de string, os erros são muito mais baratos e permitem que você codifique dados adicionais. Você pode usar NatSpec para descrever o erro para o usuário.

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

/// Not enough funds for transfer. Requested `requested`,
/// but only `available` available.
error NotEnoughFunds(uint requested, uint available);

contract Token {
  mapping(address => uint) balances;
  function transfer(address to, uint amount) public {
      uint balance = balances[msg.sender];
      if (balance < amount)
          revert NotEnoughFunds(amount, balance);
      balances[msg.sender] -= amount;
      balances[to] += amount;
      // ...
  }
}

Tipos de estrutura:

Structs são tipos personalizados definidos que podem agrupar várias variáveis ​​(consulte Structs na seção de tipos).

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract Ballot {
  struct Voter { // Struct
      uint weight;
      bool voted;
      address delegate;
      uint vote;
  }
}

Tipos de enumeração:

Enums podem ser usados ​​para criar tipos personalizados com um conjunto finito de 'valores constantes' (consulte Enums na seção de tipos).

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract Purchase {
  enum State { Created, Locked, Inactive } // Enum
}

Tipos:

Solidity é uma linguagem tipada estaticamente, o que significa que o tipo de cada variável (estado e local) precisa ser especificado. Solidity fornece vários tipos elementares que podem ser combinados para formar tipos complexos.

Além disso, os tipos podem interagir uns com os outros em expressões contendo operadores. Para obter uma referência rápida dos vários operadores, consulte Ordem de Precedência dos Operadores .

O conceito de valores “indefinidos” ou “nulos” não existe no Solidity, mas as variáveis ​​recém-declaradas sempre têm um valor padrão dependente de seu tipo. Para lidar com quaisquer valores inesperados, você deve usar a função revert para reverter toda a transação ou retornar uma tupla com um segundo boolvalor indicando sucesso.

Fonte:

https://docs.soliditylang.org/en/v0.8.17/