So schreibst und deployst du einen einfachen Stablecoin auf Linea

Stablecoins sind zu einem wichtigen Bestandteil des Blockchain- und Web3-Ökosystems geworden und helfen Nutzern dabei, die Volatilität von Kryptowährungen wie Bitcoin und Ethereum zu umgehen. In diesem Blog erfahren wir, was Stablecoins sind und wie man einen einfachen Stablecoin-Vertrag schreibt. In diesem Blog erfahren wir, was Stablecoins sind und wie man einen einfachen Stablecoin-Vertrag auf Linea schreibt und deployt.

Was sind Stablecoins?

Stablecoins sind eine Art Kryptowährung, die darauf ausgelegt ist, ihren Wert stabil zu halten. Dies wird erreicht, indem ihr Wert an etwas Stabileres gekoppelt wird – etwa an eine traditionelle Währung wie den US-Dollar, einen Rohstoff wie Gold oder sogar eine andere Kryptowährung. Das Ziel von Stablecoins ist es, die Vorteile von Kryptowährungen – wie schnelle Transaktionen und Dezentralisierung – mit der Stabilität traditioneller Finanzanlagen zu verbinden und sie so zuverlässiger und nützlicher für alltägliche Transaktionen zu machen.

Stablecoins können anhand verschiedener Faktoren klassifiziert werden, darunter ihre Kollateralstruktur, ihr Stabilitätsmechanismus und ihre relative Stabilität. Hier ist eine umfassende Übersicht der Stablecoin-Typen:

1. Fiat-besicherte Stablecoins

Fiat-besicherte Stablecoins werden durch traditionelle Währungen wie den US-Dollar oder Euro gedeckt, die in Reserven gehalten werden (z. B. Tether USDT, USD Coin USDC). Da sie direkt an Fiat-Währungen gebunden sind, sind sie stabil und einfach zu verwenden. Allerdings sind sie auf zentralisierte Einheiten für ihre Reserven angewiesen und unterliegen regulatorischer Aufsicht.

2. Krypto-besicherte Stablecoins

Krypto-besicherte Stablecoins wie DAI und LUSD werden durch andere Kryptowährungen gedeckt und sind häufig überbesichert, um die Volatilität von Kryptowährungen abzufedern. Sie sind dezentralisierter als Fiat-gedeckte Optionen. Allerdings sind sie komplex und können in Marktabschwüngen weniger stabil sein, was ein aktives Management zur Aufrechterhaltung der Stabilität erfordert.

3. Algorithmische Stablecoins

Algorithmische Stablecoins wie Ampleforth (AMPL) nutzen Algorithmen, um das Angebot anzupassen und Preise ohne direkte Besicherung zu stabilisieren. Obwohl sie hochgradig dezentralisiert und flexibel sind, sind sie schwer zu verstehen und können bei sinkendem Vertrauen anfällig für einen raschen Wertverlust („Death Spirals") sein.

Darüber hinaus gibt es weitere Typen wie hybride Stablecoins, etwa Frax (FRAX), die Besicherungs- und algorithmische Methoden kombinieren, um Stabilität zu erreichen und ein Gleichgewicht verschiedener Modelle bieten – allerdings mit zusätzlicher Komplexität. Rohstoffgedeckte Stablecoins wie Paxos Gold (PAXG) sind an physische Vermögenswerte gebunden und ermöglichen digitalen Zugang zu realen Rohstoffen. Renditetragende Stablecoins wie Compound USD (cUSDC) generieren Erträge durch Kreditvergabe oder Investitionen und bieten passives Einkommen, sind jedoch mit höheren Risiken verbunden.

Nachdem wir nun Stablecoins und die verschiedenen Typen im heutigen Ökosystem verstehen, wollen wir erkunden, wie man einen Stablecoin im Linea-Netzwerk erstellt.

Entwicklungsumgebung einrichten

Der erste Schritt besteht darin, sicherzustellen, dass deine Umgebung korrekt eingerichtet ist:

• Installiere Node.js und npm (Node Package Manager).

• Installiere Hardhat mit folgendem Befehl:

Ein neues Hardhat-Projekt erstellen

Initialisiere in deinem Projektverzeichnis ein neues Hardhat-Projekt:

Für dieses Tutorial verwenden wir TypeScript, da Hardhat bereits alle notwendigen Abhängigkeiten mitbringt. Nach der Initialisierung erhältst du eine Projektstruktur, die Folgendes umfasst:

• contracts/: Solidity-Verträge

• ignition/: Ignition-Deployment-Module

• test/: Testdateien

• hardhat.config.js: Hardhat-Konfiguration

Nun tauchen wir in das Schreiben unseres eigenen Stablecoin-Vertrags für den RadStablecoin (RAD) ein. Dies wird ein einfacher Ethereum-besicherter Stablecoin mit einer 150%igen Besicherungsquote sein.

In diesem Vertrag:

• ETH wird als Kollateral verwendet.

• Eine 150%ige Besicherungsquote gewährleistet die Stabilität.

• Nutzer können Stablecoins minten, indem sie ETH senden, und sie burnen, um ihr Kollateral zurückzuerhalten.

• Ein einfaches Price Oracle wird verwendet, um den ETH-Preis abzurufen (in einem realen Szenario würde man ein sicheres dezentrales Oracle verwenden).

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

1. Kollateral-Management:- Kollateral einzahlen:- Nutzer können Ether (ETH) als Kollateral einzahlen, indem sie depositCollateral aufrufen.

• Das eingezahlte ETH wird im collateralBalances-Mapping gespeichert, das das gesamte Kollateral der Nutzer verfolgt.

• Kollateral abheben:- Nutzer können ihr Kollateral über withdrawCollateral abheben.

1. Stablecoin-Operationen:- Stablecoins minten:- Die mintStablecoin-Funktion stellt sicher, dass der Nutzer über ausreichend Kollateral verfügt, um die gewünschte Menge an RAD-Tokens zu minten.

• Stablecoins burnen:- Die burnStablecoin-Funktion burned die angegebene Menge an RAD und gibt die entsprechende Menge ETH basierend auf der 150%igen Besicherungsquote und dem aktuellen ETH-Preis zurück.

1. Price Feeds:- Den ETH-Preis abrufen:- Der Vertrag enthält eine Funktion getCurrentPrice, die in diesem vereinfachten Beispiel einen festen Preis von 2.000 $ für ETH zurückgibt.

Hardhat für Linea konfigurieren

Aktualisiere deine hardhat.config.js, um die Linea-Testnet-Konfiguration einzuschließen. Füge die folgende Netzwerkkonfiguration hinzu:

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

Das Deployment-Skript erstellen

Erstelle im Verzeichnis ignition/modules/ eine Datei namens RadStablecoin.ts und füge das folgende Skript ein:

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

Um den Vertrag zu kompilieren, führe folgenden Befehl aus:

Bevor du den Smart Contract deployst, stelle sicher, dass du die .env-Datei im Verzeichnis mit den folgenden Werten aktualisierst:

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

Den Vertrag deployen

Deploye abschließend den RadStablecoin-Vertrag auf Linea:

Dadurch wird der Marketplace-Smart-Contract auf Linea Sepolia deployed.

Wie geht es weiter?

Stablecoins spielen eine entscheidende Rolle im Kryptowährungs-Ökosystem und bieten die dringend benötigte Stabilität für Finanzanwendungen. In diesem Tutorial haben wir die Kernkonzepte von Stablecoins, ihre verschiedenen Typen und die Art und Weise erkundet, wie sie traditionelle Finanzen mit dezentraler Technologie verbinden. Wir haben außerdem praktische Erfahrungen gesammelt, indem wir RadStablecoin im Linea-Netzwerk erstellt und deployed haben, was unser Verständnis von kollateralgedeckten Stablecoins vertieft hat – happy coding!