Como Escrever e Implantar uma Stablecoin Simples na Linea

Stablecoins se tornaram uma parte fundamental do ecossistema blockchain e web3, ajudando os usuários a evitar a volatilidade de criptomoedas como Bitcoin e Ethereum. Neste blog, vamos aprender o que são stablecoins e como escrever um contrato simples de stablecoin. Neste blog, vamos aprender o que são stablecoins e como escrever e implantar um contrato simples de stablecoin na Linea.

O que são stablecoins?

Stablecoins são um tipo de criptomoeda projetada para manter seu valor estável. Elas fazem isso atrelando seu valor a algo mais estável, como uma moeda tradicional — por exemplo, o dólar americano —, uma commodity como o ouro, ou até mesmo outra criptomoeda. O objetivo das stablecoins é combinar as vantagens das criptomoedas — como transações rápidas e descentralização — com a estabilidade dos ativos financeiros tradicionais, tornando-as mais confiáveis e úteis para transações do dia a dia.

As stablecoins podem ser classificadas com base em diversos fatores, incluindo sua estrutura de colateral, mecanismo de estabilidade e estabilidade relativa. Veja a seguir uma análise abrangente dos tipos de stablecoins:

1. Stablecoins com lastro em moeda fiduciária

Moedas tradicionais lastreiam as stablecoins com lastro em moeda fiduciária, como o dólar americano ou o euro, mantidas em reservas (ex.: Tether USDT, USD Coin USDC). Por estarem diretamente vinculadas a moedas fiduciárias, são estáveis e fáceis de usar. No entanto, dependem de entidades centralizadas para as reservas e estão sujeitas à supervisão regulatória.

2. Stablecoins com lastro em criptomoedas

Stablecoins com lastro em criptomoedas, como DAI e LUSD, são respaldadas por outras criptomoedas e frequentemente são supercolateralizadas para lidar com a volatilidade do mercado cripto. São mais descentralizadas do que as opções lastreadas em moeda fiduciária. No entanto, são mais complexas e podem ser menos estáveis durante quedas de mercado, exigindo gestão ativa para manter a estabilidade.

3. Stablecoins algorítmicas

Stablecoins algorítmicas, como Ampleforth (AMPL), utilizam algoritmos para ajustar a oferta e estabilizar os preços sem colateral direto. Embora sejam altamente descentralizadas e flexíveis, são difíceis de compreender e podem ser vulneráveis a perdas rápidas de valor ("espirais de morte") caso a confiança diminua.

Existem também outros tipos, como as stablecoins híbridas — a exemplo da Frax (FRAX) —, que combinam métodos de colateral e algorítmicos para alcançar estabilidade, oferecendo um equilíbrio entre diferentes modelos, porém com maior complexidade. As stablecoins lastreadas em commodities, como Paxos Gold (PAXG), estão vinculadas a ativos físicos, proporcionando exposição digital a commodities do mundo real. As stablecoins com rendimento, como Compound USD (cUSDC), geram retornos por meio de empréstimos ou investimentos, oferecendo renda passiva, mas com riscos associados mais elevados.

Agora que entendemos as stablecoins e os tipos existentes no ecossistema atual, vamos explorar como criar uma stablecoin na rede Linea.

Configure o ambiente de desenvolvimento

O primeiro passo é garantir que seu ambiente esteja configurado corretamente:

• Instale o Node.js e o npm (gerenciador de pacotes do Node).

• Instale o Hardhat executando:

Crie um novo projeto Hardhat

No diretório do seu projeto, inicialize um novo projeto Hardhat:

Usaremos TypeScript neste tutorial, pois o Hardhat já possui todas as dependências necessárias. Após a inicialização, você terá uma estrutura de projeto que inclui:

• contracts/: Contratos Solidity

• ignition/: Módulos de implantação do Ignition

• test/: Arquivos de teste

• hardhat.config.js: Configuração do Hardhat

Agora, vamos mergulhar na criação do nosso próprio contrato de stablecoin para a RadStablecoin (RAD). Será uma stablecoin simples com lastro em Ethereum e uma taxa de colateralização de 150%.

Neste contrato:

• ETH será usado como colateral.

• Uma taxa de colateralização de 150% garantirá a estabilidade.

• Os usuários poderão cunhar stablecoins enviando ETH e queimá-las para recuperar seu colateral.

• Um oráculo de preços simples será usado para buscar o preço do ETH (em um cenário real, você usaria um 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. Gestão de Colateral:- Depósito de Colateral:- Os usuários podem depositar Ether (ETH) como colateral chamando depositCollateral.

• O ETH depositado é armazenado no mapeamento collateralBalances, rastreando o colateral total dos usuários.

• Retirada de Colateral:- Os usuários podem retirar seu colateral usando withdrawCollateral.

1. Operações com Stablecoin:- Cunhagem de Stablecoins:- A função mintStablecoin garante que o usuário tenha colateral suficiente para cunhar a quantidade solicitada de tokens RAD.

• Queima de Stablecoins:- A função burnStablecoin queima a quantidade especificada de RAD e devolve a quantidade equivalente de ETH com base na taxa de colateralização de 150% e no preço atual do ETH.

1. Feeds de Preço:- Obtendo o Preço do ETH:- O contrato inclui uma função getCurrentPrice que retorna um preço fixo de $2000 para o ETH neste exemplo simplificado.

Configure o Hardhat para a Linea

Atualize seu hardhat.config.js para incluir a configuração da testnet da Linea. Adicione a seguinte configuração de rede:

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

Crie o script de implantação

No diretório ignition/modules/, crie um arquivo chamado RadStablecoin.ts e inclua o seguinte 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 o contrato, execute o seguinte comando:

Antes de implantar o smart contract, certifique-se de atualizar o arquivo .env no diretório com os seguintes 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

Implante o contrato

Por fim, implante o contrato RadStablecoin na Linea:

Isso implantará o smart contract do marketplace na Linea Sepolia.

O que vem a seguir?

As stablecoins desempenham um papel crucial no ecossistema de criptomoedas, oferecendo a estabilidade tão necessária para aplicações financeiras. Neste tutorial, exploramos os conceitos fundamentais das stablecoins, seus diversos tipos e como elas conectam as finanças tradicionais à tecnologia descentralizada. Também adquirimos experiência prática criando e implantando a RadStablecoin na rede Linea, aprofundando nossa compreensão sobre stablecoins com lastro em colateral — bons códigos!