DEV Community: ViniBlack

Meu primeiro smart contract: Criando um token ERC-20 pt.2

ViniBlack — Tue, 27 Sep 2022 01:37:21 +0000

Esse é o sétimo post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos terminar de implementar as funções que faltou no token ERC-20 que criamos.

Ferramentas

Nesse post vamos utilizar o VS Code para editar o código, o Node.js para instalar e executar o código.

Vamos utilizar o mesmo projeto que criamos no post Subindo meu primeiro smart contract para blockchain, caso você não tenha visto clique aqui, caso você não tenha mais o código você pode pegar aqui.

CryptoCoin

Nesse post vamos implementar as funções e eventos que faltaram no token ERC-20 que criamos no post Criando um token ERC-20.
Vamos começar adicionando mais alguns métodos na nossa interface, a nossa interface atualmente está assim:

interface IERC20 {
  function totalSupply() external view returns(uint256);
  function balanceOf(address account) external view returns(uint256);
  function transfer(address to, uint256 quantity) external returns(bool);

  event Approval(address owner, address spender, uint256 value);
}

Vamos adicionar as seguintes funções:

allowance: Retorna o número de tokens que alguém pode transferir em nome de outro endereço.
approve: Define uma quantidade de tokens que pode ser transferida em nome de outro endereço.
transferFrom: Transfere uma quantidade de tokens para outro endereço utilizando o mecanismo de permissão.
increaseAllowance: Aumenta a quantidade de tokens que pode ser transferida em nome de outro endereço.
decreaseAllowance: Diminui a quantidade de tokens que pode ser transferida em nome de outro endereço.

E vamos adicionar mais um evento:

Approval: Emite um evento quando um endereço aprova uma quantidade de tokens para outro endereço.

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Enum: Onde criamos nossos Enums, que é um tipo de dado utilizado para armazenar um conjunto de valores constantes que não pode ser modificado.
Properties: Onde criamos nossas variáveis;
Modifiers: Onde criamos nossos modificadores;
Events: Onde criamos nossos eventos;
Constructor: Onde criamos nosso construtor;
Public Functions: Onde criamos nossas funções públicas;

Enum

Vamos criar um enum de status onde vamos definir o estado do nosso contrato.

// Enum
enum Status { PAUSED, ACTIVE, CANCELLED }

Variáveis

Vamos criar mais algumas variáveis para armazenar o endereço do dono do contrato, o estado do contrato, o valor do token e vamos criar dois mapping para verificar o saldo de um endereço e um mapping que tem outro mapping guardamos que endereço tem permissão de transferir uma quantidade de tokens em nome de outro endereço.

// Properties
string public constant name = "CryptoCoin";
string public constant symbol = "CRC";
uint8 public constant decimals = 18;
uint256 private totalsupply;

// <-- Adicionado nesse post
address private owner;
Status contractState;
uint256 valorToken;

mapping(address => uint256) private addressToBalance;
mapping(address => mapping (address => uint256)) allowed;
// -->

Modificadores

Vamos criar alguns modificadores para conseguirmos diferenciar nosso contrato.
O primeiro modificador que iremos criar é o isOwner, que irá verificar se o endereço que está tentando acessar o contrato é o dono do contrato.

// Modifiers
modifier isOwner() {
  require(msg.sender == owner , "Sender is not owner!");
  _;
}

O segundo modificador será o isActive, que irá verificar se o contrato está ativo.

modifier isActive() {
  require(contractState == Status.ACTIVE, "Contract is not Active!");
  _;
}

Eventos

Vamos criar um evento chamado Mint que vamos usar mais para frente para ser emitido quando criarmos mais tokens, esse evento vai receber o endereço do dono do contrato, o saldo do endereço do dono, a quantidade de tokens que queremos criar e o total de tokens que já existem no contrato.

// Events
event Mint(address owner, uint256 BalanceOwner, uint256 amount, uint256 supply);

E vamos criar um evento chamado Burn que vamos usar mais para frente também para ser emitido quando 'queimamos' tokens, esse evento vai receber o endereço do dono do contrato, a quantidade de tokens que queremos queimar e total de tokens que já existem no contrato.

event Burn(address owner, uint256 value, uint256 supply);

Construtor

No construtor vamos passar o total de tokens como parâmetro, definir o dono do contrato como quem realiza o deploy, o totalsupply recebendo o total e atribuir todos os tokens inicialmente para carteira do dono do contrato e o status inicial do contrato como ativo.

// Constructor

constructor(uint256 total) {
  owner = msg.sender;
  totalsupply = total;
  addressToBalance[msg.sender] = totalsupply;
  contractState = Status.ACTIVE;
}

Agora vamos adicionar mais algumas funções para conseguirmos gerenciar o status do nosso contrato, criar ou queimar tokens, realizar transferência em nome de um terceiro e matar nosso contrato, os funções do nosso contrato atualmente são essas:

//Public Functions
function totalSupply() public override view returns(uint256) {
  return totalsupply;
}

function balanceOf(address account) public override view returns(uint256) {
  return addressToBalance[account];
}

function transfer(address to, uint256 quantity) public override returns(bool) {
  require(addressToBalance[msg.sender] >= quantity, "Insufficient Balance to Transfer");

  addressToBalance[msg.sender] = addressToBalance[msg.sender] - quantity;
  addressToBalance[to] = addressToBalance[to] + quantity;

  emit Transfer(msg.sender, to, quantity);
  return true;
}

Vamos implementar as funções que criamos na nossa interface.

Quantidade restante de tokens

Vamos criar uma função pública chamada allowance que retorna o número restante de tokens que um terceiro pode transferir em nome de outro endereço. Ela espera dois parâmetros from endereço da carteira que tem permissão de realizar transferência em nome do spender.

function allowance(address from, address spender) public override view returns (uint) {
  return allowed[from][spender];
}

Permissão de transferência em nome de terceiro

Vamos criar uma função pública chamada approve que permite que um terceiro transfira tokens em nome de outro endereço. Ela espera dois parâmetros: 'spender' endereço de quem eu quero dar permissão de realizar a transferência e amount quantidade de tokens que eu quero dar permissão. Dentro desta função vamos chamar o evento allowed passando a carteira de quem está dando permissão, a carteira de quem está recebendo a permissão e a quantidade de tokens que está sendo permitida.
Após isso, vamos emitir o evento Approval passando a carteira de quem está dando permissão, a carteira de quem está recebendo a permissão e a quantidade de tokens que está sendo permitida.

function approve(address spender, uint256 amount) public override returns (bool) {
  allowed[msg.sender][spender] = amount;

  emit Approval(msg.sender, spender, amount);
  return true;
}

Transferência em nome de terceiro

Vamos criar uma função pública chamada transferFrom que irá movimentar tokens de uma carteira para outra. Ela espera três parâmetros sender endereço da carteira que tem permissão de realizar transferência em nome do recipient, recipient endereço da carteira que vai receber os tokens e amount quantidade de tokens que vai ser transferida.
Dentro desta função vamos verificar se o endereço que está tentando realizar a transferência tem permissão para realizar a transferência, se o valor que está sendo transferido é maior que zero e se o endereço que está transferindo tem saldo suficiente para realizar a transferência. Após isso, vamos emitir o evento Transfer passando a carteira de quem está realizando a transferência, a carteira de quem está recebendo a transferência e a quantidade de tokens que está sendo transferida.

function transferFrom(address sender, address recipient, uint256 amount)public isActive override returns(bool) {
  require(amount > 0, "Tranfer value invalid is not zero.");
  require(amount <= balanceOf(sender), "Insufficient Balance to Transfer");
  require(amount <= allowed[sender][msg.sender], "No allowed");

  addressToBalance[sender] -= amount;
  allowed[sender][msg.sender] -= amount;
  addressToBalance[recipient] += amount;

  emit Transfer(sender, recipient, amount);
  return true;
}

Aumentar permissão de transferência em nome de terceiro

Vamos criar uma função pública chamada increaseAllowance que irá aumentar a permissão de transferência em nome de terceiro. Ela espera dois parâmetros: 'spender' endereço da carteira que vai receber a permissão e addedValue quantidade de tokens que vai ser adicionada à permissão.
Dentro desta função vamos verificar se o endereço que está tentando receber a permissão é um endereço válido. Após isso, vamos aumentar a permissão de transferência e emitir o evento Approval passando a carteira de quem está chamando a função, a carteira de quem está recebendo a permissão e a quantidade de tokens que foram aprovados.

function increaseAllowance(address spender, uint256 addedValue) public override returns (bool){
  require(spender != address(0), "Invalid address!");

  allowed[msg.sender][spender] += addedValue;

  emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
  return true;
}

Diminuir permissão de transferência em nome de terceiro

Vamos criar uma função pública chamada decreaseAllowance que irá diminuir a permissão de transferência em nome de terceiro. Ela espera dois parâmetros: 'spender' endereço da carteira que vai receber a permissão e subtractedValue quantidade de tokens que vai ser removida da permissão.
Dentro desta função vamos verificar se o endereço que está tentando receber a permissão é um endereço válido. Após isso, vamos diminuir a permissão de transferência e emitir o evento Approval passando a carteira de quem está chamando a função, a carteira de quem está recebendo a permissão e a quantidade de tokens que foram aprovados.

function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) {
  require(spender != address(0), "Invalid address!");

  allowed[msg.sender][spender] -= subtractedValue;

  emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
  return true;
}

Estado do contrato

Vamos criar uma função pública chamada state que irá retornar o estado do contrato. Ela não espera nenhum parâmetro e retorna o valor de contractState.

function state() public view returns(Status) {
  return contractState;
}

Mudar o estado do contrato

Vamos criar uma função chamada setState que irá mudar o estado do contrato. Ela espera um parâmetro status que é o novo estado do contrato, como contractState é um enum então devemos passar um numérico de 0 a 2. Essa função só pode ser chamada pelo dono do contrato, por isso vamos passar o nosso modificado ìsOwner que verifica se o endereço que está chamando a função é o dono do contrato.
Dentro desta função vamos verificar se o novo estado do contrato é diferente do estado atual do contrato, se o novo estado do contrato é um estado válido. Após isso vamos definir o valor de contractState para o estado passado como parâmetro.

function setState(uint8 status) public isOwner {
  require(status <= 1, "Invalid status");

  if(status == 0) {
    require(contractState != Status.PAUSED, "The status is already PAUSED");
    contractState = Status.PAUSED;
  }else if(status == 1){
    require(contractState != Status.ACTIVE, "The status is already ACTIVE");
    contractState = Status.ACTIVE;
  }
}

Cunhando mais tokens

Vamos criar uma função pública chamada mint que irá cunhar mais tokens. Ela espera um parâmetro amount que é a quantidade de tokens que vai ser cunhada. Essa função só pode ser chamada pelo dono do contrato, por isso vamos passar o nosso modificado ìsOwner que verifica se o endereço que está chamando a função é o dono do contrato.
Dentro desta função vamos verificar se a quantidade de tokens que vai ser cunhada é maior que zero, se for maior que zero vamos aumentar o total de tokens em circulação e aumentar a quantidade de tokens do dono do contrato. Após isso, vamos emitir o evento Mint passando o endereço do dono do contrato, o saldo da carteira do dono do contrato e a quantidade de tokens existentes.

function mint(uint256 amount) public isActive isOwner {
  require(amount > 0, "Invalid mint value.");

  totalsupply += amount;
  addressToBalance[owner] += amount;

  emit Mint(owner,addressToBalance[owner], amount, totalSupply());
}

Queimando tokens

Vamos criar uma função pública chamada burn que irá queimar tokens. Ela espera um parâmetro amount que é a quantidade de tokens que vai ser queimada. Essa função só pode ser chamada pelo dono do contrato, por isso vamos passar o nosso modificado ìsOwner que verifica se o endereço que está chamando a função é o dono do contrato.
Dentro desta função vamos verificar se a quantidade de tokens que vai ser queimada é maior que zero, se for maior que zero vamos verificar se a quantidade de tokens que vai ser queimada é menor ou igual a quantidade de tokens em circulação, se for menor ou igual vamos verificar se a quantidade de tokens que vai ser queimada é menor ou igual a quantidade de tokens do dono do contrato. Após isso, vamos diminuir o total de tokens em circulação e diminuir a quantidade de tokens do dono do contrato. Após isso vamos emitir o evento Burn passando o endereço do dono do contrato, a quantidade de tokens queimados e a quantidade de tokens existentes.

function burn(uint256 amount) public isActive isOwner {
  require(amount > 0, "Invalid burn value.");
  require(totalSupply() >= amount, "The amount exceeds your balance.");
  require(balanceOf(owner) >= amount, "The value exceeds the owner's available amount");

  totalsupply -= amount;
  addressToBalance[owner] -= amount;

  emit Burn(owner, amount, totalSupply());
}

Matando o contrato

Vamos criar uma função pública chamada kill que irá matar o contrato. Essa função só pode ser chamada pelo dono do contrato, por isso vamos passar o nosso modificado ìsOwner que verifica se o endereço que está chamando a função é o dono do contrato.
Dentro desta função vamos mudar o estado do contrato para CANCELLED e vamos destruir o contrato e enviar todos os Ether do contrato para o dono do contrato.

function kill() public isOwner {
  contractState = Status.CANCELLED;
  selfdestruct(payable(owner));
}

Como ficou nosso código

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

interface IERC20 {

  function totalSupply() external view returns(uint256);
  function balanceOf(address account) external view returns(uint256);
  function transfer(address recipient, uint256 amount) external returns(bool);
  function allowance(address owner, address spender) external view returns (uint256);
  function approve(address spender, uint256 amount) external returns (bool);
  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
  function increaseAllowance(address spender, uint256 addedValue) external  returns (bool) ;
  function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) ;

  event Transfer(address from, address to, uint256 value);
  event Approval(address owner, address spender, uint256 value);

}

contract CryptoCoin is IERC20 {
  // Enum
  enum Status { PAUSED, ACTIVE, CANCELLED }

  //Properties
  address private owner;
  string public constant name = "CryptoCoin";
  string public constant symbol = "CRC";
  uint8 public constant decimals = 18;
  uint256 private totalsupply;
  Status contractState;
  uint256 valorToken;
  mapping(address => mapping (address => uint256)) allowed;
  mapping(address => uint256) private addressToBalance;

  // Modifiers
  modifier isOwner() {
    require(msg.sender == owner , "Sender is not owner!");
    _;
  }

  modifier isActive() {
    require(contractState == Status.ACTIVE, "Contract is not Active!");
    _;
  }

  // Events
  event Mint(address owner, uint256 BalanceOwner, uint256 amount, uint256 supply);
  event Burn(address owner, uint256 value, uint256 supply);


  //Constructor
  constructor(uint256 total) {
    owner = msg.sender;
    totalsupply = total;
    addressToBalance[msg.sender] = totalsupply;
    contractState = Status.ACTIVE;
  }

  //Public Functions
  function totalSupply() public override view returns(uint256) {
    return totalsupply;
  }

  function balanceOf(address tokenOwner) public override view returns(uint256) {
    return addressToBalance[tokenOwner];
  }

  function transfer(address recipient, uint256 amount) public isActive override returns(bool) {
    require(amount <= addressToBalance[msg.sender], "Insufficient Balance to Transfer");

    addressToBalance[msg.sender] -= amount;
    addressToBalance[recipient] += amount;

    emit Transfer(msg.sender, recipient, amount);
    return true;
  }

  function allowance(address from, address spender) public override view returns (uint) {
    return allowed[from][spender];
  }

  function approve(address spender, uint256 amount) public override returns (bool) {
    allowed[msg.sender][spender] = amount;

    emit Approval(msg.sender, spender, amount);
    return true;
  }

  function transferFrom(address sender, address recipient, uint256 amount)public isActive override returns(bool) {
    require(amount > 0, "Tranfer value invalid is not zero.");
    require(amount <= balanceOf(sender), "Insufficient Balance to Transfer");
    require(amount <= allowed[sender][msg.sender], "No allowed");

    addressToBalance[sender] -= amount;
    allowed[sender][msg.sender] -= amount;
    addressToBalance[recipient] += amount;

    emit Transfer(sender, recipient, amount);
    return true;
  }

  function increaseAllowance(address spender, uint256 addedValue) public override returns (bool){
    require(spender != address(0), "Invalid address!");

    allowed[msg.sender][spender] += addedValue;

    emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
    return true;
  }

  function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) {
    require(spender != address(0), "Invalid address!");

    allowed[msg.sender][spender] -= subtractedValue;

    emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
    return true;
  }

  function state() public view returns(Status) {
    return contractState;
  }

  function setState(uint8 status) public isOwner {
    require(status <= 1, "Invalid status");

    if(status == 0) {
      require(contractState != Status.PAUSED, "The status is already PAUSED");
      contractState = Status.PAUSED;
    }else if(status == 1){
      require(contractState != Status.ACTIVE, "The status is already ACTIVE");
      contractState = Status.ACTIVE;
    }
  }

  function mint(uint256 amount) public isActive isOwner {
    require(amount > 0, "Invalid mint value.");

    totalsupply += amount;
    addressToBalance[owner] += amount;

    emit Mint(owner,addressToBalance[owner], amount, totalSupply());
  }

  function burn(uint256 amount) public isActive isOwner {
    require(amount > 0, "Invalid burn value.");
    require(totalSupply() >= amount, "The amount exceeds your balance.");
    require(balanceOf(owner) >= amount, "The value exceeds the owner's available amount");

    totalsupply -= amount;
    addressToBalance[owner] -= amount;

    emit Burn(owner, amount, totalSupply());
  }

  // Kill
  function kill() public isOwner {
    contractState = Status.CANCELLED;
    selfdestruct(payable(owner));
  }
}

Deploy

Caso você queira entender com mais detalhes de como realizar o deploy de um smart contract clique aqui.
Na pasta script vamos criar um arquivo chamado deploy-cryptoCoin.js onde vamos escrever nossos códigos para deployar o contrato.

No arquivo deploy-cryptoCoin.js vamos importar os arquivos do hardhat e criar nossa função assíncrona main e capturar o retorno dos erros caso tenha algum.

const hre = require("hardhat");

async function main() {}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Dentro da função main vamos nos conectar ao contrato CryptoCoin, realizar o deploy deste contrato criando mil tokens e escrever no console o endereço do contrato de token.

const hre = require("hardhat");

async function main() {
  const CryptoCoin = await hre.ethers.getContractFactory("CryptoCoin");
  const cryptoCoin = await CryptoCoin.deploy(1000);
  await cryptoCoin.deployed();
  console.log("Endereço do CryptoCoin", cryptoCoin.address);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Como configuramos o hardhat no post anterior, no terminal vamos executar o seguinte comando:


npx hardhat run scripts/deploy-cryptoCoin.js --network goerli

Se tudo estiver certo esse irá retornar o endereço do nosso contrato.

Copiando os endereços e entrando no Goerli Etherscan podemos ver nossos contratos na blockchain da Goerli.
Esses são os contratos que subimos nesse post.

CryptoCoin

Conclusão

Esse foi o sétimo post da série "Meu primeiro smart contract".
Se tudo deu certo, agora você tem um smart contract que é capaz criar e queimar tokens, além de ter um sistema de pausa e cancelamento do contrato.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Criando airdrop de tokens ERC-20

ViniBlack — Wed, 17 Aug 2022 13:17:26 +0000

Esse é o sexto post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos criar um contrato de airdrop de tokens utilizando o hardhat.

Ferramentas

Nesse post vamos utilizar o VS Code para editar o código, o Node.js para instalar e executar o código.

Vamos continuar usando o mesmo projeto do post anterior, caso você não tenha visto o post anterior clique aqui.

Airdrop

Os airdrops de criptomoedas são uma estratégia de marketing usada pelas empresas para fornecer tokens a traders de criptomoedas existentes gratuitamente ou em troca de um trabalho promocional mínimo.

No VS Code, vamos criar dois novos arquivos dentro da pasta contracts um chamado 03-tokens.sol e outro chamado 05-airdrop.sol, dentro do 03-tokens.sol vamos copiar o código que criamos no post Criando um token ERC-20, caso você não tenho o código clique aqui. E colar dentro de 03-tokens.sol, e no 05-airdrop.sol vamos declarar as licenças do nosso contrato, a versão do contrato e dar um nome ao contrato como já fizemos antes, mas agora vamos importar 03-tokens.sol também.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./03-token.sol";

contract Airdrop  {

}

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Enum: Onde criamos nossos Enums, que é um tipo de dado utilizado para armazenar um conjunto de valores constantes que não pode ser modificado.
Properties: Onde criamos nossas variáveis;
Modifiers: Onde criamos nossos modificadores;
Events: Onde criamos nossos eventos;
Constructor: Onde criamos nosso construtor;
Public Functions: Onde criamos nossas funções públicas;
Private Functions: Onde criamos nossas funções privadas;

Enum

Para criar um enum precisamos declarar o nome e entre as chaves os valores que ele pode ter.

// Enum
enum Status { PAUSED, ACTIVE, CANCELLED }

Clique aqui para ver mais sobre o enum.

Variáveis

Para fazer o nosso contrato de airdrop, precisamos criar algumas variáveis.

owner: Que vai ser uma variável privada do tipo address;
subscribers: Que vai ser um array de endereços privada do tipo address;
tokenAddress: Que vai ser do tipo address;
Status: Que vai receber contractState, quando criarmos o nosso construtor isso vai fazer mais sentido;
subscribersMapping: Que vai ser um mapping que irá receber address como "chave" e bool como "valor";

// Properties
address private owner;
address[] private subscribers;
address public tokenAddress;

Status contractState;
mapping(address => bool) subscribersMapping;

Modifiers

Vamos criar alguns modifiers para conseguirmos gerenciar nosso contrato.

O primeiro modifier é o isOwner, que vai ser responsável por verificar se o endereço que está tentando acessar o contrato é o dono do contrato.

modifier isOwner() {
  require(msg.sender == owner , "Sender is not owner!");
  _;
}

O segundo modifier é o isActived, que vai ser responsável por verificar se o nosso contrato está ativo.

modifier isActived() {
  require(contractState == Status.ACTIVE, "The contract is not active!");
  _;
}

Construtor

Como vamos fazer um contrato de airdrop de token, precisamos passar o endereço do contrato do token como parâmetro, então vamos definir que tokenAddress irá receber o parâmetro token que é o endereço do contrato do token, e vamos definir que owner vai ser o endereço que realizar o deploy do contrato de airdrop e definimos que contractState vai iniciar com Status.PAUSED.

// Constructor
constructor(address token) {
  tokenAddress = token;
  owner = msg.sender;
  contractState = Status.PAUSED;
}

Funções privadas

Verifica inscrição

Vamos criar uma função privada chamada hasSubscribed que vai verificar se o endereço que está tentando acessar o contrato já está inscrito, para isso irá receber um endereço como parâmetro e irá retornar um bool.

function hasSubscribed(address subscriber) private view returns(bool) {

}

Dentro da função vamos verificar se o endereço que está tentando acessar o contrato já está inscrito, se estiver inscrito vamos retornar uma mensagem de erro, se não estiver inscrito vamos retornar true.

function hasSubscribed(address subscriber) private view returns(bool) {
  require(subscribersMapping[subscriber] != true, "You already registered");

  return true;
}

Funções públicas

Inscrever-se

Vamos criar uma função pública chamada subscribe, só podemos chamar subscribe caso o contrato esteja ativo, por isso vamos utilizar nosso modifier isActived e essa função irá retornar um bool.

function subscribe() public isActived returns(bool) {

}

Dentro da função subscribe vamos chamar a função hasSubscribed para verificar se o endereço que está tentando acessar o contrato já está inscrito, se não estiver inscrito vamos inscrever esse endereço no array de endereços subscribers e vamos adicionar o endereço como chave no mapping subscribersMapping e true como valor.

function subscribe() public isActived returns(bool) {
  hasSubscribed(msg.sender);
  subscribers.push(msg.sender);
  subscribersMapping[msg.sender] = true;
  return true;
}

Verificando status do contrato

Vamos criar uma função pública chamada state que vai retornar o status do contrato.

function state() public view returns(Status) {
  return contractState;
}

Mudando o status do contrato

Vamos criar uma função pública chamada changeState que irá receber um número como parâmetro, esse número pode ser 0-PAUSED e 1-ACTIVE, só podemos definir status cancelado quando o contrato estiver "morto", essa função só pode ser chamado pelo dono do contrato.

function changeState(uint8 status) public isOwner {

}

Agora vamos realizar uma validação para verificar se o status que está tentando definir é válido, se for válido verificamos se o contrato já não está com o status que estamos tentando definir se não estiver mudamos o status do contrato.

function changeState(uint8 status) public isOwner {
  require(status <= 1, "Invalid status");

  if(status == 0) {
    require(contractState != Status.PAUSED, "The status is already PAUSED");
    contractState = Status.PAUSED;
  }else {
    require(contractState != Status.ACTIVE, "The status is already ACTIVE");
    contractState = Status.ACTIVE;
  }
}

Executando o airdrop

Vamos criar uma função pública chamada execute que irá retornar um bool que só vai poder ser chamada quando o contrato estiver ativo e só o dono do contrato pode executar a função.

function execute() public isOwner isActived returns(bool) {

}

Dentro da função vamos criar uma variável chamada balance que irá receber o saldo de tokens do contrato de airdrop no contrato CryptoToken.

function execute() public isOwner isActived returns(bool) {
  uint256 balance = CryptoToken(tokenAddress).balanceOf(address(this));
}

A lógica que vamos utilizar para distribuir nossos tokens é pegar o total de tokens e dividir pelo total de endereços que se inscreveram no nosso contrato de airdrop .
Então vamos criar uma variável chamada amountToTransfer que irá receber a quantidade total de tokens e dividir pela quantidade total de endereços inscritos no contrato de airdrop.

function execute() public isOwner isActived returns(bool) {
  uint256 balance = CryptoToken(tokenAddress).balanceOf(address(this));
  uint256 amountToTransfer = balance / subscribers.length;
}

Para realizarmos o pagamento para todas as pessoas inscritas, vamos criar um looping para percorrer todos os endereços inscritos no contrato de airdrop, vamos verificar se o endereço cadastrado é um endereço válido e depois vamos utilizar o CryptoToken passando o endereço do contrato de token e realizar uma transferência passando o endereço da pessoa e a quantidade de tokens que vamos transferir e no final vamos retornar true.

function execute() public isOwner isActived returns(bool) {
  uint256 balance = CryptoToken(tokenAddress).balanceOf(address(this));
  uint256 amountToTransfer = balance / subscribers.length;
  for (uint i = 0; i < subscribers.length; i++) {
    require(subscribers[i] != address(0));
    require(CryptoToken(tokenAddress).transfer(subscribers[i], amountToTransfer));
  }

  return true;
}

Matando o contrato

Como as coisas que são escritas na blockchain não podem ser alteradas após realizarmos o deploy para ela, o solidity criou uma forma de conseguirmos "matar" nosso contrato ele irá continuar na blockchain, mas não será mais possível executar nenhuma função deste contrato.
Para isso, vamos criar uma função pública chamada kill que só o dono do contrato poderá executar essa função.

function kill() public isOwner {

}

Dentro desta função vamos definir que o status do contrato será cancelado e depois vamos chamar uma função chamada selfdestruct para matar o contrato passando o endereço do dono do contrato, com isso antes de matar o contrato vamos enviar todos os Ethers para o endereço do dono do contrato caso tiver algum.

function kill() public isOwner {
  contractState = Status.CANCELLED;
  selfdestruct(payable(owner));
}

Caso queira entender um pouco mais sobre selfdestruct clique aqui

Como ficou nosso código

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

import "./03-token.sol";

contract Airdrop  {
  // Enum
  enum Status { PAUSED, ACTIVE, CANCELLED } // mesmo que uint8

  // Properties
  address private owner;
  address[] private subscribers;
  address public tokenAddress;

  Status contractState;
  mapping(address => bool) subscribersMapping;

  // Modifiers
  modifier isOwner() {
    require(msg.sender == owner , "Sender is not owner!");
    _;
  }

  modifier isActived() {
    require(contractState == Status.ACTIVE, "The contract is not active!");
    _;
  }

  // Constructor
  constructor(address token) {
    owner = msg.sender;
    tokenAddress = token;
    contractState = Status.PAUSED;
  }


  // Public Functions
  function subscribe() public isActived returns(bool) {
    hasSubscribed(msg.sender);
    subscribers.push(msg.sender);
    subscribersMapping[msg.sender] = true;
    return true;
  }

  function execute() public isOwner isActived returns(bool) {
    uint256 balance = CryptoToken(tokenAddress).balanceOf(address(this));
    uint256 amountToTransfer = balance / subscribers.length;
    for (uint i = 0; i < subscribers.length; i++) {
      require(subscribers[i] != address(0));
      require(CryptoToken(tokenAddress).transfer(subscribers[i], amountToTransfer));
    }

    return true;
  }

  function state() public view returns(Status) {
    return contractState;
  }

  function changeState(uint8 status) public isOwner {
    require(status <= 1, "Invalid status");

    if(status == 0) {
      require(contractState != Status.PAUSED, "The status is already PAUSED");
      contractState = Status.PAUSED;
    }else if(status == 1){
      require(contractState != Status.ACTIVE, "The status is already ACTIVE");
      contractState = Status.ACTIVE;
    }
  }

  // Private Functions
  function hasSubscribed(address subscriber) private view returns(bool) {
    require(subscribersMapping[subscriber] != true, "You already registered");

    return true;
  }

  function kill() public isOwner {
    contractState = Status.CANCELLED;
    selfdestruct(payable(owner));
  }
}

Deploy

Caso você não tenha visto o post anterior clique aqui onde eu explico com mais detalhes o que é fazer um deploy e como configurar o hardhat para subir nosso contrato para blockchain.
Na pasta script vamos criar um arquivo chamado deploy-airdrop.js onde vamos escrever nossos códigos para deployar o contrato.

No arquivo deploy-airdrop.js vamos importar os arquivos do hardhat e criar nossa função assíncrona main e capturar o retorno dos erros caso tenha algum.

const hre = require("hardhat");

async function main() {

}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Dentro da função main vamos nos conectar ao contrato CryptoToken, realizar o deploy deste contrato criando mil tokens e escrever no console o endereço do contrato de token.

const hre = require("hardhat");

async function main() {
  const CryptoToken = await hre.ethers.getContractFactory("CryptoToken");
  const cryptoToken = await CryptoToken.deploy(1000);
  await cryptoToken.deployed();
  console.log("Endereço do CryptoToken", cryptoToken.address);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Depois disso vamos se conectar ao contrato Airdrop, realizar o deploy passando o endereço do contrato CryptoToken como parâmetro e escrever no console o endereço do contrato de airdrop.

const hre = require("hardhat");

async function main() {
  const CryptoToken = await hre.ethers.getContractFactory("CryptoToken");
  const cryptoToken = await CryptoToken.deploy(1000);
  await cryptoToken.deployed();
  console.log("Endereço do CryptoToken", cryptoToken.address);

  const Airdrop = await hre.ethers.getContractFactory("Airdrop");
  const airdrop = await Airdrop.deploy(cryptoToken.address);
  await airdrop.deployed();
  console.log("Endereço do Airdrop", airdrop.address);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Como configuramos o hardhat no post anterior, no terminal vamos executar o seguinte comando:

npx hardhat run scripts/deploy-airdrop.js --network goerli

Se tudo estiver certo esse irá retornar o endereço do nosso contrato.

Copiando os endereços e entrando no Goerli Etherscan podemos ver nossos contratos na blockchain da Goerli.
Esses são os contratos que subimos nesse post.

Conclusão

Esse foi o sexto post da série "Meu primeiro smart contract".
Se tudo deu certo, agora você tem um smart contract que é capaz de realizar um airdrop de token ERC-20 rodando na testnet Goerli.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Subindo meu primeiro smart contract para blockchain

ViniBlack — Thu, 04 Aug 2022 13:48:05 +0000

Esse é o quinto post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos entender o que é o hardhat e aprender a subir nosso contrato para uma rede de teste (testnet) utilizando o Alchemy para nos ajudar nessa parte.

Ferramentas

Nesse post vamos utilizar o VS Code para editar o código, o Node.js para instalar e executar o código, o Alchemy para nos ajudar a subir nosso contrato para uma rede de teste e a Metamask para administrarmos nossas carteiras.

Hardhat

Hardhat é um ambiente de desenvolvimento para software Ethereum. Ele consiste em diferentes componentes para editar, compilar, depurar e implantar seus contratos inteligentes e dApps, todos trabalhando juntos para criar um ambiente de desenvolvimento completo.

O Hardhat Runner é o principal componente com o qual você interage ao usar o Hardhat. É um executor de tarefas flexível e extensível que ajuda você a gerenciar e automatizar as tarefas recorrentes inerentes ao desenvolvimento de contratos inteligentes e dApps.

Caso queira saber mais sobre o Hardhat, clique aqui que é um tutorial de hardhat para iniciantes.

Instalação

No terminar do VS Code:
1 - Vamos criar o package.json com uma configuração base:

npm init -y

2 - Vamos instalar o hardhat como dependência de desenvolvimento:

npm install --save-dev hardhat

3 - Vamos criar um novo projeto:

npx hardhat

3.1 - Esse comando irá te fazer algumas perguntas para saber que tipo de projeto você deseja criar, vamos criar um projeto JavaScript:

What do you want to do?
┗ Create a JavaScript project

3.2 - Onde você deseja criar o projeto do hardhat:

Hardhat project root:
┗ Enter

3.3 - Se deseja criar o arquivo .gitignore:

Do you want to add a .gitignore?
┗ Y

3.4 - Se deseja compartilhar as informações do seu projeto com o Hardhat:

Help us improve Hardhat with anonymous crash reports & basic usage data?
┗ N

3.5 - Se deseja já instalar as dependências do projeto:

Do you want to install this sample project's dependencies with npm (@nomicfoundation/hardhat-toolbox)?
┗ Y

Após executar esses comandos o hardhat vai ter criado uma um projeto base para nós conseguirmos trabalhar.

Vamos dar uma olhada nos arquivos que o hardhat criou e entender cada um deles.

Contracts

Dentro da pasta contracts é o lugar onde criamos nossos contratos inteligentes, vamos dar uma olhada no contrato Lock.

Lock

Esse contrato que o hardhat criou como exemplo, nos permite travar uma quantia de ether por um determinado tempo dentro do nosso contrato e depois que passar o tempo definido vamos conseguir retirar essa quantidade de ether.
Vamos mudar algumas coisas para seguir o mesmo padrão que utilizamos nos posts anteriores.
Dentro do arquivo Lock.sol vamos mudar a licença do contrato para GLP-3.0.

// SPDX-License-Identifier: GPL-3.0

O contrato está importando o arquivo hardhat/console.sol que é o arquivo que contém algumas funções que nos permite utilizar o console para nos ajuda a debugar o nosso contrato, nativamente o solidity não tem suporte ao console, então importamos o arquivo hardhat/console.sol para que possamos usar o console.

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.9;

// Import this file to use console.log
import "hardhat/console.sol";

Caso queira entender um pouco mais sobre importação de outros contratos, clique aqui

Variáveis

O nosso contrato tem duas variáveis: uma para salvar o dono do contrato owner e outra para salvar o tempo que será travado a quantidade de ether unlockTime.

uint public unlockTime;
address payable public owner;

Evento

Temos um evento para enviar uma informação para o nosso front-end quando realizarmos a retirada de ether do contrato.

event Withdrawal(uint amount, uint when);

Construtor

No constructor estamos fazendo uma verificação para ver se _unlockTime é maior que o block.timestamp, se for maior que o timestamp do bloco, então salvamos o tempo que o bloco será destravado e o dono do contrato.

constructor(uint _unlockTime) payable {
  require(
    block.timestamp < _unlockTime,
    "Unlock time should be in the future"
  );

  unlockTime = _unlockTime;
  owner = payable(msg.sender);
}

Saldo do contrato

Para facilitar o nosso entendimento mais para frente vamos criar uma função chamada balanceOf que retorna o saldo do contrato.

function balanceOf() public view returns(uint){
  return address(this).balance;
}

Retirar Ethers

Antes de retirar os ethers do contrato, é feita uma verificação se o contrato está destravado e se quem chamou a função é o dono do contrato.
Se passar pelas verificações, então é feita a retirada dos Ethers do contrato.

function withdraw() public {
  // Uncomment this line to print a log in your terminal
  console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp); // {1}

  require(block.timestamp >= unlockTime, "You can't withdraw yet");
  require(msg.sender == owner, "You aren't the owner");

  emit Withdrawal(address(this).balance, block.timestamp);

  owner.transfer(address(this).balance);
}

Na linha {1} podemos descomentar essa linha para verificar o timestamp que o contrato será destravado e o timestamp atual.

Scripts

Dentro da pasta scripts é o lugar onde podemos escrever scripts para compilar nossos contratos e implementá-los em uma rede ativa ou em uma rede de teste.

Deploy

Deploy significa implantar, isso quer dizer que quando fazemos um deploy estamos subindo nosso contrato para blockchain para que outras pessoas possam ver nosso contrato e interagir com ele.
Vamos dar uma olhada no arquivo deploy.js que é o arquivo que contém todas as informações para subir nosso contrato para a blockchain.

Na variável hre estamos realizando uma importação das funções do hardhat com o require que é uma instrução node.js embutida e é mais comumente usada para incluir módulos de outros arquivos separados, resumidamente é mais ou menos igual o import que vimos mais cedo.

const hre = require("hardhat");

O hardhat criou uma função assíncrona chamada main, quando chamamos uma função assíncrona, ela retorna uma promessa que quando resolvida, retorna o valor que queremos ou um erro caso ocorra algum.

Dentro da função main estamos usando a função round da biblioteca Math do JavaScript, ela pega um número decimal e arredonda para baixo e dentro dele estamos pegando o nosso tempo atual dividindo por 1000 para conseguirmos pegar o tempo em milisegundos e salvando tudo isso dentro da variavel currentTimestampInSeconds.

const currentTimestampInSeconds = Math.round(Date.now() / 1000);

Após isso existe uma variável chamada ONE_YEAR_IN_SECS que é o tempo que o contrato será destravado em segundos. Vamos mudar essa variável para que o contrato seja destravado em um tempo menor.

const ONE_YEAR_IN_SECS = 5 * 60;

Caso queira deixar mudar o nome da variável para ficar igual a operação que está sendo atribuída a ela você pode mudar o nome dela para FIVE_MINUTES_IN_SECS.

E no final de tudo vamos somar o valor de currentTimestampInSeconds + FIVE_MINUTES_IN_SECS e atribuir esse resultado para variável unlockTime.

const currentTimestampInSeconds = Math.round(Date.now() / 1000);
const FIVE_MINUTES_IN_SECS = 5 * 60;
const unlockTime = currentTimestampInSeconds + FIVE_MINUTES_IN_SECS;

Agora vamos mudar a variável lockedAmount que agora irá passar 0.01 Ether para o contrato, precisamos mudar a quantidade de ethers que será enviada para o contrato para conseguirmos subir o contrato para blockchain.

const lockedAmount = hre.ethers.utils.parseEther("0.01");

Na variável Lock estamos se conectando ao nosso contrato e na variável lock estamos fazendo o deploy do contrato passando o tempo que o contrato ficará travado e a quantidade de Ethers que ficarão travadas.

const Lock = await hre.ethers.getContractFactory("Lock");
const lock = await Lock.deploy(unlockTime, { value: lockedAmount });

Vamos esperar o deploy do contrato e após isso vamos escrever no console o endereço do contrato que subiu para a blockchain.

await lock.deployed();

console.log("Lock with 1 ETH deployed to:", lock.address);

O hardhat criou essa função para conseguirmos usar async/await em todos os lugares do arquivo e mostrar o erro no console caso aconteça algum.

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Test

Dentro da pasta test é o lugar onde podemos escrever os testes para nossos contratos.
Nos próximos posts vamos entrar em mais detalhes sobre testes.

Artifacts

Quando um contrato inteligente é compilado com sucesso é criado um arquivo JSON para esse contrato, esse arquivo fica salvo na pasta artifacts, esse JSON tem informações importantes sobre o contrato de maneira organizada, tais como bytecode, ABI, detalhes do deploy, versão, entre outras coisas.
Conseguimos utilizar os JSONs para interagir com algumas bibliotecas e fazer a conexão entre frontend e o contrato, por exemplo.

Cache

O diretório usado pelo Hardhat para armazenar em cache seus itens internos.

Node_modules

Dentro da pasta node_modules é um diretório criado pelo npm ela serve para guardar todos os arquivos das dependências que instalamos no nosso projeto.

Arquivos

.gitignore: Arquivo que é usado para ignorar arquivos/pastas que não queremos que o git acompanhe.
hardhat.config.js: Arquivo que é usado para configurar o hardhat.
package-lock.json: Arquivo que descreve a árvore exata das dependências que foram geradas para permitir que as instalações subsequentes tenham a árvore idêntica.
package.json: Nesse arquivo armazena as informações básicas sobre as dependências do projeto.
README.md: Arquivo que é usado para documentar o projeto.

Subindo o contrato para a blockchain

Para conseguirmos subir o contrato para blockchain precisamos fazer algumas coisas antes.

Dotenv

Abra seu terminal na pasta do nosso projeto, e execute o seguinte comando.

npm install --save-dev dotenv

Com o dotenv conseguimos criar variáveis de ambiente para cada ambiente da nossa aplicação.

Crie um um arquivo chamado .env, dentro dele vamos criar algumas variáveis de ambiente, fazermos isso porque vamos ter que utilizar algumas chaves de aplicação que não pode subir para internet.

Alchemy

No site do Alchemy, após você ter criado uma conta e se logado, dentro do dashboard clique no botão "Create app"

Escreva o nome da sua aplicação, escreva uma descrição, selecione a chain "Ethereum", a network "Goerli" e clique em "Create App"

Clicando no nome do projeto vamos ser direcionado para tela da aplicação, onde podemos ter mais informações sobre o uso da aplicação

Clique em "View key" e copie a chave "HTTPS".
TOME CUIDADO PARA NÃO COMPARTILHAR ESSAS INFORMAÇÕES COM OUTRAS PESSOAS.

Dentro do arquivo .env vamos informar nossa chave "HTTPS"

STAGING_ALCHEMY_KEY="COLE AQUI SUA CHAVE HTTPS"

Metamask

Caso você não tenha instalado o Metamask, de uma olhada nesse video que ensina como instalar e configurar a MetaMask.
Com a Metamask configurada, clique na sua "foto" e entre em "settings".

Clique em "Advanced".

Desça a página até encontrar a opção "Show test networks" e ative essa opção

Após ativarmos isso vamos conseguir não só ver as redes Mainnet mas também as redes Testnet.
Agora clique em "Ethereum Mainnet" e mude para "Goerli Test Network"

Para conseguirmos subir nossos contratos para blockchain vamos precisar de dinheiro para pagar o GAS da transação, mas não precisa se preocupar, como estamos usando uma rede de teste tudo lá é de mentira até o dinheiro, para isso existe as torneiras de moeda entre nesse site Goerli faucet, copie o endereço da sua carteira.

E informe o seu endereço e clique em "Send Me ETH".

Agora precisamos pegar uma informação da nossa carteira, vamos clicar nos três pontos e clicar em "Account details".

Clique em "Export Private Key".

Informe a senha da sua carteira.

Após isso, irá carregar a chave da nossa carteira.
TOME CUIDADO COM ESSA CHAVE, NUNCA ENVIE OU COLOQUE ELA EM NENHUM LUGAR DA INTERNET, COM ESSA CHAVE QUALQUER PESSOA CONSEGUE FAZER TRANSFERÊNCIA DA SUA CARTEIRA SEM PRECISAR DA SUA SENHA.

Dentro do arquivo .env vamos informar nossa "PRIVATE_KEY"

STAGING_ALCHEMY_KEY="COLE AQUI SUA CHAVE HTTPS"
PRIVATE_KEY="COLE AQUI SUA PRIVATE KEY"

Dentro do arquivo hardhat.config.js vamos adicionar algumas informações da nossa networks utilizando as variáveis de ambiente que criamos mais cedo e importar os arquivos do dotenv.

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.9",
  networks: {
    goerli: {
      url: process.env.STAGING_ALCHEMY_KEY,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

No seu terminal na pasta do nosso projeto, vamos executar o seguinte comando:

npx hardhat run scripts/deploy.js --network goerli

Se tudo estiver certo esse comando irá realizar o deploy do nosso contrato para blockchain, e ira retornar o endereço do nosso contrato.

Copiando esse endereço e entrando no Goerli Etherscan conseguimos ver o nosso contrato na blockchain.

Clique aqui para ver o contrato que subimos para blockchain nesse post.

Conclusão

Esse foi o quinto post da série de posts "Meu primeiro smart contract".
Se tudo deu certo, agora você tem o hardhat configurado na sua máquina para fazer deploy de smart contracts para blockchain e tem o seu primeiro smart contract rodando na testnet Goerli sendo gerenciado pelo Alchemy.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Criando um token ERC-20 pt.1

ViniBlack — Wed, 27 Jul 2022 13:36:00 +0000

Esse é o quarto post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos entender o que são tokens ERC-20 e criar o nosso próprio token ERC-20.

Ferramentas

Vamos continuar usando Remix IDE para criação dos nossos contratos.dd

O que são tokens ERC-20?

É uma estrutura padrão para desenvolvimento de tokens, usada na rede Ethereum para facilitar a criação de novas criptomoedas.
Ele é um dos padrões mais utilizados no mundo dos cripto ativos e hoje existem diversos tokens criados a partir dele.

O ERC-20 possuem 6 funções obrigatórias, algumas opcionais e 2 eventos obrigatórios.

Caso queira saber mais sobre o ERC-20, clique aqui

Nesse post vamos implementar algumas dessas funções e eventos.

Como criar um token ERC-20?

Igual outras linguagens de programação o solidity possui interface, que é um conjunto de rotinas e padrões estabelecidos pelo software para a utilização das suas funcionalidades por aplicativos que não pretendem usar suas funções, mas apenas usá-la como base para criar suas funções.
Existem algumas formas de implementar uma interface no solidity, mas nesse post vamos criar nossa interface dentro do nosso arquivo.

Caso queira saber mais sobre o interfaces no solidity, clique aqui

Criando um novo arquivo

Vamos criar um novo arquivo dentro da pasta contracts chamado 03-token.sol.

Dentro do arquivo 03-token.sol, vamos declarar as licenças do nosso contrato, a versão do contrato e dar um nome ao contrato como já fizemos, mas agora vamos declarar nossa interface ERC-20, iremos criar nossa interface com o nome IERC20 é uma boa prática iniciar nossas interfaces com I para sabermos que é uma interface sempre que olharmos.

Dentro do IERC20, vamos declarar as funções obrigatórias do contrato e os eventos.


interface IERC20 {
  function totalSupply() external view returns(uint256);
  function balanceOf(address account) external view returns(uint256);
  function transfer(address to, uint256 quantity) external returns(bool);

  event Transfer(address from, address to, uint256 value);
}

Funções:
- totalSupply: Retorna o total de tokens existentes. Não precisamos passar nenhum parâmetro para essa função.
- balanceOf: Retorna o saldo de um determinado endereço. Precisamos passar um parâmetro address que é o endereço do usuário que desejamos saber o saldo.
- transfer: Realiza a transferência de tokens para um determinado endereço. Precisamos passar dois parâmetros: o endereço do usuário que desejamos transferir e o valor da transferência.
Eventos:
- Transfer: Emite um evento quando uma transferência é realizada. Precisamos passar três parâmetros: o endereço do usuário que transferiu, o endereço do usuário que recebeu e o valor da transferência.

Para utilizar uma interface em um contrato precisamos colocar is na frente do nome do contrato e o nome da interface que queremos utilizar.
Nosso contrato inicialmente vai ficar assim com a interface IERC20:

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

interface IERC20 {
  function totalSupply() external view returns(uint256);
  function balanceOf(address account) external view returns(uint256);
  function transfer(address to, uint256 quantity) external returns(bool);

  event Transfer(address from, address to, uint256 value);
}

contract CryptoToken is IERC20{

}

Caso queira saber o que são funções external no solidity, clique aqui

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Properties: Onde definimos nossas variáveis;
Constructor: Onde definimos nosso construtor;
Public Functions: Onde definimos nossas funções públicas;

Variáveis

Vamos começar dando o nome para nosso token, o símbolo dele e quantas casas decimais o token vai ter.

//Properties
string public constant name = "CryptoToken";
string public constant symbol = "CRY";
uint8 public constant decimals = 18;

Vamos definir nossas variáveis como constant, porque variáveis constantes tem seus valores atribuídos em tempo de compilação depois que são compiladas não é possível alterá-los.
Fazemos isso para que não seja possível alterar o nome, símbolo e as casas decimais do nosso token.

Vamos criar uma variável para armazenar o total de tokens existentes e um mapping que vai armazenar a quantidade de tokens para cada endereço.

uint256 public totalSupply;

mapping (address => uint256) public addressToBalance;

Construtor

Vamos agora criar o nosso construtor, que vai definir que totalsupply vai receber a quantidade total de tokens e que o endereço que fez o deploy vai receber todos esses tokens inicialmente.

//Constructor
constructor(uint256 total) {
  totalsupply = total;
  addressToBalance[msg.sender] = totalsupply;
}

Funções públicas

Total de tokens

Vamos criar uma função pública chamada totalSupply que retorna o total de tokens existentes.

//Public Functions
function totalSupply() public override view returns(uint256) {
  return totalsupply;
}

Precisamos declarar que essa função é override porque ela substitui uma classe da interface IERC20 que foi declarada no início do código.

Caso queira saber o que são funções override no solidity, clique aqui

Saldo de um endereço

Para saber o saldo de um determinado endereço, vamos criar uma função pública chamada balanceOf que retorna o saldo de um determinado endereço.
Ela espera um parâmetro que é o endereço do usuário que desejamos saber o saldo.

function balanceOf(address account) public override view returns(uint256) {
  return addressToBalance[account];
}

Transferência de tokens

Para transferir tokens, vamos criar uma função pública chamada transfer que recebe dois parâmetros: o endereço do usuário que desejamos transferir e a quantidade de tokens que desejamos transferir.

function transfer(address to, uint256 quantity) public returns(bool) {
  require(addressToBalance[msg.sender] >= quantity, "Insufficient Balance to Transfer");

  addressToBalance[msg.sender] = addressToBalance[msg.sender] - quantity;
  addressToBalance[to] = addressToBalance[to] + quantity;

  emit Transfer(msg.sender, to, quantity);
  return true;
}

Como ficou nosso código

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

interface IERC20 {
  function totalSupply() external view returns(uint256);
  function balanceOf(address account) external view returns(uint256);
  function transfer(address to, uint256 quantity) external returns(bool);

  event Transfer(address from, address to, uint256 value);
}

contract CryptoToken is IERC20 {

  //Properties
  string public constant name = "CryptoToken";
  string public constant symbol = "CRY";
  uint8 public constant decimals = 7;  //Padrão do Ether é 18
  uint256 private totalsupply;

  mapping(address => uint256) private addressToBalance;

  //Constructor
  constructor(uint256 total) {
    totalsupply = total;
    addressToBalance[msg.sender] = totalsupply;
  }

  //Public Functions
  function totalSupply() public override view returns(uint256) {
    return totalsupply;
  }

  function balanceOf(address account) public override view returns(uint256) {
    return addressToBalance[account];
  }

  function transfer(address to, uint256 quantity) public override returns(bool) {
    require(addressToBalance[msg.sender] >= quantity, "Insufficient Balance to Transfer");


    addressToBalance[msg.sender] = addressToBalance[msg.sender] - quantity;
    addressToBalance[to] = addressToBalance[to] + quantity;

    emit Transfer(msg.sender, to, quantity);
    return true;
  }
}

Mão na massa

Agora vamos compilar e realizar o deploy do nosso contrato 03-token.sol.

No menu lateral esquerdo clique em "Solidity compiler".
Clique no botão "Compile 03-token.sol".
No menu lateral esquerdo clique em "Deploy & run transactions".
Informe a quantidade inicial de tokens e clique no botão "Deploy".
Clique na seta para vermos as funções do nosso contrato.
Podemos verificar as casas decimais do nosso token, o nome do token, o símbolo e a quantidade total de tokens.
Copie o endereço da carteira que foi feito o deploy e clique em "balanceOf" para vermos a quantidade de tokens que esse endereço tem.
Troque de endereço.
Copie o endereço dessa carteira e clique em "balanceOf" para vermos a quantidade de tokens que esse endereço tem.
Volte para o endereço que fez o deploy do contrato, e informe o endereço da carteira que copiamos, a quantidade de tokens que queremos enviar e clique na função "transact".
Verifique a quantidade de tokens novamente do endereço que acabamos de fazer a transferência.

Conclusão

Esse foi o quarto post da série de posts "Meu primeiro smart contract".
Se você realizou todas as etapas acima, agora você tem um contrato de um token ERC-20 que consegue definir o nome do token, o símbolo do token, as casas decimais do token, ver a quantidade total de tokens existentes, consultar o saldo de tokens de um endereço, criar tokens e transferir tokens.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Referencias

ERC20 & EIP-20
O Que São Tokens ERC-20?
ERC-20: O que é e como funciona esse tipo de token?
Token Standards

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Criando um contrato de aposta

ViniBlack — Thu, 21 Jul 2022 23:58:00 +0000

Esse é o terceiro post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos criar um contrato de aposta, onde você vai conseguir escolher um número, apostar uma quantidade de Ether, sortear um número premiado e pagar os vencedores.

Ferramentas

Vamos continuar usando Remix IDE para criação dos nossos contratos.

Criando um novo arquivo

Vamos criar um novo arquivo dentro da pastacontracts chamado 02-bet.sol.

Dentro do arquivo 02-bet.sol, vamos declarar as licenças do nosso contrato, a versão do solidity e dar um nome para o contrato.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Bet {

}

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Structs: Onde definimos alguns tipos de dados mais complexo (nesse post vamos entender o que isso significa);
Properties: Onde definimos nossas variáveis;
Modifiers: Onde definimos nossos modificadores;
Constructor: Onde definimos nosso construtor;
Public Functions: Onde definimos nossas funções públicas;
Private Functions: Onde definimos nossas funções privadas;

Structs

Os struct são usados para representar uma estrutura de dados.
Por exemplo, para conseguirmos realizar as nossas apostas todo player precisa informar o valor apostado e o número selecionado, para isso vamos criar um struct chamado Player que vai armazenar amountBet (valor apostado) e numberSelected (número selecionado) e os dois vão ser do tipo uint256.

//Structs
struct Player{
   uint256 amountBet;
   uint256 numberSelected;
}

Caso queira entender um pouco mais sobre Structs clique aqui

Variáveis

Para fazermos o nosso sistema de apostas, vamos precisar criar algumas variáveis públicas para armazenar nossos dados.

owner: Que vai ser do tipo address;
players: Que vai ser um array do tipo address;
winners: Que vai ser um array do tipo address;
totalBet: Que vai ser do tipo uint256;
minimunBet: Que vai ser do tipo uint256;
addressToPlayer: Que vai ser um mapping que irá receber address como "chave" e Player como "valor";

// Properties
address public owner;
address[] public players;
address[] public winners;
uint256 public totalBet;
uint256 public minimunBet;

mapping(address => Player) addressToPlayer;

Modifiers

Vamos criar o modifier isOwner para utilizarmos nas funções que só o dono do contrato poderá executar.

modifier isOwner() {
    require(msg.sender == owner , "Sender is not owner!");
    _;
}

Construtor

Vamos agora criar o nosso construtor, que vai definir que o owner vai receber o msg.sender e vamos fazer uma verificação que o minimunBetValue tem que ser diferente de zero, caso minimunBetValue for igual a zero vamos retornar uma mensagem de erro.

constructor (uint256 minimunBetValue) {
    owner = msg.sender;
    if(minimunBetValue != 0) {
        minimunBet = minimunBetValue;
    }else {
        revert("Invalid value");
    }
}

Funções públicas

Realizando uma aposta

Vamos criar uma função pública chamada bet, onde vamos conseguir passar o parâmetro numberSelected que vai ser do tipo uint256.
Como essa função irá interagir com Ethers precisamos garantir que esses Ethers sejam enviados para o contrato.
Para que o solidity entenda que ela vai mexer com Ethers precisamos adicionar o modificador payable, qualquer função no Solidity com o modificador Payable garante que a função possa enviar e receber Ethers.

// Public Functions
function bet(uint256 numberSelected) public payable {

}

Caso queria entender um pouco mais sobre o modificador payable clique aqui

Dentro da função bet vamos verificar se o valor apostado é maior ou igual ao minimunBet, se for maior vamos criar duas variaveis, uma chamada valueBet do tipo uint256 que irá receber o msg.value e outra chamada playerBet do tipo address que irá receber msg.sender.

// Public Functions
function bet(uint256 numberSelected) public payable {
    require(msg.value >= minimunBet * 10**18, "The bet amount is less than the minimum allowed");
    uint256 valueBet = msg.value;
    address playerBet = msg.sender;
}

Agora vamos adicionar as informações dos nossos apostadores na nossa lista addressToPlayer.
Vamos criar uma variável chamada newPlayer, que vai ser do tipo Player e como nossas variáveis não vão gravar nada dentro delas, só vamos usar elas como local temporário para armazenar os dados até salvarmos esses dados dentro de uma variável precisamos informar que ela é um memory. Dentro da variável newPlayer, vamos definir que numberSelected vai receber numberSelected e amountBet vai receber valueBet ao final disso vamos adicionar o nosso newPlayer dentro do mapping addressToPlayer com a "chave" playerBet.

// Public Functions
function bet(uint256 numberSelected) public payable {
    require(msg.value >= minimunBet * 10**18, "The bet amount is less than the minimum allowed");
    uint256 valueBet = msg.value;
    address playerBet = msg.sender;

    Player memory newPlayer = Player({
        numberSelected : numberSelected,
        amountBet: valueBet
    });
    addressToPlayer[playerBet] = newPlayer;
}

Caso queira entender um pouco mais sobre memory clique aqui.

No final da função vamos somar o valor apostado com o totalBet e adicionar playerBet no nosso array players.

// Public Functions
function bet(uint256 numberSelected) public payable {
    require(msg.value >= minimunBet * 10**18, "The bet amount is less than the minimum allowed");
    uint256 valueBet = msg.value;
    address playerBet = msg.sender;

    Player memory newPlayer = Player({
        numberSelected : numberSelected,
        amountBet: valueBet
    });
    addressToPlayer[playerBet] = newPlayer;

    totalBet += valueBet;
    players.push(playerBet);
}

Gerando vencedor

Vamos criar uma função pública chamada generateWinner, apenas o dono do contrato vai conseguir utilizar essa função, por isso precisamos chamar nosso modificador isOwner, dentro da funçãogenerateWinner vamos chamar a função generateWinnerNumber.

 function generateWinner() public isOwner{
    generateWinnerNumber();
}

Funções privadas

Pagando vencedor

Vamos criar uma função privada chamada rewardWinner onde vamos conseguir passar o parametro numberPrizeGenerated que vai ser do tipo uint256.

// Private Functions
function rewardWinner(uint256 numberPrizeGenerated)  private{

}

Dentro da função rewardWinner, vamos criar uma variável chamada count que vai ser do tipo uint256 que vai receber 0 inicialmente. E vamos criar uma estrutura de repetição para verificar se algum número apostado é igual ao número sorteado, para isso criaremos uma variável chamada playerAddress do tipo address que vai receber players[i] assim vamos conseguir verificar se o número de todos os apostadores é igual o número sorteado, se for igual vamos adicionar o endereço do apostador no array winners e aumentar o count.

// Private Functions
function rewardWinner(uint256 numberPrizeGenerated)  private{
    uint256 count = 0;

    for(uint256 i = 0; i < players.length; i++){
        address playerAddress = players[i]; 

        if(addressToPlayer[playerAddress].numberSelected == numberPrizeGenerated){
            winners.push(playerAddress);
            count++;
        }
    }
}

Caso queira entender um pouco mais sobre estruturas de repetição no solidity clique aqui

Agora vamos realizar o pagamento para os vencedores, para isso vamos fazer uma validação para ver se o count é diferente de zero, se for diferente vamos criar uma variável chamada winnerEtherAmount que vai receber totalBet dividido pelo count e vamos criar uma estrutura de repetição para fazer o pagamento para todos os vencedores, então vamos criar uma variável chamada payTo que vai ser do tipo address e payable e vai receber winners[j]. Vamos fazer uma verificação para ver se o endereço do vencedor é um endereço válido, se for vamos realizar a transferência para esse endereço.

// Private Functions
function rewardWinner(uint256 numberPrizeGenerated)  private{
    uint256 count = 0;

    for(uint256 i = 0; i < players.length; i++){
        address playerAddress = players[i]; 

        if(addressToPlayer[playerAddress].numberSelected == numberPrizeGenerated){
            winners.push(playerAddress);
            count++;
        }
    }

    if(count != 0){
        uint256 winnerEtherAmount = totalBet / count;
        for(uint256 j = 0; j < count; j++) {
            address payable payTo = payable(winners[j]);
            if(payTo != address(0)) {
                payTo.transfer(winnerEtherAmount);
            }
        }
    }
}

Caso queira entender o que significa address(0) clique aqui

Sorteado um número

Vamos criar uma função privada chamada generateWinnerNumber que vai ser responsável por sortear um número aleatório.
Precisamos ter em mente que solidity não é capaz de criar números aleatórios. Na verdade, nenhuma linguagem de programação por si só é capaz de criar números completamente aleatórios.
Mas conseguimos criar números pseudo-aleatórios que são conjuntos de valores ou elementos que são estatisticamente aleatórios, mas é derivado de um ponto de partida conhecido e normalmente é repetido várias vezes.
Então vamos criar uma variável do tipo uint256 chamada numberPrize que vai receber block.number que é o número do bloco atual + block.timestamp que é o número em segundos da data e hora que o bloco foi fechado, e vamos dividir tudo isso por 10 e pegar o resto dessa divisão e somar com + 1 .
E vamos chamar a função rewardWinner passando numberPrize como parâmetro.

function generateWinnerNumber() private {
    uint256 numberPrize = (block.number + block.timestamp) % 10 + 1;
    rewardWinner(uint256(numberPrize));
}

Como ficou nosso código

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Bet {

    //Structs
    struct Player{
        uint256 amountBet;
        uint256 numberSelected;
    }

    // Properties
    address public owner;
    address[] public players;
    uint256 public totalBet;
    uint256 public minimunBet;
    address[] public winners;

    mapping(address => Player) addressToPlayer;
    mapping(address => uint256) private addressToBalance;


    // Modifiers
    modifier isOwner() {
        require(msg.sender == owner , "Sender is not owner!");
        _;
    }

    // Constructor
    constructor (uint256 minimunBetValue) {
        owner = msg.sender;
        if(minimunBetValue != 0) {
            minimunBet = minimunBetValue;
        }else {
            revert("Invalid value");
        }
    }

    // Public Functions
    function bet(uint256 numberSelected) public payable {
        require(msg.value >= minimunBet * 10**18, "The bet amount is less than the minimum allowed");
        uint256 valueBet = msg.value;
        address playerBet = msg.sender;

        Player memory newPlayer = Player({
            numberSelected : numberSelected,
            amountBet: valueBet
        });
        addressToPlayer[playerBet] = newPlayer;

        totalBet += valueBet;
        players.push(playerBet);
    }

    // Private Functions
    function rewardWinner(uint256 numberPrizeGenerated) private{
        uint256 count = 0;

        for(uint256 i = 0; i < players.length; i++){
            address playerAddress = players[i]; 

            if(addressToPlayer[playerAddress].numberSelected == numberPrizeGenerated){
                winners.push(playerAddress);
                count++;
            }
        }

        if(count != 0){
             uint256  winnerEtherAmount = totalBet/count;
            for(uint256 j = 0; j < count; j++) {
                address payable payTo = payable(winners[j]); // verificar se precisa dos dois payable
                if(payTo != address(0)) {
                    payTo.transfer(winnerEtherAmount);
                }
            }
        }
    }

    function generateWinnerNumber() private {
        uint256 numberPrize = (block.number + block.timestamp) % 10 + 1;
        rewardWinner(uint256(numberPrize));
    }

    function generateWinner() public isOwner{
        generateWinnerNumber();
    }
}

Mão na massa

Agora vamos compilar e realizar o deploy do nosso contrato 02-bet.sol.

No menu lateral esquerdo clique em "Solidity compiler".
Clique no botão "Compile 02-bet.sol".
No menu lateral esquerdo clique em "Deploy & run transactions".
Informe o valor mínimo da aposta e clique no botão "Deploy".
Clique na seta para vermos as funções do nosso contrato.
Mude de "Wei" para "Ether".
Informe uma quantidade de Ether menor que o valor mínimo da aposta, informe um número para apostar e clique em "bet".
Como fizemos uma aposta com o valor menor que a aposta mínima vai acontecer um erro no console.
Agora aposte um valor maior que o valor de aposta mínima, informe um número para apostar e clique em "bet".
Troque de carteira.
Realize uma aposta com outra carteira.
Antes de realizarmos o sorteio do número premiado vamos olhar o saldo das nossas carteiras.
Com a carteira de quem fez o deploy do contrato clique no botão "generateWinner"
Depois de gerar o número premiado vamos olhar o saldo das nossas carteiras.

Conclusão

Esse foi o terceiro post da série de posts "Meu primeiro smart contract".
Se você realizou todas as etapas acima, agora você tem um smart contract de aposta, onde você consegue definir o valor mínimo de Ethers para apostar, escolher um número para apostar, apostar uma quantidade de Ether e gerar o número premiado.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Aprendendo um pouco mais sobre smart contract

ViniBlack — Wed, 13 Jul 2022 02:43:00 +0000

Esse é o segundo post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos criar um contrato básico de um banco, onde você vai conseguir depositar uma quantidade de "dinheiro" e mudar o dono do contrato.

Ferramentas

Vamos continuar usando Remix IDE para criação dos nossos contratos.

Criando um novo arquivo

Vamos criar um novo arquivo dentro da pasta contracts chamado 01-bank.sol

Dentro do arquivo 01-bank.sol, vamos declarar as licenças do nosso contrato, a versão do solidity e dar um nome para o contrato.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Bank {

}

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Properties: Onde definimos nossas variáveis;
Modifiers: Onde definimos nossos modificadores, (nesse post vamos entender para que serve);
Events: Onde definimos nossos eventos, (nesse post vamos entender como funciona);
Constructor: Onde definimos nosso construtor;
Public Functions: Onde definimos nossas funções públicas;

Variáveis

Vamos começar criando uma a variável privada chamada owner que vai ser do tipo address, e uma variável pública chamada addressToBalance que vai ser do tipo mapping, essa variável recebe um address como chave e armazena um uint como valor.
O mapping é usado para armazenar dados na forma de pares chave-valor, a chave pode ser qualquer um dos tipos de dados do solidity. mapping parece muito com um objeto, onde você pode criar uma chave e definir um valor para ele.

    //Properties
    address private owner;
    mapping(address => uint) public addressToBalance;

Caso queira entender um pouco mais sobre os tipos de dados que exite no solidity clique aqui

Modificadores

O modifier é usado para modificar o comportamento de uma função.
Por exemplo, vamos criar um modifier chamado isOwner que dentro dele vai ter um require, que basicamente vai exigir que o msg.sender (já vamos ver o que é isso) seja igual o endereço do dono do contrato (owner).

    //Modifiers
    modifier isOwner() {
        require(msg.sender == owner , "Sender is not owner!");
        _;
    }

Na linha {1} se a instrução require retornar um true então será executado o código _; que significa: execute o que vem depois.
Isso quer dizer que se o código quebrar no require não irá executar a instrução, logo, não irá executar o código da função que vem depois.

Eventos

Agora vamos criar os eventos BalanceIncreased passando como
parâmetros target que vai ser do tipo address e balance que vai ser do tipo uint256, que vai ser chamado quando depositamos uma quantidade de "dinheiro" para um endereço.
E no OwnerChanged vamos passar como parâmetros oldOwner que vai ser do tipo address e newOwner que também vai ser do tipo address, que vai ser chamado quando mudarmos o dono do nosso contrato.
Quando um event é emitido ele armazena os argumentos passados e realiza uma ação.
Um evento gerado não é acessível dentro dos contratos, nem mesmo aqueles que os criou ou chamou. Os eventos no solidity servem para enviarmos alguma resposta para o nosso front-end, por exemplo depois que acontecer alguma ação no contrato.

  //Events
    event BalanceIncreased(address target, uint256 balance);
    event OwnerChanged(address oldOwner, address newOwner);

Construtor

Vamos agora criar o nosso constructor, que vai definir que o owner vai receber o msg.sender, resumidamente o msg.sender é sempre o endereço de quem chamou a função. Nesse caso estamos definindo que quem fez o deploy do contrato vai ser o owner do contrato.

Caso queira entender um pouco mais sobre msg.sender clique aqui

   //Constructor
    constructor() {
        owner = msg.sender;
    }

Funções

Adicionar saldo à um endereço

Vamos criar uma função pública chamada addBalance que vai nos permitir adicionar uma quantia de "dinheiro" há uma conta. Para conseguirmos fazer isso addBalance irá ter alguns parâmetros como to que vai ser do tipo address e value que vai ser do tipo uint.

  //Public functions
    function addBalance(address to, uint value) public {

    }

E por questão de segurança queremos que somente o dono (owner) do contrato possa adicionar "dinheiro" há um endereço. Para isso vamos colocar na frente da nossa função o nosso modificador isOwner, assim antes de executar nossa função ele vai executar o nosso modificador isOwner e verificar se quem está chamando a função é o owner, se não for vai retornar uma mensagem de erro.

  //Public functions
     function addBalance(address to, uint value) public isOwner {

    }

Dentro da nossa função addBalance vamos escrever a lógica para adicionar uma quantidade de "dinheiro" há uma conta.
Usando o nosso mapping addressToBalance vamos pegar a quantidade de "dinheiro" do endereço do parâmetro to e adicionamos uma quantidade de "dinheiro" que vamos passar no parâmetro value, depois vamos chamar o evento BalanceIncreased passando como parâmetros o endereço (to) e a quantidade (value) de "dinheiro" que queremos enviar.

//Public functions
    function addBalance(address to, uint value) public isOwner {
        addressToBalance[address(to)] = addressToBalance[address(to)] + value;
        emit BalanceIncreased(to, value);
    }

Alterando dono do contrato

As regras da nossa função para trocar o dono do contrato é bem parecida com a da função addBalance.
Vamos criar uma função pública chamada changeOwner que somente o dono do contrato (owner) vai conseguir chamar essa função, que seja possível passar um endereço (newOwnerContract) como parâmetro.

    function changeOwner(address newOwnerContract) public isOwner{

    }

Dentro da nossa função changeOwner vamos redefinir o valor da variável owner para o endereço do novo dono (newOwnerContract), e chamar nosso evento OwnerChanged passando o endereço do atual dono (owner) do contrato e o endereço do novo dono (newOwnerContract) como parâmetros.

    function changeOwner(address newOwnerContract) public isOwner{
        owner = newOwnerContract;
        emit OwnerChanged(owner, newOwnerContract);
    }

Como ficou nosso código

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Bank {

    //Properties
    address private owner;
    mapping(address => uint) public addressToBalance;

    //Modifiers
    modifier isOwner() {
        require(msg.sender == owner , "Sender is not owner!");
        _;
    }

    //Events
    event BalanceIncreased(address target, uint256 balance);
    event OwnerChanged(address oldOwner, address newOwner);

    //Constructor
    constructor() {
        owner = msg.sender;
    }

    //Public functions
    function addBalance(address to, uint value) public isOwner {
        addressToBalance[address(to)] = addressToBalance[address(to)] + value;
        emit BalanceIncreased(to, value);
    }

    function changeOwner(address newOwnerContract) public isOwner{
        owner = newOwnerContract;
        emit OwnerChanged(owner, newOwnerContract);
    }
}

Mão na massa

Agora vamos compilar e realizar o deploy do nosso contrato 01-bank.sol.

No menu lateral esquerdo clique em "Solidity compiler".
Clique no botão "Compile 01-bank.sol".
No menu lateral esquerdo clique em "Deploy & run transactions".
Clique no botão "Deploy".
Clique na seta para vermos as funções do nosso contrato.
Copie o endereço da carteira que fizemos o deploy.
Clique em "addressToBalance" para verificar o salto do endereço que passamos.
Podemos ver que o saldo do nosso endereço está zerado.
Clique na seta para vermos todos os campos da função.
Copie o endereço da nossa carteira novamente.
Informe o endereço da nossa carteira no primeiro campo e informe a quantidade de "dinheiro" que quer depositar.
Clique em "addressToBalance" para verificar o salto do endereço após o depósito do "dinheiro".
Podemos ver que o saldo do nosso endereço tem a mesma quantidade de "dinheiro" que passamos na função addBalance.
Agora vamos pegar o endereço de outra carteira, para isso só clica em cima do endereço que irá aparecer uma lista de endereços.
Copie o endereço dessa nova carteira.
Agora vamos voltar para o endereço da primeira carteira, e informe o endereço da carteira que acabamos de copiar e clique na função "changeOwner".
Se tudo estiver certo quando clicarmos para executar novamente a função "changeOwner" vai dar um erro no console.

Conclusão

Esse foi o segundo post da série de posts "Meu primeiro smart contract".
Se você realizou todas as etapas acima, agora você tem um smart contract simples de um banco, onde você consegue depositar uma quantia de "dinheiro" e mudar o dono do contrato.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Meu primeiro smart contract: Criando o seu primeiro contrato inteligente

ViniBlack — Tue, 05 Jul 2022 01:31:00 +0000

Esse é o primeiro post da série Meu primeiro smart contract, que tem a intenção de ensinar ao longo de sete semanas alguns conceitos do solidity até construirmos um token baseado no ERC-20 com alguns testes unitários.

Nesse post vamos criar o nosso primeiro smart contract, onde você vai conseguir salvar um número no contrato e consultar esse número.

Ferramentas

Nesse começo vamos utilizar o Remix IDE para criarmos os nossos primeiros contratos.

Criando um novo arquivo

Quando abrimos o Remix já vão ter algumas pastas e arquivos criados.

Por enquanto, vamos ignorar esses arquivos e criar um novo arquivo dentro da pasta contracts chamado 00-storage.sol

Dentro do arquivo 00-storage.sol vamos definir as licenças do nosso contrato e sua versão.
A Partir da versão 0.6.8 do solidity precisamos definir uma licença para nossos contratos.

Você pode entender um pouco mais sobre licenças clicando aqui.

// SPDX-License-Identifier: GPL-3.0 // {1}

pragma solidity >=0.7.0 <0.9.0; // {2}

Na linha {1} vamos definir qual é a licença do nosso contrato.
Na linha {2} vamos definir em qual versão do solidity nosso contrato vai ser desenvolvido.

Para começarmos a criar o nosso contrato precisamos dar um nome para ele, para fazer isso dentro do solidity é da seguinte forma:
contract Storage {...}
Dentro das {} é onde vamos definir as regras do contrato.

Organização do código

Não existe uma forma certa de estruturar o código dos nossos contratos, mas para facilitar o entendimento vamos utilizar o seguinte padrão:

Properties: Onde vamos definir as nossas variáveis;
Constructor: Onde vamos definir nosso construtor, (nesse post vamos entender para que serve);
Public Functions: Onde vamos definir nossas funções públicas;

O solidity é uma linguagem fortemente tipada, isso quer dizer que temos que informar qual é o tipo (type) dos nossos objetos e variáveis no momento de sua declaração.

Caso queira entender um pouco mais sobre tipagem no solidity clique aqui

Variáveis

Vamos começar criando uma variável para armazenar um número inteiro dentro do nosso contrato, para criar uma uma variável no solidity precisamos passar o tipo (type) da variável, definir se ela é pública ou privada e o nome da variável.
Então vamos criar uma variável privada chamada numeroDev que vai ser do tipo (type) int.

contract Storage {
   // Properties
   int private numeroDev;
}

Por padrão as variáveis no solidity são públicas, então se você só informar o tipo (type) da variável e seu nome, ela vai ser pública.

Construtor

Vamos agora criar o nosso constructor, que basicamente é uma função especial usada para inicializar variáveis de estado em um contrato.
O construtor é chamado quando o nosso contrato é criado pela primeira vez e podemos utilizá-los para definir seus valores iniciais.
Então vamos definir que numeroDev vai ser igual a 5 inicialmente.

    // Constructor
    constructor() {
       numeroDev = 5;
    }

Funções

As funções são blocos de códigos reutilizáveis que podem ser chamadas em qualquer lugar do seu contrato. Isso elimina a necessidade de escrevermos o mesmo código repetidas vezes.
No solidity existe três tipos de funções as funções puras, as de visualização e as de modificação.

Funções puras: São funções que não lê ou modifica algum dado da blockchain. Todos os dados com os quais as funções puras estão relacionadas são passadas ou definidas no escopo da função.
Quando temos uma função pura temos que declarar isso, para fazer isso basta colocarmos pure na frente do nome da função.

Funções de visualização: São funções que servem somente para leitura e não modificam nenhum dado da blockchain.
Quando temos uma função de visualização temos que declarar isso, para fazer isso basta colocarmos view na frente do nome da função.

Funções de modificação: São funções que servem para mudar algum dado dentro da blockchain.

Igual as variáveis precisamos definir se nossas funções são públicas ou privadas. Se nossa função retornar alguma coisa precisamos informar qual é o tipo (type) desse retorno.
Para fazer isso basta colocarmos returns (type) na frente do nome da função.
Vamos criar duas funções:

get() que vai ser uma função pública do tipo view e vai retornar o valor da variável numeroDev que é do tipo inteiro.
store que vai ser uma função pública do modificação, que recebe como parâmetro um número inteiro, e dentro dele vamos fazer a soma de numeroDev + num.

    // Public Functions
    function get() public view returns (int) {
        return numeroDev;
    }

    function store(int num) public {
        numeroDev = numeroDev + num;
    }

Nosso código até agora

Se você você chegou até aqui seu contrato vai estar mais ou menos assim:

// SPDX-License-Identifier: GPL-3.0 // {1}

pragma solidity >=0.7.0 <0.9.0; // {2}

contract Storage {

    // Properties
    int private numeroDev;


    // Constructor
    constructor() {
        numeroDev = 5;
     }


    // Public Functions
    function get() public view returns (int) {
        return numeroDev;
    }

    function store(int num) public {
        numeroDev = numeroDev + num;
    }

}

Executando nosso contrato

Agora no Remix IDE vamos compilar e realizar o deploy do nosso contrato 00-storage.sol.

No menu lateral esquerdo clique em "Solidity compiler".
Clique no botão "Compile 00-storage.sol".
No menu lateral esquerdo clique em "Deploy & run transactions".
Clique no botão "Deploy".
Clique na seta para vermos as funções do nosso contrato.
Clique em "get" para executar a função.
Passe um número no input e clique em "store" para executar a função.
Clique em "get" para executar a função para conferirmos se o valor que passamos foi somado com o valor inicial.

Conclusão

Esse foi o primeiro post da série de posts "Meu primeiro smart contract".
Se você realizou todas as etapas acima, agora você tem um smart contract simples que é possível salvar um dado e consultar esse dado.

Se você gostou do conteúdo e te ajudou de alguma forma, deixe um like para ajudar o conteúdo a chegar para mais pessoas.

Link do repositório

https://github.com/viniblack/meu-primeiro-smart-contract

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Como instalar o hardhat

ViniBlack — Tue, 28 Jun 2022 23:34:00 +0000

Link do projeto no github

Neste tutorial, apresentaremos o passo a passo de como criar um smart contract usando o VS Code.
Como exemplo, criaremos o nosso próprio token.

Requisitos mínimos

VS Code >= v.1.64
Node.js >= v.12.0

Instalação

No terminar do VS Code:
1 - Vamos criar o package.json com uma configuração base

npm init -y

2 - Vamos instalar o hardhat como dependência de desenvolvimento.

npm install --save-dev hardhat

3 - Vamos fazer a configuração do hardhat no projeto

npx hardhat

Esse comando irá te fazer algumas perguntas para saber que tipo de projeto você deseja criar

What do you want to do?
┗ Create a basic sample project

Onde você deseja criar o projeto do Hardhat

Hardhat project root
┗ Enter

Se deseja criar o arquivo .gitignore

Do you want to add a .gitignore? 
┗ Y

Se deseja compartilhar as informações do seu projeto com o Hardhat

Help us improve Hardhat with anonymous crash reports & basic usage data?
┗ N

Se deseja já instalar as dependências do projeto

Do you want to install this sample project's dependencies with npm (@nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers)?
┗ Y

Após execurtamos esses comandos o hardhat vai ter criado uma um projeto base para nós conseguirmos trabalhar

Conclusão

Esse post é o primeiro post da série de posts "Criando o seu primeiro smart contract com testes unitários"

Vamos trocar uma ideia ?

Fique a vontade para me chamar para trocarmos uma ideia, aqui embaixo está meu contato.

https://www.linkedin.com/in/viniblack/

Como instalar Solidity

ViniBlack — Fri, 04 Feb 2022 16:08:16 +0000

Se você deseja só criar alguns "smart contract" para estudos não é necessário instalar o solidity em seu computador você pode usar o Remix online, com ele você não precisa instalar nada na sua máquina. Se você quiser usá-lo sem conexão com a Internet também é possível baixar o código fonte dele no seu repositório oficial do github.
O Remix é uma opção conveniente para testar compilações noturnas (nightly builds) sem precisar instalar várias versões do Solidity.

Instalar o Solidity no Linux

Os pacotes binários do Solidity estão disponíveis em solidity/releases.
Também temos PPAs para Ubuntu, você pode obter a versão estável mais recente usando os seguintes comandos:

sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install solc

A versão noturna (nightly builds) pode ser instalado usando estes comandos:

sudo add-apt-repository ppa:ethereum/ethereum
sudo add-apt-repository ppa:ethereum/ethereum-dev
sudo apt-get update
sudo apt-get install solc

Também é possível instalar via snap para todas as distribuições linux suportadas. Para instalar a versão estável mais recente do solc só usar esse comando:

sudo snap install solc --edge

Bibliografia

Documentação oficial