Merge pull request AmazingAng#630 from marcelojsilva/feature_ptbr

Feature ptbr

Languages/en/README.md

@@ -1,6 +1,6 @@
 ![](../../img/logo2.jpeg)
 
-**[中文](https://github.com/AmazingAng/WTF-Solidity) / [Español](../es/README.md)**
+**[中文](https://github.com/AmazingAng/WTF-Solidity) / [Español](../es/README.md) / [Português Brasileiro](../pt-br/README.md)**
 
 # WTF Solidity
 

Languages/es/README.md

@@ -1,6 +1,6 @@
 ![](../../img/logo2.jpeg)
 
-**[中文版本](https://github.com/AmazingAng/WTF-Solidity) / [English Version](../en/README.md)**
+**[中文版本](https://github.com/AmazingAng/WTF-Solidity) / [English Version](../en/README.md) / [Português Brasileiro](../pt-br/README.md)**
 
 # WTF Solidity
 

Languages/pt-br/01_HelloWeb3/HelloWeb3.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+contract HelloWeb3{
+    string public _string = "Hello Web3!";
+}

Languages/pt-br/01_HelloWeb3/readme.md

@@ -0,0 +1,90 @@
+## 1. Olá Web3 (Três linhas de código)
+
+Recentemente, tenho revisitado o estudo do Solidity para consolidar alguns detalhes e criar um "Guia de Introdução ao Solidity" para iniciantes (programadores avançados podem buscar outros tutoriais). Será atualizado semanalmente com 1-3 lições.
+
+Twitter: [@0xAA_Science](https://twitter.com/0xAA_Science)
+
+Comunidade: [Discord](https://discord.gg/5akcruXrsk) | [Grupo do WhatsApp](https://docs.google.com/forms/d/e/1FAIpQLSe4KGT8Sh6sJ7hedQRuIYirOoZK_85miz3dw7vA1-YjodgJ-A/viewform?usp=sf_link) | [Website wtf.academy](https://wtf.academy)
+
+Todo o código e tutorial estão disponíveis no GitHub: [github.com/AmazingAng/WTFSolidity](https://github.com/AmazingAng/WTF-Solidity)
+
+-----
+
+## Introdução ao Solidity
+
+`Solidity` é uma linguagem de programação utilizada para escrever contratos inteligentes na Máquina Virtual Ethereum (`EVM`). Acredito que dominar o `Solidity` seja uma habilidade essencial para quem deseja se envolver em projetos blockchain: a maioria dos projetos blockchain são de código aberto e entender o código pode ajudar a evitar perder dinheiro em projetos ruins.
+
+`Solidity` possui duas características:
+
+1. "Orientado a Objetos": Aprender `Solidity` pode ajudá-lo a conseguir um bom emprego no campo blockchain e encontrar parceiros ideais.
+2. "Avançado": Não saber `Solidity` em um ambiente de criptomoedas pode ser visto como desatualizado.
+
+## Ferramenta de Desenvolvimento: Remix
+
+Neste tutorial, utilizaremos o `Remix` para trabalhar com contratos `Solidity`. O `Remix` é um ambiente integrado de desenvolvimento de contratos inteligentes recomendado oficialmente pela Ethereum, ideal para iniciantes, pois permite o rápido desenvolvimento e a implantação de contratos diretamente no navegador, sem a necessidade de instalar nada localmente.
+
+Site: [https://remix.ethereum.org](https://remix.ethereum.org)
+
+No `Remix`, o menu à esquerda tem três botões, que correspondem a arquivos (para escrever código), compilar (para executar o código) e implantar (para implantar o contrato na blockchain). Clique no botão "Criar novo arquivo" (`Create New File`), para criar um contrato `Solidity` em branco.
+
+![Painel do Remix](./img/1-1.png)
+
+## Primeiro Programa em Solidity
+
+Este programa simples consiste em 1 linha de comentário e 3 linhas de código:
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+contract HelloWeb3{
+    string public _string = "Olá Web3!";
+}
+```
+
+Vamos analisar o programa e aprender sobre a estrutura de um arquivo de código Solidity:
+
+1. A primeira linha é um comentário que indica a licença de software que o código está utilizando, neste caso, a licença MIT. Se a licença não for especificada, o compilador emitirá um aviso, mas o programa ainda será executado. Comentários em Solidity começam com "//" seguido pelo conteúdo do comentário.
+
+   ```solidity
+   // SPDX-License-Identifier: MIT
+   ```
+
+2. A segunda linha declara a versão do Solidity que este arquivo está usando, pois a sintaxe varia entre versões. Esta linha indica que o arquivo só pode ser compilado com a versão 0.8.4 do compilador Solidity, até a versão 0.9.0 (a segunda condição é fornecida pelo "^"). As declarações em Solidity terminam com ponto e vírgula (`;`).
+
+   ```solidity
+   pragma solidity ^0.8.4;
+   ```
+
+3. As linhas 3-4 são a parte do contrato. A linha 3 cria o contrato (`contract`) e declara que o nome do contrato é `HelloWeb3`. A linha 4 é o corpo do contrato, declarando uma variável string `_string` pública, com o valor "Olá Web3!".
+
+   ```solidity
+   contract HelloWeb3 {
+       string public _string = "Olá Web3!";
+   }
+   ```
+
+Continuaremos a investigar variáveis mais detalhadamente no Solidity.
+
+## Compilando e Implantando o Código
+
+Na página de edição de código do Remix, pressione Ctrl + S para compilar o código, é muito conveniente.
+
+Após a compilação, clique no botão "Implantar" no menu à esquerda para acessar a página de implantação.
+
+![Imagem de Implantação](./img/1-2.png)
+
+Por padrão, o `Remix` usa a Máquina Virtual `Remix` (anteriormente conhecida como Máquina Virtual JavaScript) para simular a rede Ethereum ao executar contratos inteligentes, como se fosse uma rede de testes no navegador. O `Remix` também oferece algumas contas de teste, cada uma com 100 ETH (tokens de teste) para uso. Clique em `Deploy` (botão amarelo) para implantar o contrato que escrevemos.
+
+![Imagem do _string](./img/1-3.png)
+
+Após a implantação bem-sucedida, você verá o contrato chamado `HelloWeb3`. Clique em `_string` para ver a mensagem "Olá Web3!".
+
+## Conclusão
+
+Nesta lição, introduzimos brevemente o `Solidity` e a ferramenta `Remix`, e concluímos nosso primeiro programa `Solidity` - `HelloWeb3`. A seguir, continuaremos a estudar o `Solidity` de forma mais aprofundada!
+
+### Recursos recomendados em Solidity
+
+1. [Solidity Documentation](https://docs.soliditylang.org/en/latest/)
+2. [Solidity Tutorial by freeCodeCamp](https://www.youtube.com/watch?v=ipwxYa-F1uY)
+

Languages/pt-br/02_ValueTypes/ValueTypes.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+contract ValueTypes{
+    // Valores booleanos
+    bool public _bool = true;
+    // Operações booleanas
+    //取非
+    //e
+    //ou
+    //igual
+    //não é igual
+
+
+    // Número inteiro
+    int public _int = -1;
+    uint public _uint = 1;
+    uint256 public _number = 20220330;
+    // Operações com números inteiros
+    // +, -, *, /
+    // Índice
+    // Pegar o resto da divisão
+    // Comparar tamanhos
+
+
+    // Endereço
+    address public _address = 0x7A58c0Be72BE218B41C608b7Fe7C5bB630736C71;
+    // endereço pagável, você pode enviar e receber pagamentos, verificar o saldo
+    // Membro do tipo de endereço
+    // saldo do endereço
+
+
+    // Matriz de bytes de comprimento fixo
+    // bytes32: 0x4d696e69536f6c69646974790000000000000000000000000000000000000000
+    // bytes1: 0x4d
+
+
+    // Enum
+    // Comprar, Manter, Vender
+    enum ActionSet { Buy, Hold, Sell }
+    // Criar uma variável enum chamada "action"
+    ActionSet action = ActionSet.Buy;
+
+    // enum pode ser convertido explicitamente para uint
+    function enumToUint() external view returns(uint){
+        return uint(action);
+    }
+}
+

Languages/pt-br/02_ValueTypes/readme.md

@@ -0,0 +1,159 @@
+---
+title: 2. Tipos de Valor
+tags:
+  - solidity
+  - básico
+  - wtfacademy
+---
+
+# WTF Introdução Simplificada ao Solidity: 2. Tipos de Valor
+
+Recentemente, tenho revisado Solidity para consolidar alguns detalhes e estou escrevendo um "WTF Introdução Simplificada ao Solidity" para ajudar iniciantes (programadores avançados podem procurar outros tutoriais). Será atualizado semanalmente com 1-3 lições.
+
+Twitter: [@0xAA_Science](https://twitter.com/0xAA_Science)
+
+Comunidade: [Discord](https://discord.gg/5akcruXrsk)｜[Grupo no WeChat](https://docs.google.com/forms/d/e/1FAIpQLSe4KGT8Sh6sJ7hedQRuIYirOoZK_85miz3dw7vA1-YjodgJ-A/viewform?usp=sf_link)｜[Website wtf.academy](https://wtf.academy)
+
+Todo o código e tutorial estão disponíveis no Github: [github.com/AmazingAng/WTFSolidity](https://github.com/AmazingAng/WTF-Solidity)
+
+-----
+
+## Tipos de Variáveis no Solidity
+
+1. **Tipo de Valor (Value Type)**: incluem booleanos, inteiros, etc., esses tipos de variáveis passam diretamente o valor ao serem atribuídas.
+
+2. **Tipo de Referência (Reference Type)**: incluem arrays e structs, esses tipos de variáveis ocupam mais espaço e passam o endereço diretamente ao serem atribuídas (semelhante a ponteiros).
+
+3. **Tipo de Mapeamento (Mapping Type)**: Estrutura de dados para armazenar pares chave-valor no Solidity, pode ser entendido como uma tabela de hash.
+
+Vamos abordar apenas os tipos comuns, os tipos menos utilizados não serão abordados, e neste artigo, falaremos sobre tipos de valor.
+
+## Tipos de Valor
+
+### 1. Booleano
+
+O tipo booleano é uma variável binária, com valores `true` ou `false`.
+
+```solidity
+// Booleano
+bool public _bool = true;
+```
+
+Os operadores booleanos incluem:
+
+- `!` (negação lógica)
+- `&&` (e lógico, "and")
+- `||` (ou lógico, "or")
+- `==` (igual a)
+- `!=` (diferente de)
+
+```solidity
+// Operações booleanas
+bool public _bool1 = !_bool; // negação
+bool public _bool2 = _bool && _bool1; // e
+bool public _bool3 = _bool || _bool1; // ou
+bool public _bool4 = _bool == _bool1; // igual
+bool public _bool5 = _bool != _bool1; // diferente
+```
+
+No código acima: a variável `_bool` possui o valor `true`; `_bool1` é a negação de `_bool`, ou seja, `false`; `_bool && _bool1` é `false`; `_bool || _bool1` é `true`; `_bool == _bool1` é `false`; `_bool != _bool1` é `true`.
+
+**Observe que:** os operadores `&&` e `||` seguem a regra da avaliação de curto-circuito, o que significa que, se houver uma expressão `f(x) || g(y)`, e `f(x)` for `true`, `g(y)` não será avaliado, mesmo que o resultado seja o oposto de `f(x)`. Da mesma forma, se houver uma expressão `f(x) && g(y)`, e `f(x)` for `false`, `g(y)` não será avaliado.
+
+### 2. Inteiro
+
+Os inteiros são tipos de dados inteiros no Solidity, os mais comuns são:
+
+```solidity
+// Inteiros
+int public _int = -1; // inteiro, incluindo números negativos
+uint public _uint = 1; // inteiro positivo
+uint256 public _number = 20220330; // inteiro positivo de 256 bits
+```
+
+Os operadores de inteiro comuns incluem:
+
+- Operadores de comparação (retornam um valor booleano): `<=`, `<`, `==`, `!=`, `>=`, `>`
+- Operadores aritméticos: `+`, `-`, `*`, `/`, `%` (resto da divisão), `**` (potenciação)
+
+```solidity
+// Operações com inteiros
+uint256 public _number1 = _number + 1; // +, -, *, /
+uint256 public _number2 = 2**2; // potenciação
+uint256 public _number3 = 7 % 2; // resto da divisão
+bool public _numberbool = _number2 > _number3; // comparação
+```
+
+Você pode executar o código acima para ver os valores das 4 variáveis.
+
+### 3. Endereço
+
+O tipo de dado endereço (address) possui duas variantes:
+
+- Endereço normal (address): armazena um valor de 20 bytes (tamanho de um endereço Ethereum).
+- Endereço pagável (payable address): além do endereço normal, inclui os métodos `transfer` e `send` para receber transferências de Ether.
+
+Falaremos mais sobre endereços pagáveis em capítulos posteriores.
+
+```solidity
+// Endereço
+address public _address = 0x7A58c0Be72BE218B41C608b7Fe7C5bB630736C71;
+address payable public _address1 = payable(_address); // endereço pagável, permite transferências e verificar saldo
+// Membros do tipo de endereço
+uint256 public balance = _address1.balance; // saldo do endereço
+```
+
+### 4. Arrays de Bytes de Comprimento Fixo
+
+Os arrays de bytes podem ser de comprimento fixo ou variável:
+
+- Arrays de bytes de comprimento fixo: são tipos de valor, o comprimento do array não pode ser alterado após a declaração. Existem tipos como `bytes1`, `bytes8`, `bytes32`, etc. O máximo é armazenar 32 bytes, ou seja, `bytes32`.
+- Arrays de bytes de comprimento variável: são tipos de referência (serão abordados em capítulos posteriores), o comprimento do array pode ser alterado após a declaração, como o tipo `bytes`.
+
+```solidity
+// Array de Bytes de Comprimento Fixo
+bytes32 public _byte32 = "MiniSolidity"; 
+bytes1 public _byte = _byte32[0]; 
+```
+
+No código acima, a variável `MiniSolidity` é armazenada em `_byte32` como uma sequência de bytes. Se convertido para hexadecimal, seria: `0x4d696e69536f6c69646974790000000000000000000000000000000000000000`
+
+O valor de `_byte` será o primeiro byte de `_byte32`, ou seja, `0x4d`.
+
+### 5. Enum (Enumerado)
+
+Enum é um tipo de dado que pode ser definido pelo usuário no Solidity. Geralmente é usado para atribuir nomes a `uint`, facilitando a leitura e manutenção do código. Se parece com `enum` em linguagens como C, onde os nomes são atribuídos a partir de `0`.
+
+```solidity
+// Definindo um enum para Buy, Hold e Sell
+enum ActionSet { Buy, Hold, Sell }
+// Criando uma variável enum chamada action
+ActionSet action = ActionSet.Buy;
+```
+
+É possível converter explicitamente `enum` em `uint` e vice-versa, e o Solidity verificaria se o inteiro positivo convertido está dentro do intervalo do `enum`, caso contrário, ocorrerá um erro:
+
+```solidity
+// Conversão explícita de enum em uint
+function enumToUint() external view returns(uint){
+    return uint(action);
+}
+```
+
+O `enum` é um tipo de dados pouco utilizado, raramente usado.
+
+## Executando no Remix
+
+- Após a implantação do contrato, é possível verificar os valores das variáveis de cada tipo:
+
+![2-1.png](./img/2-1.png)
+
+- Exemplo de conversão entre `enum` e `uint`:
+
+![2-2.png](./img/2-2.png)
+![2-3.png](./img/2-3.png)
+
+## Conclusão
+
+Neste artigo, apresentamos os tipos de valor no Solidity, incluindo booleanos, inteiros, endereços, arrays de bytes de comprimento fixo e enum. Nos próximos capítulos, continuaremos discutindo outros tipos de variáveis no Solidity, como os tipos de referência e mapeamento.
+

Languages/pt-br/03_Function/Function.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+contract FunctionTypes{
+    uint256 public number = 5;
+
+    constructor() payable {}
+
+    // Tipo de função
+    // função (<tipos de parâmetros>) {interno|externo} [puro|visualização|pagável] [retorna (<tipos de retorno>)]
+    // função padrão
+    function add() external{
+        number = number + 1;
+    }
+
+    // puro: puro boi cavalo
+    function addPure(uint256 _number) external pure returns(uint256 new_number){
+        new_number = _number+1;
+    }
+
+    // view: Espectador
+    function addView() external view returns(uint256 new_number) {
+        new_number = number + 1;
+    }
+
+    // internal: Função interna
+    function minus() internal {
+        number = number - 1;
+    }
+
+    // As funções dentro do contrato podem chamar funções internas.
+    function minusCall() external {
+        minus();
+    }
+
+    // payable: função que permite enviar ETH para o contrato
+    function minusPayable() external payable returns(uint256 balance) {
+        minus();    
+        balance = address(this).balance;
+    }
+}