Neste artigo, vamos nos aprofundar no mundo do Solidity criando um Simple Tax Token (token de taxa simples). Este tutorial o ajudará a entender os fundamentos da programação do Solidity e como criar contratos inteligentes. Ao final deste tutorial, você terá uma sólida compreensão do Solidity e será capaz de aplicar seu conhecimento para criar seus próprios contratos inteligentes.
Portanto, se você estiver pronto para iniciar sua jornada no empolgante mundo Solidity, vamos mergulhar de cabeça!
######Foto por The New York Public Library no Unsplash
###Configuração do ambiente
Para configurar seu ambiente de desenvolvimento, siga as instruções do Guia de Introdução ao Hardhat. Usaremos o Typescript para este projeto.
Depois de configurado, você pode instalar a biblioteca
@openzeppelin/contracts com o seguinte comando.
yarn add --dev @openzeppelin/contracts
###Criação do Contrato de Token de Taxa Simples
Criaremos um contrato inteligente que implementa o padrão ERC-20. Nosso contrato inclui uma função tax, que deduz automaticamente uma porcentagem do valor do token de cada transação que ocorre na blockchain.
A taxa é coletada automaticamente e, em seguida, distribuída para um endereço (fundo) específico, como uma instituição de caridade ou um fundo de desenvolvimento.
Herdaremos contratos da biblioteca @openzeppelin/contracts para aumentar a segurança e a velocidade do processo de desenvolvimento.
Criaremos apenas dois testes para este tutorial.
- Ele deve definir o endereço do fundo na implantação.
- Ele deve transferir 5% para o endereço do fundo.
import { loadFixture } from "@nomicfoundation/hardhat-network-helpers"
import { expect } from "chai"
import { ethers } from "hardhat"
describe("SimpleVoting", function () {
async function deploy() {
const [deployer, fund, target] = await ethers.getSigners()
const Contract = await ethers.getContractFactory("SimpleTax")
const contract = await Contract.deploy(fund.address)
await contract.deployed()
return { contract, deployer, fund, target }
}
describe("deployment", function () {
it("should set the fund address", async function () {
const { contract, fund } = await loadFixture(deploy)
expect(await contract.fund()).to.eq(fund.address)
})
})
describe("transfer", function () {
it("should transfer 5% to the fund's address", async function () {
const { contract, deployer, fund, target } = await loadFixture(deploy)
const amount = ethers.utils.parseEther("100")
await expect(contract.transfer(target.address, amount)).to.changeTokenBalances(contract,
[deployer, fund, target],
[amount.mul(-1), amount.mul(5).div(100), amount.mul(95).div(100)]
)
})
})
})
Em nosso contrato, teremos que fazer duas coisas.
####fund
Em nosso construtor, adicionaremos um argumento para o fundo. Você pode ver na função deploy do nosso caso de teste que chamamos Contract.deploy com o endereço do fundo como argumento. Em seguida, definiremos o fundo no contrato.
Se você observar a declaração do fundo no contrato, verá que ele é immutable. Isso significa simplesmente que ele não pode ser alterado depois de inicializado.
####_transfer
_transfer é uma função interna que a função externa transfer chama. Ela é responsável por alterar os saldos. É nessa função _transfer que calculamos o valor que deve ser transferido para o destinatário e para o fundo.
No Solidity, não existem decimais, portanto, não podemos usar uma porcentagem fixa, ou seja, 5/100 = 0,05, pois esse número não existe no Solidity.
Em nosso caso de teste, estamos transferindo 100 tokens. Em Solidity, 100 é representado por 100000000000000000000. Dado o tamanho desse número, podemos dividi-lo por 100 e multiplicá-lo por 10.
Por último, mas não menos importante, chamamos a função super._transfer (duas vezes). Isso significa chamar a função _transfer declarada no contrato OpenZeppelin ERC20.sol. Nós a chamamos uma vez para transferir fundos para o destinatário e uma vez para transferir fundos para o fundo.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract SimpleTax is ERC20 {
address public immutable fund;
constructor(address fund_) ERC20("SimpleTax", "STX") {
_mint(msg.sender, 1000 * 10 ** decimals());
fund = fund_;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
uint tax = (amount / 100) * 5; // 5% de taxa
super._transfer(sender, recipient, amount - tax);
super._transfer(sender, fund, tax);
}
}
Parabéns! Escrevemos um token de taxa simples em 25 linhas de código. Nada mal. O código está disponível no Github.
###Produção
É importante observar que, para que esse contrato funcione corretamente em uma exchange descentralizada, precisaríamos adicionar uma lista de permissões (whitelist) para não tributar determinadas transferências que envolvam o par de liquidez. Falaremos mais sobre isso em um artigo futuro.
Se este artigo foi útil, junte-se ao nosso Telegram! É um espaço web3 para discutir ideias, criar projetos e ajudar a solucionar problemas de código.
Sou um fundador multidisciplinar, gerente de projetos, desenvolvedor de Solidity + React, marido e cozinheiro de família e amigos.
Tem uma ideia de projeto? Entre em contato comigo no Twitter ou junte-se ao Telegram.
Novo em negócios? Experimente bots de negociação de criptomoedas ou copy trading nas melhores exchanges de criptos.
Junte-se a Coinmonks no Canal do Telegram e no Canal do Youtube e obtenha diariamente notícias sobre criptomoedas
###Leia também
- Free Crypto Signals | Crypto Trading Bots
- An ultimate guide to Leveraged Token
- 16 Best Folding Electric Bikes
- 28 Best Electric Bikes Review
- Top 3 Binance Futures Trading Bots
Esse artigo foi escrito por Cyrille e traduzido por Fátima Lima. O original pode ser lido aqui.