Minha Primeira Experiência em Construir um Aplicativo Web3 com Solidity, React e TypeScript

// Isso nos ajudará a executar o teste escrito em Typescript
require('ts-node').register({
  files: true,
  project: './tsconfig.test.json',
})

// Obtém variáveis de ambiente do arquivo .env
require('dotenv').config()

const HDWalletProvider = require('@truffle/hdwallet-provider')

const { MNEMONIC, NEXT_PUBLIC_PROJECT_URL } = process.env

module.exports = {
  /**
   * As redes definem como você se conecta ao seu cliente Ethereum e permitem que você defina as configurações
   * padrões que a Web3 usa para enviar transações. Se você não especificar uma, o Truffle
   * iniciará uma instância gerenciada do Ganache para você na porta 9545 quando você
   * executar `develop` ou `test`. Você pode solicitar a um comando Truffle que use uma rede
   * específica na linha de comando, por exemplo
   *
   * $ truffle test --network <network-name>
   */
  networks: {
    // Útil para testes. O nome `development` é especial - o Truffle o utiliza por padrão
    // se ele for definido aqui e nenhuma outra rede for especificada na linha de comando.
    // Você deve executar um cliente (como Ganache, Geth ou Parity) em uma aba separada do terminal
    // se estiver usando esta rede e também deve definir as opções `host`, `port` e `network_id`
    // abaixo com algum valor.
    //
    development: {
      host: '127.0.0.1', // Localhost (padrão: nenhum)
      port: 7545, // Porta padrão da Ethereum (padrão: nenhuma)
      network_id: '*', // Qualquer rede (padrão: nenhuma)
    },

    // Útil para implantar em uma rede pública.
    // Observação: É importante encapsular o provedor como uma função para garantir que o Truffle utilize um novo provedor toda vez.
    goerli: {
      provider: () => new HDWalletProvider(MNEMONIC, NEXT_PUBLIC_PROJECT_URL),
      network_id: 5, // ID do Goerli
      confirmations: 2, // número de confirmações a serem aguardadas entre as implantações. (padrão: 0)
      timeoutBlocks: 200, // número de blocos antes do tempo limite de uma implantação (mínimo/padrão: 50)
      skipDryRun: true, // Pular a execução seca antes das migrações? (padrão: falso para redes públicas)
    },
  },

  // Defina as opções padrão do Mocha aqui, use relatórios especiais, etc.
  mocha: {
    // timeout: 100000
  },

  // Configure seus compiladores
  compilers: {
    solc: {
      version: '0.8.17', // Obtenha a versão exata do solc-bin (padrão: versão do Truffle)
      // docker: true,        // Use "0.5.1" se você o instalou localmente com o Docker (padrão: falso)
      // settings: {          // Consulte a documentação do Solidity para obter orientações sobre otimização e evmVersion
      //  optimizer: {
      //    enabled: false,
      //    runs: 200
      //  },
      //  evmVersion: "byzantium"
      // }
    },
  },
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;

import "@openzeppelin/contracts/utils/Strings.sol";

/**
 * @título Jogo de loteria
 * @autor Francisco Ramos
 * @aviso Jogo Web3 simples baseado no curso da Udemy 
 * https://www.udemy.com/course/ethereum-and-solidity-the-complete-developers-guide/
 */
contract Lottery {
  // Armazena o proprietário do contrato
  address public owner;

  // mantém o registro das pessoas que entram no jogo
  address payable[] public players;

  // Nós o usamos para emitir alguns detalhes sobre a transação pickWinner
  event WinnerPicked(
    uint index,
    uint prize,
    address winner
  );

  /**
   * @dev Armazena o endereço da pessoa que está implantando o contrato
   */
  constructor() {
    owner = msg.sender;
  }

  /**
   * @dev Aplica uma quantidade mínima de ether a ser enviada para uma função
   * @param value O valor mínimo a ser enviado
   */
  modifier minimum(uint value) {
    string memory requiredMsg = string.concat("O valor minimo necessário e", Strings.toString(value));
    require(msg.value >= value, requiredMsg);
    _;
  }

  /**
   * @dev Garante que o proprietário seja o único que pode chamar uma função
   */
  modifier restricted() {
    require(msg.sender == owner, "Somente o proprietario desse contrato pode chamar a funcao");
    _;
  }

  /**
   * @dev Será chamado pelo jogador que entrar no jogo enviando ether
   * e garante que ele/ela está enviando um mínimo de 0,01 ether
   */
  function enter() public payable minimum(.01 ether) {
    players.push(payable(msg.sender));
  }

  /**
   * @dev Gera um número pseudoaleatório
   * https://medium.com/0xcode/hashing-functions-in-solidity-using-keccak256-70779ea55bb0
   * https://docs.soliditylang.org/en/v0.8.17/abi-spec.html
   * @return o índice do jogador em nossa lista 
   */
  function random() private view returns (uint) {
    return uint(keccak256(abi.encodePacked(block.difficulty, block.timestamp, players)));
  }

  /**
   * @dev Obtém a lista de jogadores atualmente no jogo
   * @return jogadores
   */
  function getPlayers() public view returns (address payable[] memory) {
    return players;
  }

  /**
   * @dev Chamado pelo gerente, ele escolhe um vencedor
   * emitindo o evento WinnerPicked
   */
  function pickWinner() public restricted {
    // Calcule o índice (pseudo)aleatório do vencedor
    uint index = random() % players.length;

    uint prize = address(this).balance;
    address payable winner = players[index];

    // Transfere o valor total para o vencedor
    winner.transfer(prize);

    // "Esvazia a lista de jogadores."
    players = new address payable[](0);

    // Emite um evento com detalhes do resultado
    emit WinnerPicked(
        index,
        prize,
        winner
    );
  }
}

import type {
  LotteryInstance,
  LotteryContract,
} from '../types/truffle-contracts/Lottery'

const Lottery: LotteryContract = artifacts.require('Lottery')

let lotteryInstance: LotteryInstance

beforeEach(async () => {
  lotteryInstance = await Lottery.new()
})

contract('Lottery', (accounts) => {
  it('permite que uma conta entre', async () => {
    await lotteryInstance.enter({
      from: accounts[0],
      value: web3.utils.toWei('0.01', 'ether'),
    })

    const players = await lotteryInstance.getPlayers({
      from: accounts[0],
    })

    assert.equal(accounts[0], players[0])
    assert.equal(players.length, 1)
  })

  it('requer um valor mínimo', async () => {
    try {
      await lotteryInstance.enter({
        from: accounts[0],
        value: web3.utils.toWei('0.0099', 'ether'),
      })

      assert.fail('Deveria ter levantado a excecao "valor minimo necessario"')
    } catch (e) {
      assert.ok(e, 'A excecao "valor minimo exigido" foi levantada)
    }
  })

  it('permite a entrada de várias contas', async () => {
    await lotteryInstance.enter({
      from: accounts[0],
      value: web3.utils.toWei('0.02', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[1],
      value: web3.utils.toWei('0.03', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[2],
      value: web3.utils.toWei('0.04', 'ether'),
    })

    const players = await lotteryInstance.getPlayers({
      from: accounts[0],
    })

    assert.equal(accounts[0], players[0])
    assert.equal(accounts[1], players[1])
    assert.equal(accounts[2], players[2])

    assert.equal(3, players.length)
  })

  it('somente o proprietário pode chamar o método pickWinner', async () => {
    await lotteryInstance.enter({
      from: accounts[0],
      value: web3.utils.toWei('0.02', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[1],
      value: web3.utils.toWei('0.02', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[2],
      value: web3.utils.toWei('0.02', 'ether'),
    })

    try {
      await lotteryInstance.pickWinner({
        from: accounts[1], // accounts[1] não é o proprietário
      })

      assert.fail('Deveria ter levantado a excecao "Nao e o proprietario"')
    } catch (err) {
      assert.ok(err, 'A excecao "Nao e o proprietario" foi levantada')
    }
  })

  it('envia dinheiro para o vencedor e redefine a matriz de jogadores', async () => {
    await lotteryInstance.enter({
      from: accounts[0],
      value: web3.utils.toWei('0.02', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[1],
      value: web3.utils.toWei('0.03', 'ether'),
    })

    await lotteryInstance.enter({
      from: accounts[2],
      value: web3.utils.toWei('0.04', 'ether'),
    })

    const tx = await lotteryInstance.pickWinner({
      from: accounts[0],
    })

    // Vamos capturar o evento 'WinnerPicked' emitido aqui, onde
    // temos os detalhes dessa transação
    const { logs } = tx
    assert.ok(Array.isArray(logs))
    assert.equal(logs.length, 1)

    const log = logs[0]
    assert.equal(log.event, 'WinnerPicked')

    const index = parseInt(log.args.index.toString(10), 10)
    const prize = parseFloat(web3.utils.fromWei(log.args.prize.toString(10))) // in ether

    assert.equal(prize, 0.09) // 0.02 + 0.03 + 0.04
    assert.equal(accounts[index], log.args.winner)

    // Certifique-se de que a lista de jogadores esteja vazia
    const players = await lotteryInstance.getPlayers()
    assert.equal(0, players.length)
  })
})

import Web3 from 'web3'
import { EventData } from 'web3-eth-contract'
import lotteryJson from './contract.json'
import emitter from '../emitter'

type Address = string
type Amount = string // valores sempre são apresentados como strings

type ContractDetails = {
  owner: Address
  players: Address[]
  balance: Amount
  isManager: boolean
  hasEntered: boolean
  participants: number
  contractBalance: Amount
}

// As configurações de rede têm mais propriedades,
// mas estamos interessados apenas no `address`
type NetworkSettings = Record<string, { address: Address }>

const projectUrl = process.env['NEXT_PUBLIC_PROJECT_URL']
const networkId = process.env['NEXT_PUBLIC_NETWORK_ID']

const networkSettings = lotteryJson.networks as NetworkSettings

const CONTRACT_ABI = lotteryJson.abi as unknown as AbiItem
const CONTRACT_ADDRESS = networkSettings[networkId ?? 5777].address as Address

export const web3 = new Web3(Web3.givenProvider ?? projectUrl)

// Cria uma interface semelhante ao contrato inteligente
export const lotteryContract = new web3.eth.Contract(
  CONTRACT_ABI,
  CONTRACT_ADDRESS,
)

// Queremos informar ao front-end quando o contrato emitir o 
// evento WinnerPicked, passando o objeto do evento, que contém 
// todos os detalhes enviados no evento.
lotteryContract.events.WinnerPicked((error: Error, event: EventData) => {
  if (error) {
    emitter.emit('error-picking-winner', error)
  } else {
    emitter.emit('winner-picked', event)
  }
})

/**
 * @returns endereço de implantação do contrato
 */
export function getContractAddress(): Address {
  return CONTRACT_ADDRESS
}

/**
 * Esta função solicitará permissão ao usuário para conectar sua carteira
 * @returns lista de contas de carteira conectadas.
 */
export async function requestAccounts(): Promise<Address[]> {
  return web3.eth.requestAccounts()
}

/**
 * @param endereço do qual queremos obter o saldo
 * @returns o valor nesse endereço
 */
export async function getBalance(address: Address): Promise<Amount> {
  const balanceWei = await web3.eth.getBalance(address)
  return web3.utils.fromWei(balanceWei)
}

/**
 * @returns o valor bloqueado no contrato
 */
export async function getContractBalance(): Promise<Amount> {
  return getBalance(CONTRACT_ADDRESS)
}

/**
 * @returns endereço do proprietário do contrato
 */
export async function getContractOwner(): Promise<Address> {
  return lotteryContract.methods.owner().call()
}

/**
 * @param do endereço de entrada no jogo
 * @param quantidade de ether enviado ao pool pelo participante
 */
export async function enterLottery(
  from: Address,
  ether: Amount,
): Promise<string> {
  return lotteryContract.methods.enter().send({
    from,
    value: web3.utils.toWei(ether),
  })
}

/**
 * @param do endereço que consulta a lista de participantes
 * @returns a lista de participantes
 */
export async function getPlayers(from: Address): Promise<Address[]> {
  if (from) {
    return lotteryContract.methods.getPlayers().call({ from })
  }

  return []
}

/**
 * @param do endereço que consulta o número de participantes
 * @returns o número de participantes
 */
export async function numPlayers(from: Address): Promise<number> {
  const players = await getPlayers(from)
  return players.length
}

/**
 * Essa função só pode ser chamada pelo gerente (proprietário do contrato).
 * Ele escolherá um vencedor aleatório e enviará todo o ether que havia no pool
 * para esse jogador sortudo.
 * @param do endereço que chama essa função
 */
export async function pickWinner(from: Address): Promise<void> {
  if (from) {
    return lotteryContract.methods.pickWinner().send({ from })
  }
}

/**
 * @param endereço para consulta dos detalhes do contrato
 * @returns uma promessa com detalhes sobre o contrato
 */
export async function getContractDetails(
  address: Address,
): Promise<ContractDetails> {
  const [balance, players, owner, contractBalance] = await Promise.all([
    getBalance(address),
    getPlayers(address),
    getContractOwner(),
    getContractBalance(),
  ])

  const participants = players.length
  const hasEntered = players.includes(address)
  const isManager = owner === address

  return {
    owner,
    players,
    balance,
    isManager,
    hasEntered,
    participants,
    contractBalance,
  }
}

// ...
require('dotenv').config()
const HDWalletProvider = require('@truffle/hdwallet-provider')
const { MNEMONIC, NEXT_PUBLIC_PROJECT_URL } = process.env

module.exports = {
  // ...
  networks: {
    // ...
    goerli: {
      provider: () => new HDWalletProvider(MNEMONIC, NEXT_PUBLIC_PROJECT_URL),
      network_id: 5, // ID do Goerli
      confirmations: 2, // número de confirmações a serem aguardadas entre as implantações. (padrão: 0)
      timeoutBlocks: 200, // número de blocos antes do tempo limite de uma implantação (mínimo/padrão: 50)
      skipDryRun: true, // Pular a execução de teste antes das migrações? (padrão: falso para redes públicas)
    },
  },
  // ...
}

//...
import lotteryJson from './contract.json'

//...
const projectUrl = process.env['NEXT_PUBLIC_PROJECT_URL']
const networkId = process.env['NEXT_PUBLIC_NETWORK_ID']

const networkSettings = lotteryJson.networks as NetworkSettings

const CONTRACT_ABI = lotteryJson.abi as unknown as AbiItem
const CONTRACT_ADDRESS = networkSettings[networkId ?? 5777].address as Address

export const web3 = new Web3(Web3.givenProvider ?? projectUrl)

// Cria uma interface semelhante ao contrato inteligente
export const lotteryContract = new web3.eth.Contract(
  CONTRACT_ABI,
  CONTRACT_ADDRESS,
)
//...