Tutorial de Solidity: Token de Impuesto Sencillo
En este artículo, profundizaremos en el mundo de Solidity creando un Token de Impuesto Sencillo. Este tutorial te ayudará a entender los conceptos básicos de la programación en Solidity y cómo construir sobre los contratos inteligentes. Al final de este tutorial, tendrás un entendimiento sólido de Solidity y serás capaz de aplicar tu conocimiento para crear tus propios contratos inteligentes
Así que si estás listo para iniciar tu travesía en el mundo de Solidity, ¡vamos a empezar!
Foto por The New York Public Library en Unsplash
Configurando el Entorno
Para configurar tu entorno de desarrollo, sigue la guía de primeros pasos de Hardhat. Usaremos Typescript para este proyecto.
Una vez que lo hayas configurado, puedes instalar la biblioteca @openzeppelin/contracts con el siguiente comando:
yarn add --dev @openzeppelin/contracts
Creando el contrato del Token de Impuesto
Crearemos un contrato inteligente que implemente el estándar ERC-20. Nuestro contrato incluye la función de impuesto, el cual deduce automáticamente un porcentaje del valor del token por cada transacción que sucede en la blockchain.
El impuesto se recolecta automáticamente y luego es distribuído a una dirección específica (fondo) como la caridad o un fondo de desarrollo.
Heredaremos contratos desde la biblioteca @openzeppelin/contracts para mejorar la seguridad y rapidez del proceso de desarrollo.
Sólo estaremos creando dos pruebas para este tutorial:
- Debería configurar los fondos de la dirección en el despliegue.
- Debería transferir 5% de los fondos de la dirección.
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)]
)
})
})
})
En nuestro contrato, tendremos dos cosas:
Fondo
En nuestro constructor, añadiremos un argumento para el fondo. Puedes verlo en la función de despliegue para nuestro caso de prueba que llamaremos Contract.deploy con la dirección del fondo como argumento. Luego estableceremos el fondo en el contrato.
Si miras la declaración del fondo en el contrato, verás que es immutable. Esto simplemente quiere decir que no puede cambiarse una vez inicializado.
_transfer
_transfer es una función interna. La función externa transfer la llama. Es responsable de cambiar los balances. Es en esta función _transfer que calculamos la cantidad que debería transferirse al receptor y al fondo.
En solidity, no hay cosas como decimales, así que no podemos usar porcentajes fijos, es decir, 5/100 = 0.05, este número no existe en solidity.
En nuestro caso de prueba, vamos a transferir 100 tokens. En solidity, 100 es representado por 100000000000000000000. Dado el tamaño del número, podemos dividirlo por 100 y multiplicarlo por 10.
Por último, llamamos la función super._transfer (dos veces). Esto llama a la función _transfer declarada en el contrato ERC20.sol en OpenZeppelin. La llamamos una vez para que transfiera los fondos al receptor, y una vez para que transfiera los fondos al fondo.
// 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 impuesto
super._transfer(sender, recipient, amount - tax);
super._transfer(sender, fund, tax);
}
}
¡Felicidades! Escribimos un token de impuesto simple en 25 líneas de código. No está nada mal. El código está disponible en GitHub.
Producción
Es importante tomar en cuenta que, para poder hacer que este contrato funcione correctamente en un intercambio descentralizado, necesitamos añadir una lista blanca, para no poner impuestos en ciertas transferencias que involucran el par de liquidez. Habrá más de esto en un artículo en el futuro.
Si este artículo te fue útil, ¡únete a nuestro grupo de Telegram! Es un espacio web3 para debatir ideas, construir proyectos y ayudar con el código troubleshoot.
Soy un fundador multidisciplinario, administrador de proyecto, desarrollador de solidity y react, esposo y cocinero para la familia y amigos.
¿Tienes una idea de un proyecto? Escríbeme en Twitter o únete al grupo de Telegram.
¿Nuevo con el trading? Intenta bots para el trading de cripto o copia el trading en los mejores sitios de intercambio de cripto.
Únete al Canal de Telegram y al Canal de Youtube de Coinmonks para obtener Novedades sobre el Cripto
Lee También
- Free Crypto Signals - Crypto Trading Bots
- Una guía definitiva para Leveraged Token
- 16 Best Folding Electric Bikes
- 28 Best Electric Bikes Review
- Top 3 Binance Futures Trading Bots
Este artículo es una traducción deCyrille, hecha por Gabriella Martínez. Puedes encontrar el artículo original aquí
Sería genial escucharte en nuestro Discord, puedes contarnos tus ideas, comentarios, sugerencias y dejarnos saber lo que necesitas.
Si prefieres puedes escribirnos a @web3dev_es en Twitter.
Discussion (0)