Crear un grifo de criptomonedas utilizando un contrato inteligente de Solidity

En este tutorial crearemos dos contratos inteligentes de llave de moneda criptográfica. El primer contrato de faucet permite a los usuarios solicitar que se envíe ETH gratuito a una billetera. El segundo contrato de faucet crea un token ERC20 y permite a los usuarios solicitar tokens ERC20 gratuitos. Ambos grifos tienen una función de bloqueo de tiempo que evita que los usuarios realicen la misma solicitud varias veces al día. Escribiremos estos contratos en Solidity y los implementaremos en la cadena de bloques Ethereum.

¿Qué es un grifo?

Un grifo de moneda criptográfica es un sistema que distribuye tokens a los usuarios que lo solicitan. Al igual que pequeñas gotas de agua que gotean de un grifo, un grifo criptográfico gotea pequeñas cantidades de tokens a los solicitantes. Los tokens de un grifo son gratuitos o se otorgan por realizar tareas en Internet. En consecuencia, los faucets son una excelente manera de distribuir tokens a usuarios de todo el mundo.

¿Cómo funcionan los grifos de moneda criptográfica?

Un crypto faucet es un sistema en el que un usuario realiza una solicitud en un sitio web para obtener tokens gratuitos. El usuario puede realizar una tarea como hacer clic en un anuncio, ver un video o realizar una encuesta y, como recompensa, el usuario gana criptomonedas gratis. Cabe señalar que para usar un faucet, cada participante debe proporcionar la dirección de su billetera para recibir recompensas simbólicas. Los usuarios seguirán las instrucciones en el sitio web de Faucet para que el sistema transfiera tokens a su billetera.

Los sitios web y las aplicaciones móviles que ejecutan crypto faucets generalmente configuran un umbral de un número específico de tokens que se otorgarán cada día para cada usuario. Por ejemplo, un faucet podría permitir reclamar 100 tokens por día y cada billetera solo puede reclamar 1 token. Entonces, este sistema distribuiría 1 token a 100 billeteras únicas por día. Además, se podría establecer un umbral de pago mínimo antes de que el usuario pueda reclamar las recompensas recolectadas. Por ejemplo, el usuario debe reclamar 5 tokens antes de que se procese un pago.

Algunas llaves de moneda criptográfica tienen el siguiente flujo de proceso:

Cree un grifo criptográfico para dispensar ETH

Primero, creemos un contrato de grifo simple que dispensa ETH cuando un usuario realiza una solicitud. El contrato de grifería ETH a continuación contiene las siguientes características:

• El contrato tiene un propietario que se puede cambiar
• Tiene una cantidad configurable de ETH para dispensar a cada billetera solicitada
• Apoya donaciones al grifo
• Realiza un seguimiento de las direcciones que solicitan ETH
• Los solicitantes pueden solicitar ETH solo una vez al día

Para ilustrar las características anteriores, lea los comentarios en el código para comprender cómo funciona este contrato de grifería ETH.

pragma solidity ^0.8.3;

contract faucet {
	

    //state variable to keep track of owner and amount of ETHER to dispense
    address public owner;
    uint public amountAllowed = 1000000000000000000;


    // when you can requestTokens address and blocktime+1 day is saved in TimeLock
    mapping(address => uint) public lockTime;


    //constructor to set the owner
	constructor() payable {
		owner = msg.sender;
	}


    modifier onlyOwner {
        require(msg.sender == owner, "Only owner can call this function.");
        _; /* jumps to code of function using this modifier */
    }


    //function to change the owner.  Only the owner of the contract can call this function
    function setOwner(address newOwner) public onlyOwner {
        owner = newOwner;
    }


    //function to set the amount allowable to be claimed. Only the owner can call this function
    function setAmountallowed(uint newAmountAllowed) public onlyOwner {
        amountAllowed = newAmountAllowed;
    }


    //function to donate funds to the faucet contract
	function donateTofaucet() public payable {
	}


    //function to send tokens from faucet to an address
    function requestTokens(address payable _requestor) public payable {

        //perform a few checks to make sure function can execute
        require(block.timestamp > lockTime[msg.sender], "lock time has not expired. Please try again later");
        require(address(this).balance > amountAllowed, "Not enough funds in the faucet. Please donate");

        //if the balance of this contract is greater then the requested amount send funds
        _requestor.transfer(amountAllowed);        
 
        //updates locktime 1 day from now
        lockTime[msg.sender] = block.timestamp + 1 days;
    }
}

Pruébalo en Remezclar

Haga un grifo criptográfico para dispensar un token ERC20

En segundo lugar, creemos un contrato de faucet para un token ERC20. Los grifos de token ERC20 son similares en concepto al contrato anterior, pero su estructura de contrato podría ser diferente. El contrato de grifería ERC20 a continuación contiene las siguientes características:

• A diferencia del contrato anterior, el contrato siguiente crea un token ERC20
• Puede nombrar y crear un símbolo para el token
• Hereda todas las funciones del contrato Open Zepplin ERC20
• El propietario acuña tokens en el constructor.
• Realiza un seguimiento de las direcciones que solicitan el token ERC20
• Los solicitantes pueden solicitar el token ERC20 solo una vez al día

Para ilustrar las características anteriores, lea los comentarios en el código para comprender cómo funciona el proceso de un contrato de grifería ERC20. Lea la función de token de solicitud para ver en qué se diferencia del contrato anterior.

pragma solidity ^0.8.3;

//import Open Zepplins ERC-20 contract
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";

//Create a sample token that inherits Open Zepplins ERC-20 contract
contract sampleToken is ERC20 {

    uint public amountAllowed = 1000000000000000000;

    //when deploying the token give it a name and symbol and the amount of tokens specified are minted for the owner
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        _mint(msg.sender, 50000000 * (10 ** 18));
    }

    // when you can requestTokens address and blocktime+1 day is saved in TimeLock
    mapping(address => uint) public lockTime;

    //allow users to call the requestTokens function to mint tokens
    function requestTokens (address requestor , uint amount) external {
        
        //perform a few check to make sure function can execute
        require(block.timestamp > lockTime[msg.sender], "lock time has not expired. Please try again later");
        
        //mint tokens
        _mint(requestor, amount);

        //updates locktime 1 day from now
        lockTime[msg.sender] = block.timestamp + 1 days;
    }
}

Pruébalo en Remezclar

En resumen, los contratos anteriores son dos ejemplos de cómo crear una llave criptográfica para dispensar ETH o un token ERC20. Estos son contratos inteligentes de Solidity muy simples para ayudarlo a comprender los conceptos de los grifos de moneda criptográfica.

Finalmente, recuerde que este código es solo para fines de aprendizaje y entretenimiento. El código no ha sido auditado y use bajo su propio riesgo. Recuerde que los contratos inteligentes son experimentales y podrían contener errores.