Comment rédiger et déployer un Stablecoin simple sur Linea

Les stablecoins sont devenus un élément clé de l'écosystème blockchain et web3, aidant les utilisateurs à éviter la volatilité des cryptomonnaies comme Bitcoin et Ethereum. Dans ce blog, nous allons découvrir ce que sont les stablecoins et comment rédiger un contrat de stablecoin simple. Nous allons également apprendre à écrire et déployer un contrat de stablecoin simple sur Linea.

Que sont les stablecoins ?

Les stablecoins sont un type de cryptomonnaie conçu pour maintenir une valeur stable. Pour ce faire, ils ancrent leur valeur à quelque chose de plus stable, comme une devise traditionnelle (par exemple le dollar américain), une matière première comme l'or, ou même une autre cryptomonnaie. L'objectif des stablecoins est de combiner les avantages des cryptomonnaies—tels que la rapidité des transactions et la décentralisation—avec la stabilité des actifs financiers traditionnels, les rendant ainsi plus fiables et utiles pour les transactions du quotidien.

Les stablecoins peuvent être classés selon plusieurs critères, notamment leur structure de collatéral, leur mécanisme de stabilité et leur stabilité relative. Voici une présentation complète des types de stablecoins :

1. Stablecoins adossés à des monnaies fiduciaires

Les stablecoins adossés à des monnaies fiduciaires sont garantis par des devises traditionnelles comme le dollar américain ou l'euro, conservées en réserve (par ex., Tether USDT, USD Coin USDC). Directement liés aux monnaies fiduciaires, ils sont stables et faciles à utiliser. Cependant, ils dépendent d'entités centralisées pour la gestion des réserves et sont soumis à une surveillance réglementaire.

2. Stablecoins adossés à des cryptomonnaies

Les stablecoins adossés à des cryptomonnaies, comme DAI et LUSD, sont garantis par d'autres cryptomonnaies et sont souvent sur-collatéralisés pour faire face à la volatilité du marché crypto. Ils sont plus décentralisés que les options adossées à des monnaies fiduciaires. Cependant, ils sont complexes et peuvent être moins stables lors des baisses de marché, nécessitant une gestion active pour maintenir leur stabilité.

3. Stablecoins algorithmiques

Les stablecoins algorithmiques, tels qu'Ampleforth (AMPL), s'appuient sur des algorithmes pour ajuster l'offre et stabiliser les prix sans collatéral direct. Bien que très décentralisés et flexibles, ils sont difficiles à comprendre et peuvent être vulnérables à une perte rapide de valeur (« spirales mortelles ») en cas de perte de confiance.

Il en existe également d'autres, comme les stablecoins hybrides tels que Frax (FRAX), qui combinent des méthodes de collatéral et algorithmiques pour atteindre la stabilité, offrant un équilibre entre différents modèles mais avec une complexité accrue. Les stablecoins adossés à des matières premières, comme Paxos Gold (PAXG), sont liés à des actifs physiques, offrant une exposition numérique aux matières premières du monde réel. Les stablecoins générateurs de rendement, tels que Compound USD (cUSDC), génèrent des revenus via le prêt ou les investissements, offrant des revenus passifs mais avec des risques associés plus élevés.

Maintenant que nous comprenons les stablecoins et les types de stablecoins présents dans l'écosystème actuel, voyons comment créer un stablecoin sur le réseau Linea.

Configurer l'environnement de développement

La première étape consiste à s'assurer que votre environnement est correctement configuré :

• Installez Node.js et npm (le gestionnaire de paquets Node).

• Installez Hardhat en exécutant :

Créer un nouveau projet Hardhat

Dans le répertoire de votre projet, initialisez un nouveau projet Hardhat :

Nous utiliserons TypeScript pour ce tutoriel, car Hardhat dispose déjà de toutes les dépendances nécessaires. Après l'initialisation, vous aurez une structure de projet comprenant :

• contracts/ : Contrats Solidity

• ignition/ : Modules de déploiement Ignition

• test/ : Fichiers de test

• hardhat.config.js : Configuration Hardhat

Passons maintenant à la rédaction de notre propre contrat de stablecoin pour le RadStablecoin (RAD). Il s'agira d'un stablecoin simple adossé à Ethereum avec un ratio de collatéralisation de 150 %.

Dans ce contrat :

• ETH sera utilisé comme collatéral.

• Un ratio de collatéralisation de 150 % garantira la stabilité.

• Les utilisateurs pourront minter des stablecoins en envoyant de l'ETH et les brûler pour récupérer leur collatéral.

• Un oracle de prix simple sera utilisé pour récupérer le prix de l'ETH (dans un scénario réel, vous utiliseriez un oracle décentralisé sécurisé).

// 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
    }
}
Copier

1. Gestion du collatéral :- Dépôt de collatéral :- Les utilisateurs peuvent déposer de l'Ether (ETH) comme collatéral en appelant depositCollateral.

• L'ETH déposé est stocké dans le mapping collateralBalances, qui suit le collatéral total des utilisateurs.

• Retrait de collatéral :- Les utilisateurs peuvent retirer leur collatéral via withdrawCollateral.

1. Opérations sur les stablecoins :- Minting de stablecoins :- La fonction mintStablecoin vérifie que l'utilisateur dispose d'un collatéral suffisant pour minter le montant demandé de tokens RAD.

• Burning de stablecoins :- La fonction burnStablecoin brûle le montant spécifié de RAD et retourne le montant équivalent en ETH sur la base du ratio de collatéralisation de 150 % et du prix actuel de l'ETH.

1. Flux de prix :- Récupération du prix de l'ETH :- Le contrat inclut une fonction getCurrentPrice qui retourne un prix fixe de 2 000 $ pour l'ETH dans cet exemple simplifié.

Configurer Hardhat pour Linea

Mettez à jour votre hardhat.config.js pour inclure la configuration du testnet Linea. Ajoutez la configuration réseau suivante :

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;
Copier

Créer le script de déploiement

Dans le répertoire ignition/modules/, créez un fichier appelé RadStablecoin.ts et incluez le script suivant :

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;
Copier

Pour compiler le contrat, exécutez la commande suivante :

Avant de déployer le smart contract, assurez-vous de mettre à jour le fichier .env dans le répertoire avec les valeurs suivantes :

# 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
Copier

Déployer le contrat

Enfin, déployez le contrat RadStablecoin sur Linea :

Cela déploiera le smart contract de la marketplace sur Linea Sepolia.

Et maintenant ?

Les stablecoins jouent un rôle crucial dans l'écosystème des cryptomonnaies, offrant une stabilité indispensable aux applications financières. Dans ce tutoriel, nous avons exploré les concepts fondamentaux des stablecoins, leurs différents types et la façon dont ils font le lien entre la finance traditionnelle et la technologie décentralisée. Nous avons également acquis une expérience pratique en créant et déployant RadStablecoin sur le réseau Linea, approfondissant ainsi notre compréhension des stablecoins adossés à un collatéral—bon coding !