Cómo escribir e implementar una stablecoin simple en Linea

Las stablecoins se han convertido en una parte clave del ecosistema blockchain y web3, ayudando a los usuarios a evitar la volatilidad de criptomonedas como Bitcoin y Ethereum. En este blog, aprenderemos qué son las stablecoins y cómo escribir un contrato de stablecoin sencillo. En este blog, aprenderemos qué son las stablecoins y cómo escribir e implementar un contrato de stablecoin sencillo en Linea.

¿Qué son las stablecoins?

Las stablecoins son un tipo de criptomoneda diseñada para mantener su valor estable. Lo logran vinculando su valor a algo más estable, como una moneda tradicional (por ejemplo, el dólar estadounidense), una materia prima como el oro, o incluso otra criptomoneda. El objetivo de las stablecoins es combinar las ventajas de las criptomonedas —como las transacciones rápidas y la descentralización— con la estabilidad de los activos financieros tradicionales, haciéndolas más confiables y útiles para las transacciones cotidianas.

Las stablecoins pueden clasificarse según varios factores, entre ellos su estructura de colateral, su mecanismo de estabilidad y su estabilidad relativa. A continuación, se presenta un desglose completo de los tipos de stablecoins:

1. Stablecoins con respaldo en moneda fiat

Las monedas tradicionales respaldan las stablecoins con colateral fiat, como el dólar estadounidense o el euro, mantenidas en reservas (p. ej., Tether USDT, USD Coin USDC). Al estar directamente vinculadas al fiat, son estables y fáciles de usar. Sin embargo, dependen de entidades centralizadas para las reservas y están sujetas a supervisión regulatoria.

2. Stablecoins con respaldo en criptomonedas

Las stablecoins con colateral en criptomonedas, como DAI y LUSD, están respaldadas por otras criptomonedas y suelen estar sobrecolateralizadas para gestionar la volatilidad del mercado cripto. Son más descentralizadas que las opciones respaldadas en fiat. Sin embargo, son complejas y pueden ser menos estables durante las caídas del mercado, lo que requiere una gestión activa para mantener la estabilidad.

3. Stablecoins algorítmicas

Las stablecoins algorítmicas, como Ampleforth (AMPL), se basan en algoritmos para ajustar la oferta y estabilizar los precios sin colateral directo. Aunque son altamente descentralizadas y flexibles, son difíciles de comprender y pueden ser vulnerables a una pérdida rápida de valor ("espirales de muerte") si cae la confianza.

También existen otros tipos, como las stablecoins híbridas, por ejemplo Frax (FRAX), que combinan métodos de colateral y algorítmicos para lograr estabilidad, ofreciendo un equilibrio entre distintos modelos pero con mayor complejidad. Las stablecoins respaldadas por materias primas, como Paxos Gold (PAXG), están vinculadas a activos físicos y ofrecen exposición digital a commodities del mundo real. Las stablecoins generadoras de rendimiento, como Compound USD (cUSDC), generan retornos a través de préstamos o inversiones, ofreciendo ingresos pasivos pero con mayores riesgos asociados.

Ahora que entendemos las stablecoins y los tipos que existen en el ecosistema actual, exploremos cómo crear una stablecoin en la red Linea.

Configurar el entorno de desarrollo

El primer paso es asegurarse de que tu entorno esté correctamente configurado:

• Instala Node.js y npm (gestor de paquetes de Node).

• Instala Hardhat ejecutando:

Crear un nuevo proyecto de Hardhat

En el directorio de tu proyecto, inicializa un nuevo proyecto de Hardhat:

Usaremos TypeScript para este tutorial, ya que Hardhat ya incluye todas las dependencias necesarias. Tras la inicialización, tendrás una estructura de proyecto que incluye:

• contracts/: Contratos en Solidity

• ignition/: Módulos de despliegue de Ignition

• test/: Archivos de prueba

• hardhat.config.js: Configuración de Hardhat

Ahora, adentrémonos en la escritura de nuestro propio contrato de stablecoin para la RadStablecoin (RAD). Será una stablecoin simple con colateral en Ethereum y una ratio de colateralización del 150%.

En este contrato:

• ETH se utilizará como colateral.

• Una ratio de colateralización del 150% garantizará la estabilidad.

• Los usuarios podrán mintear stablecoins enviando ETH y quemarlas para recuperar su colateral.

• Se utilizará un oráculo de precios sencillo para obtener el precio del ETH (en un escenario real, se usaría un oráculo descentralizado seguro).

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/// @title RadStablecoin
/// @notice A simple stablecoin implementation with collateral-based minting
/// @dev Inherits from ERC20 and Ownable
contract RadStablecoin is ERC20, Ownable {
    /// @notice The collateralization ratio (150%)
    uint256 public constant COLLATERAL_RATIO = 150;

    /// @notice The precision for price calculations (2 decimal places)
    uint256 public constant PRICE_PRECISION = 100;

    /// @notice Mapping to track collateral balances for each user
    mapping(address => uint256) public collateralBalances;

    /// @notice Initializes the RadStablecoin contract
    constructor() ERC20("RadStablecoin", "RAD") {}

    /// @notice Allows users to deposit LineaETH as collateral
    /// @dev The deposited amount is added to the user's collateral balance
    function depositCollateral() external payable {
        collateralBalances[msg.sender] += msg.value;
    }

    /// @notice Allows users to withdraw their deposited collateral
    /// @dev Implements the checks-effects-interactions pattern to prevent reentrancy
    /// @param amount The amount of collateral to withdraw (in wei)
    function withdrawCollateral(uint256 amount) external {
        require(collateralBalances[msg.sender] >= amount, "Insufficient collateral");
        collateralBalances[msg.sender] -= amount; // Update state before making external call
        payable(msg.sender).transfer(amount);     // Safely transfer LineaETH after updating state
    }

    /// @notice Mints stablecoin (RAD) based on the user's deposited collateral
    /// @dev Calculates required collateral based on current LineaETH price and mints RAD tokens
    /// @param stablecoinAmount The amount of stablecoin to mint
    function mintStablecoin(uint256 stablecoinAmount) external {
        uint256 collateralRequired = (stablecoinAmount * COLLATERAL_RATIO * PRICE_PRECISION) / (100 * getCurrentPrice());
        require(collateralBalances[msg.sender] >= collateralRequired, "Insufficient collateral");

        collateralBalances[msg.sender] -= collateralRequired;
        _mint(msg.sender, stablecoinAmount);
    }

    /// @notice Burns stablecoin (RAD) and returns the equivalent collateral to the user
    /// @dev Calculates collateral to return based on current LineaETH price and burns RAD tokens
    /// @param stablecoinAmount The amount of stablecoin to burn
    function burnStablecoin(uint256 stablecoinAmount) external {
        require(balanceOf(msg.sender) >= stablecoinAmount, "Insufficient stablecoin balance");

        uint256 collateralToReturn = (stablecoinAmount * COLLATERAL_RATIO * PRICE_PRECISION) / (100 * getCurrentPrice());
        _burn(msg.sender, stablecoinAmount);
        collateralBalances[msg.sender] += collateralToReturn;
    }

    /// @notice Gets the current price of LineaETH in USD
    /// @dev In a real-world scenario, this would fetch the price from an oracle
    /// @return The current LineaETH price in USD (fixed at $2000 for simplicity)
    function getCurrentPrice() public view returns (uint256) {
        // In a real-world scenario, this would fetch the current LineaETH/USD price from an oracle
        // For simplicity, we'll use a fixed price of $2000 per LineaETH
        return 200000; // $2000.00
    }
}
Copiar

1. Gestión del colateral:- Depósito de colateral:- Los usuarios pueden depositar Ether (ETH) como colateral llamando a depositCollateral.

• El ETH depositado se almacena en el mapping collateralBalances, que registra el colateral total de los usuarios.

• Retiro de colateral:- Los usuarios pueden retirar su colateral usando withdrawCollateral.

1. Operaciones con stablecoins:- Minteo de stablecoins:- La función mintStablecoin verifica que el usuario tenga colateral suficiente para mintear la cantidad solicitada de tokens RAD.

• Quema de stablecoins:- La función burnStablecoin quema la cantidad especificada de RAD y devuelve la cantidad equivalente de ETH según la ratio de colateralización del 150% y el precio actual del ETH.

1. Feeds de precios:- Obtención del precio del ETH:- El contrato incluye una función getCurrentPrice que devuelve un precio fijo de $2000 para el ETH en este ejemplo simplificado.

Configurar Hardhat para Linea

Actualiza tu hardhat.config.js para incluir la configuración de la testnet de Linea. Añade la siguiente configuración de red:

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
  solidity: "0.8.24",
  networks: {
    "linea-testnet": {
      url: `https://linea-sepolia.infura.io/v3/${process.env.INFURA_API_KEY}`,
      accounts: [process.env.ACCOUNT_PRIVATE_KEY!],
    },
  },
};
export default config;
Copiar

Crear el script de despliegue

En el directorio ignition/modules/, crea un archivo llamado RadStablecoin.ts e incluye el siguiente script:

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

const RadStablecoinModule = buildModule("RadStablecoinModule", (m) => {
  // Deploy the RadStablecoin contract
  const radStablecoin = m.contract("RadStablecoin");

  // Return the deployed contract instance
  return { radStablecoin };
});

export default RadStablecoinModule;
Copiar

Para compilar el contrato, ejecuta el siguiente comando:

Antes de desplegar el smart contract, asegúrate de actualizar el archivo .env en el directorio con los siguientes valores:

# Infura API key for connecting to Ethereum networks
INFURA_API_KEY=your_infura_api_key_here

# Private key of the account to be used for deployments and transactions
ACCOUNT_PRIVATE_KEY=your_account_private_key_here
Copiar

Desplegar el contrato

Por último, despliega el contrato RadStablecoin en Linea:

Esto desplegará el smart contract del marketplace en Linea Sepolia.

¿Qué sigue?

Las stablecoins desempeñan un papel fundamental en el ecosistema de las criptomonedas, ofreciendo la estabilidad tan necesaria para las aplicaciones financieras. En este tutorial, exploramos los conceptos fundamentales de las stablecoins, sus distintos tipos y cómo conectan las finanzas tradicionales con la tecnología descentralizada. También adquirimos experiencia práctica creando y desplegando RadStablecoin en la red Linea, profundizando nuestra comprensión de las stablecoins respaldadas por colateral. ¡Feliz codificación!