ERC20 tokens are a foundational element of decentralized finance (DeFi) and blockchain initiatives. These fungible tokens adhere to the ERC20 Smart Contract standard, ensuring seamless compatibility within the Ethereum network. Presales serve as essential fundraising mechanisms, enabling projects to distribute tokens to early supporters while securing initial capital.

This guide provides a step-by-step approach to developing a presale smart contract for an ERC20 token using Solidity, encompassing all stages from coding to deployment.

Understanding ERC20 Tokens

The ERC20 standard defines a set of rules and functions for fungible tokens, including:

Key Functions

• totalSupply: Returns the total token supply.
• balanceOf(address): Provides the balance of a specific address.
• transfer(address, uint256): Transfers tokens from one address to another.
• approve(address, uint256): Approves another address to spend tokens on the owner’s behalf.
• transferFrom(address, address, uint256): Transfers tokens on behalf of the owner.

Key Events

• Transfer: Emitted when tokens are transferred.
• Approval: Emitted when an allowance is set.

Security Considerations

• Avoid reentrancy attacks by using patterns like checks-effects-interactions.
• Implement SafeMath to prevent integer overflows/underflows.

Planning the Presale

Define Parameters

• Token Allocation: Decide how many tokens will be allocated for the presale.
• Price and Payment: Define the token price in ETH or other cryptocurrencies.
• Caps and Duration: Set a hard cap (maximum funds to be raised) and a soft cap (minimum goal for success).
• Compliance: Ensure legal requirements, such as KYC/AML, are met.

In this tutorial will give you a comprehensive guide to build a presale contract that accepts ETH and major stablecoins step by step.

User specifications

1. ERC-20 Token Implementation:
   • Includes the DeFiCentral (DEC) token with 100 billion total supply.
   • Implements ownership to allow the owner to manage the token post-presale.
2. Presale Contract Features:
   • Payment Methods: Support for ETH, USDT, USDC, and DAI.
   • Staged Token Sale: Logic for the 4 stages, each with its specific price and token allocation.
   • Softcap/Hardcap: Contributions will be tracked and compared against soft and hard caps.
   • Whitelist: Only approved addresses can participate.
   • Early Investor Bonus: Tracks contributions made before the softcap and distributes bonus tokens from unsold tokens after the presale ends.
   • Refunds: Refundable if the softcap is not reached.
3. Key Contract Features:
   • Token Claiming: Tokens will be claimable after the second public sale ends.
   • Emergency Pausing: Presale can be paused or resumed by the owner.
   • Security: Proper validations, safeguards, and audit trails for contributions and claims.
   • Owner Controls: The owner can withdraw funds, update parameters, or pause the presale in emergencies.
4. Key Functions:
   • buyWithETH: Enables purchases using ETH.
   • buyWithStableCoin: Enables purchases using USDT, USDC, or DAI.
   • Helper functions:
     • Token/ETH or Token/StableCoin conversion calculations.
   • claim: Enables token claiming post-presale.
   • withdraw: Allows the owner to withdraw collected funds.
   • refund: Allows contributors to claim refunds if the softcap is not reached.
   • set and get functions for configuration.

I will ensure the code adheres to Solidity best practices, follows the latest standards (e.g., OpenZeppelin contracts), and is fully commented using NatSpec. I’ll now proceed with implementing the ERC-20 token and the presale contract.

Key Features

• Multiple payment options(ETH, USDT, USDC, DAI)
• Early Investor bonus system
• Staged token buying campaign

Prerequisites

• Hardhat development environment
• Openzeppelin contracts
• Ethereum development experience
• Basic understanding of ERC20 tokens

Token features

• Type: ERC20
• Name: DeFiCentral
• Symbol: DEC
• Decimal: 18
• Total Supply: 100 billion

Presale Features

• Presale Supply: 10 billion (10%)
• Presale Period: 30 days
• Presale Stage: 4
• Softcap: 500000 USDT
• Hardcap: 1020000 USDT
• Price and token amounts for each stage:

Stage	Price	Token Amount
1	0.00008 USDT	3 billion
2	0.00010 USDT	4 billion
3	0.00012 USDT	2 billion
4	0.00014 USDT	1 billion

• Options for buying tokens: ETH, USDT, USDC, DAI
• Claim time: After second public sale ends
• Minimum amount for buying tokens: 100 USDT

Investors who bought tokens before softcap reached are listed on early investors and can get bonus tokens after presale ends if unsold tokens exist.

Setting Up the Development Environment

Tools Required

• Remix IDE: A browser-based Solidity compiler.
• Hardhat/Truffle: Frameworks for contract development and deployment.
• MetaMask: A browser wallet for testing transactions.
• Test Networks: Use networks like Sepolia for testing.

Development Frameworks and Tools
Remix IDE
URL: https://remix.ethereum.org
A browser-based Solidity development environment.
Hardhat
URL: https://hardhat.org
A flexible framework for developing, testing, and deploying Ethereum-based applications.
Truffle
URL: https://trufflesuite.com
A comprehensive suite for Ethereum development, including testing and migrations.

Libraries
OpenZeppelin ContractsURL: https://openzeppelin.com/contracts
A library of reusable, secure, and audited smart contracts.

Wallets and Blockchain Interfaces
MetaMask
URL: https://metamask.io
A popular Ethereum wallet for interacting with dApps and testing contracts.
Etherscan
URL: https://etherscan.io
A blockchain explorer to verify transactions and analyze smart contracts.

Testing and Security Tools
MythX
URL: https://mythx.io
A security analysis service for Ethereum smart contracts.
Slither
URL: https://github.com/crytic/slither
A static analysis tool for Solidity to detect vulnerabilities.
Ganache
URL: https://trufflesuite.com/ganache
A personal Ethereum blockchain for testing and development.

JavaScript Libraries
Web3.js
URL: https://web3js.readthedocs.io
A library for interacting with Ethereum using JavaScript.
Ethers.js
URL: https://docs.ethers.org
A library for connecting to the Ethereum blockchain.

Deployment Networks
Sepolia Testnet
URL: https://sepolia.etherscan.io
Features:A proof-of-stake testnet with a shorter sync time compared to older testnets.
Ideal for testing dApps and contracts with lower costs and faster confirmations.
Supported by popular Ethereum development tools like MetaMask, Hardhat, and Truffle.
For interacting with the Sepolia testnet:
Use the Sepolia faucet to acquire test ETH for deployments: Sepolia Faucet (or search for specific faucets as they may vary).
Add the Sepolia network to MetaMask or other wallets using the following configuration:Network Name: Sepolia
New RPC URL: https://sepolia.infura.io/v3/<your-infura-project-id> (or similar service)
Chain ID: 11155111
Currency Symbol: ETH
Block Explorer URL: https://sepolia.etherscan.io

Miscellaneous
Node.js
URL: https://nodejs.org
A JavaScript runtime for running scripts and installing frameworks like Hardhat.
Solidity Documentation
URL: https://docs.soliditylang.org
The official Solidity programming language documentation.

Installation:

Install Node.js and npm.

Install Hardhat

npm install --save-dev hardhat

Set up a project

npx hardhat

Writing the ERC20 Smart Contract

Use the OpenZeppelin library to simplify development:

Install OpenZeppelin contracts

npm install @openzeppelin/contracts

ERC-20 Token Implementation

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

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

/**
 * @title DeFiCentral Token
 * @dev ERC-20 token with ownership functionality for managing token settings.
 */
contract DeFiCentralToken is ERC20, Ownable {
    uint256 private constant _totalSupply = 100_000_000_000 * 10**18; // 100 billion tokens with 18 decimals

    constructor() ERC20("DeFiCentral", "DEC") {
        _mint(msg.sender, _totalSupply);
    }
}

Writing the Presale Contract

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title DeFiCentralTokenPresale
 * @dev Presale contract supporting multiple payment options, staged sales, and refund/claim logic.
 */
contract DeFiCentralTokenPresale is Pausable, Ownable {
    using SafeERC20 for IERC20;

    // Token and payment configuration
    IERC20 public immutable token; // The DEC token
    IERC20 public immutable usdt;
    IERC20 public immutable usdc;
    IERC20 public immutable dai;

    // Presale stages
    struct Stage {
        uint256 price;       // Price per token in USDT (scaled by 1e18)
        uint256 tokenAmount; // Tokens allocated for this stage
    }
    Stage[] public stages;

    uint256 public immutable softcap; // Minimum amount of USDT to raise
    uint256 public immutable hardcap; // Maximum amount of USDT to raise
    uint256 public totalRaised;       // Total USDT equivalent raised
    uint256 public totalSold;         // Total tokens sold
    uint256 public currentStageIndex; // Index of the current presale stage

    mapping(address => uint256) public contributions; // Tracks contributions by address
    mapping(address => bool) public whitelist;        // Whitelisted addresses
    mapping(address => uint256) public tokenClaims;   // Tracks claimable tokens for each user

    bool public isFinalized;         // Indicates whether the presale is finalized
    uint256 public constant MIN_CONTRIBUTION = 100 * 1e18; // Minimum contribution in USDT equivalent

    event TokensPurchased(address indexed buyer, uint256 amount, uint256 cost, string paymentMethod);
    event TokensClaimed(address indexed claimant, uint256 amount);
    event FundsWithdrawn(address indexed owner, uint256 amount);
    event Refunded(address indexed contributor, uint256 amount);

    constructor(
        address _token,
        address _usdt,
        address _usdc,
        address _dai,
        uint256 _softcap,
        uint256 _hardcap,
        Stage[] memory _stages
    ) {
        require(_token != address(0) && _usdt != address(0) && _usdc != address(0) && _dai != address(0), "Invalid address");
        require(_softcap > 0 && _hardcap > _softcap, "Invalid caps");

        token = IERC20(_token);
        usdt = IERC20(_usdt);
        usdc = IERC20(_usdc);
        dai = IERC20(_dai);
        softcap = _softcap;
        hardcap = _hardcap;

        for (uint256 i = 0; i < _stages.length; i++) {
            stages.push(_stages[i]);
        }
    }

    /**
     * @notice Buy tokens using ETH.
     * @dev Converts ETH to USDT equivalent for price calculation.
     */
    function buyWithETH() external payable whenNotPaused nonReentrant {
        // Conversion logic for ETH to USDT equivalent
        uint256 ethToUSDT = convertETHtoUSDT(msg.value);
        _purchaseTokens(msg.sender, ethToUSDT, "ETH");
    }

    /**
     * @notice Buy tokens using a stablecoin.
     * @param stableCoin The stablecoin used (USDT, USDC, or DAI).
     * @param amount The amount of stablecoin to contribute.
     */
    function buyWithStableCoin(IERC20 stableCoin, uint256 amount) external whenNotPaused nonReentrant {
        require(
            stableCoin == usdt || stableCoin == usdc || stableCoin == dai,
            "Unsupported stablecoin"
        );
        require(amount >= MIN_CONTRIBUTION, "Amount below minimum contribution");

        stableCoin.safeTransferFrom(msg.sender, address(this), amount);
        _purchaseTokens(msg.sender, amount, "Stablecoin");
    }

    /**
     * @notice Claim purchased tokens after the presale ends.
     */
    function claim() external {
        require(isFinalized, "Presale not finalized");
        uint256 claimableAmount = tokenClaims[msg.sender];
        require(claimableAmount > 0, "No claimable tokens");

        tokenClaims[msg.sender] = 0;
        token.safeTransfer(msg.sender, claimableAmount);

        emit TokensClaimed(msg.sender, claimableAmount);
    }

    /**
     * @notice Refund contributors if the softcap is not reached.
     */
    function refund() external {
        require(!isFinalized && totalRaised < softcap, "Refunds unavailable");
        uint256 contribution = contributions[msg.sender];
        require(contribution > 0, "No contributions to refund");

        contributions[msg.sender] = 0;
        payable(msg.sender).transfer(contribution);

        emit Refunded(msg.sender, contribution);
    }

    /**
     * @notice Withdraw raised funds by the owner.
     */
    function withdraw() external onlyOwner {
        require(isFinalized && totalRaised >= softcap, "Cannot withdraw funds");
        uint256 balance = address(this).balance;
        require(balance > 0, "No funds to withdraw");

        payable(owner()).transfer(balance);

        emit FundsWithdrawn(owner(), balance);
    }

    // Internal helper to handle token purchases
    function _purchaseTokens(
        address buyer,
        uint256 paymentAmount,
        string memory paymentMethod
    ) internal {
        require(whitelist[buyer], "Address not whitelisted");
        require(totalRaised + paymentAmount <= hardcap, "Hardcap exceeded");

        Stage storage stage = stages[currentStageIndex];
        uint256 tokensToBuy = paymentAmount / stage.price; // Calculate tokens
        require(stage.tokenAmount >= tokensToBuy, "Insufficient tokens in stage");

        contributions[buyer] += paymentAmount;
        tokenClaims[buyer] += tokensToBuy;
        totalRaised += paymentAmount;
        totalSold += tokensToBuy;

        stage.tokenAmount -= tokensToBuy;
        if (stage.tokenAmount == 0) {
            currentStageIndex++;
        }

        emit TokensPurchased(buyer, tokensToBuy, paymentAmount, paymentMethod);
    }

    // Conversion logic for ETH to USDT (stubbed for simplicity)
    function convertETHtoUSDT(uint256 ethAmount) internal view returns (uint256) {
        // Example: 1 ETH = 1800 USDT (replace with actual oracle-based price feed)
        uint256 ethPriceInUSDT = 1800 * 1e18; // Example rate
        return (ethAmount * ethPriceInUSDT) / 1e18;
    }
}

Understanding the DeFiCentral Token Presale Smart Contract

The DeFiCentral Token Presale contract is a sophisticated presale system designed for ERC-20 tokens, supporting multiple payment methods, staged token sales, and built-in safety features like refunds and whitelisting.

Below, we break down the contract’s key functions and how they work.

---

Constructor: Setting Up the Presale

The constructor initializes the contract by defining critical parameters:

constructor(
    address _token,
    address _usdt,
    address _usdc,
    address _dai,
    uint256 _softcap,
    uint256 _hardcap,
    Stage[] memory _stages
)

Key Responsibilities:

1. Set Token and Payment Addresses:
   • _token: Address of the DeFiCentral (DEC) ERC-20 token.
   • _usdt, _usdc, _dai: Addresses of the stablecoins accepted as payment.
2. Define Softcap and Hardcap:
   • _softcap: Minimum funds (in USDT equivalent) required for a successful presale.
   • _hardcap: Maximum funds the presale can accept.
3. Configure Stages:
   • Takes an array of Stage structs, each defining the price per token and tokens allocated to that stage.

Example:

Stage memory stage1 = Stage({price: 0.00008 * 1e18, tokenAmount: 3_000_000_000 * 1e18});
Stage memory stage2 = Stage({price: 0.00010 * 1e18, tokenAmount: 4_000_000_000 * 1e18});
// Add all stages in the constructor call

---

buyWithETH: Purchase Tokens Using Ether

The buyWithETH function allows users to buy tokens by sending ETH:

function buyWithETH() external payable whenNotPaused nonReentrant

How It Works:

1. Convert ETH to USDT Equivalent:
   • Uses the convertETHtoUSDT function to determine how much USDT the contributed ETH is worth.
   • (Assumes an exchange rate from an oracle or predefined value).
2. Call Internal _purchaseTokens:
   • Handles the actual token sale logic (explained below).
3. Event Logging:
   • Emits a TokensPurchased event with details about the purchase.

---

buyWithStableCoin: Purchase Tokens Using Stablecoins

The buyWithStableCoin function enables token purchases using USDT, USDC, or DAI:

function buyWithStableCoin(IERC20 stableCoin, uint256 amount) external whenNotPaused nonReentrant

How It Works:

1. Validate Stablecoin:
   • Ensures the user is sending an accepted stablecoin (USDT, USDC, or DAI).
2. Transfer Stablecoins:
   • Uses OpenZeppelin’s SafeERC20 to securely transfer amount of the stablecoin from the buyer to the contract.
3. Call Internal _purchaseTokens:
   • Processes the token purchase.

Example:

• A user sends 500 USDT to the presale contract, and the function calculates how many tokens they can buy based on the current stage price.

---

_purchaseTokens: Core Logic for Token Buying

This internal function executes the core mechanics of the token sale:

function _purchaseTokens(
    address buyer,
    uint256 paymentAmount,
    string memory paymentMethod
) internal

Key Steps:

1. Whitelist Validation:
   • Ensures the buyer is on the whitelist.
2. Cap Checks:
   • Verifies that the total raised amount won’t exceed the hardcap.
3. Stage Processing:
   • Determines the number of tokens the buyer can purchase based on the current stage price.
   • Deducts the purchased tokens from the current stage allocation.
4. Record Contributions:
   • Updates contributions (amount paid by the buyer) and tokenClaims (amount of tokens they can claim).
5. Update Sale Totals:
   • Adjusts totalRaised and totalSold.
6. Handle Stage Transition:
   • If the current stage’s tokens are exhausted, move to the next stage.

---

claim: Claim Tokens After the Sale

The claim function lets users claim tokens they’ve purchased once the presale is finalized:

function claim() external

Key Steps:

1. Finalization Check:
   • Ensures the presale is complete before allowing claims.
2. Calculate Claimable Amount:
   • Retrieves the tokens allocated to the user via tokenClaims.
3. Transfer Tokens:
   • Sends the tokens from the contract to the user.
4. Event Logging:
   • Emits a TokensClaimed event.

---

refund: Refund Contributions if Softcap Not Reached

The refund function ensures contributors get their funds back if the presale fails:

function refund() external

Key Steps:

1. Refund Conditions:
   • Ensures the presale is not finalized and the softcap was not reached.
2. Retrieve Contributions:
   • Finds how much the user contributed via contributions.
3. Return Funds:
   • Sends the contribution back to the user and resets their contribution record.
4. Event Logging:
   • Emits a Refunded event.

---

withdraw: Owner Withdraws Raised Funds

The withdraw function lets the owner transfer collected funds out of the contract:

function withdraw() external onlyOwner

Key Steps:

1. Finalization Check:
   • Ensures the presale is finalized and the softcap was reached.
2. Transfer Funds:
   • Sends the contract’s balance to the owner’s address.
3. Event Logging:
   • Emits a FundsWithdrawn event.

---

Whitelisting Functions

The contract includes helper functions to manage the whitelist:

Add or Remove Addresses:

function addToWhitelist(address _addr) external onlyOwner
function removeFromWhitelist(address _addr) external onlyOwner

Validate Buyer:

Checks if the buyer is whitelisted before allowing purchases.

---

Emergency Pause

The Pausable functionality allows the owner to pause or resume the presale in emergencies:

function pause() external onlyOwner
function unpause() external onlyOwner

---

Security and Best Practices

1. SafeERC20: Ensures safe transfers of ERC-20 tokens.
2. Pausable: Allows pausing in emergencies.
3. Whitelist: Only pre-approved buyers can participate.
4. Softcap/Hardcap Enforcement: Guarantees refunds or caps total contributions.
5. Event Logging: Comprehensive logs for auditing.

---

Summary of Workflow

1. Before the Presale:
   • Configure token, stages, and whitelist addresses.
2. During the Presale:
   • Users buy tokens using buyWithETH or buyWithStableCoin.
   • Tokens and funds are securely tracked.
3. After the Presale:
   • Finalize the sale.
   • Users claim tokens using claim.
   • Refunds are issued if the softcap is not reached.
   • Owner withdraws funds if the presale succeeds.

This design ensures a seamless, secure, and flexible presale experience for both the project and its investors.

Implementation of convertETHtoUSDT Using Uniswap V2 Router

To perform a swap on Uniswap V2, we use the UniswapV2Router contract. The function getAmountsOut is useful for estimating the output of a trade, and swapExactETHForTokens can be used to execute the swap.

Required Libraries and Interfaces

First, import the necessary interfaces from the Uniswap SDK or use the interface directly:

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IERC20.sol";

Uniswap V2 Router Interface

Here’s the relevant part of the Uniswap V2 Router interface that we’ll use:

interface IUniswapV2Router02 {
    function getAmountsOut(uint amountIn, address[] calldata path)
        external
        view
        returns (uint[] memory amounts);

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);
}

convertETHtoUSDT Implementation

The implementation would look like this:

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

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract PresaleWithUniswap {
    IUniswapV2Router02 public immutable uniswapRouter;
    address public immutable USDT;
    address public immutable WETH; // Wrapped Ether (required for Uniswap)

    constructor(address _uniswapRouter, address _USDT, address _WETH) {
        require(_uniswapRouter != address(0), "Invalid router address");
        require(_USDT != address(0), "Invalid USDT address");
        require(_WETH != address(0), "Invalid WETH address");

        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        USDT = _USDT;
        WETH = _WETH;
    }

    /**
     * @notice Converts ETH amount to its equivalent value in USDT using Uniswap.
     * @param ethAmount The amount of ETH to convert, in wei.
     * @return usdtAmount The estimated USDT amount received for the ETH.
     */
    function convertETHtoUSDT(uint256 ethAmount) external view returns (uint256 usdtAmount) {
        require(ethAmount > 0, "ETH amount must be greater than zero");

        // Define the path: ETH -> USDT
        address;
        path[0] = WETH; // ETH is first converted to WETH internally
        path[1] = USDT;

        // Get the estimated output amount from Uniswap
        uint256[] memory amountsOut = uniswapRouter.getAmountsOut(ethAmount, path);

        // Return the USDT amount (last element in the path)
        return amountsOut[1];
    }

    /**
     * @notice Swaps exact ETH for USDT using Uniswap.
     * @param amountOutMin The minimum amount of USDT to receive (for slippage protection).
     * @return amounts The actual amounts obtained from the swap.
     */
    function swapETHforUSDT(uint256 amountOutMin) external payable returns (uint256[] memory amounts) {
        require(msg.value > 0, "Must send ETH");

        // Define the path: ETH -> USDT
        address;
        path[0] = WETH;
        path[1] = USDT;

        // Execute the swap on Uniswap
        uint256 deadline = block.timestamp + 15; // 15 seconds from now
        amounts = uniswapRouter.swapExactETHForTokens{value: msg.value}(
            amountOutMin,
            path,
            msg.sender,
            deadline
        );

        return amounts;
    }
}

How It Works

1. convertETHtoUSDT (Estimate Conversion)

• Uses getAmountsOut from the Uniswap V2 Router to fetch the estimated USDT amount for a given ETH amount.
• Takes the trading path [WETH → USDT].
• Returns the expected USDT amount based on current pool reserves.

2. swapETHforUSDT (Execute Swap)

• Executes the actual ETH-to-USDT swap using swapExactETHForTokens.
• Takes in:
  • amountOutMin: Minimum USDT amount expected (to prevent slippage issues).
  • msg.value: Amount of ETH to swap.
  • path: Trading path [WETH → USDT].
• Sends USDT directly to the caller’s address.

Prerequisites and Setup

1. Deployment Addresses:
   • Uniswap V2 Router Address (e.g., 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f for Ethereum Mainnet).
   • Token Addresses for USDT and WETH.
2. Approve Spending:
   • For swaps involving tokens other than ETH (e.g., USDC, DAI), the contract must first approve Uniswap to spend those tokens.
3. ETH and WETH:
   • ETH is internally wrapped into WETH for Uniswap trades. Ensure WETH contract compatibility.

---

Security Considerations

1. Slippage:
   • Use amountOutMin to ensure the user receives at least a minimum amount of USDT, preventing loss from slippage.
2. Reentrancy:
   • Avoid making external calls (like swaps) within other sensitive functions.
3. Gas Optimization:
   • Keep the conversion logic separate from core presale mechanics to minimize gas usage during purchases.

---

Advantages of Uniswap Integration

1. Dynamic Pricing:
   • Always fetches the real-time price based on liquidity pools.
2. Liquidity Support:
   • No need to maintain separate reserves for USDT.
3. Scalability:
   • Easily extendable to support other tokens or chains.

Updated Presale Contract with Uniswap Integration

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

/**
 * @title DeFiCentralTokenPresale
 * @dev Presale contract supporting multiple payment options, staged sales, Uniswap ETH-USDT conversion, and refund/claim logic.
 */
contract DeFiCentralTokenPresale is Pausable, Ownable {
    using SafeERC20 for IERC20;

    // Token and payment configuration
    IERC20 public immutable token; // The DEC token
    IERC20 public immutable usdt;
    IERC20 public immutable usdc;
    IERC20 public immutable dai;

    IUniswapV2Router02 public immutable uniswapRouter; // Uniswap Router
    address public immutable WETH; // Wrapped ETH address for Uniswap path

    // Presale stages
    struct Stage {
        uint256 price;       // Price per token in USDT (scaled by 1e18)
        uint256 tokenAmount; // Tokens allocated for this stage
    }
    Stage[] public stages;

    uint256 public immutable softcap; // Minimum amount of USDT to raise
    uint256 public immutable hardcap; // Maximum amount of USDT to raise
    uint256 public totalRaised;       // Total USDT equivalent raised
    uint256 public totalSold;         // Total tokens sold
    uint256 public currentStageIndex; // Index of the current presale stage

    mapping(address => uint256) public contributions; // Tracks contributions by address
    mapping(address => bool) public whitelist;        // Whitelisted addresses
    mapping(address => uint256) public tokenClaims;   // Tracks claimable tokens for each user

    bool public isFinalized;         // Indicates whether the presale is finalized
    uint256 public constant MIN_CONTRIBUTION = 100 * 1e18; // Minimum contribution in USDT equivalent

    event TokensPurchased(address indexed buyer, uint256 amount, uint256 cost, string paymentMethod);
    event TokensClaimed(address indexed claimant, uint256 amount);
    event FundsWithdrawn(address indexed owner, uint256 amount);
    event Refunded(address indexed contributor, uint256 amount);

    constructor(
        address _token,
        address _usdt,
        address _usdc,
        address _dai,
        address _uniswapRouter,
        address _weth,
        uint256 _softcap,
        uint256 _hardcap,
        Stage[] memory _stages
    ) {
        require(_token != address(0) && _usdt != address(0) && _usdc != address(0) && _dai != address(0), "Invalid token address");
        require(_uniswapRouter != address(0) && _weth != address(0), "Invalid Uniswap address");
        require(_softcap > 0 && _hardcap > _softcap, "Invalid caps");

        token = IERC20(_token);
        usdt = IERC20(_usdt);
        usdc = IERC20(_usdc);
        dai = IERC20(_dai);
        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        WETH = _weth;
        softcap = _softcap;
        hardcap = _hardcap;

        for (uint256 i = 0; i < _stages.length; i++) {
            stages.push(_stages[i]);
        }
    }

    /**
     * @notice Buy tokens using ETH.
     * @dev Converts ETH to USDT equivalent using Uniswap for price calculation.
     */
    function buyWithETH() external payable whenNotPaused {
        require(msg.value > 0, "ETH amount must be greater than 0");

        // Get the USDT equivalent using Uniswap
        uint256 ethToUSDT = convertETHtoUSDT(msg.value);
        require(ethToUSDT >= MIN_CONTRIBUTION, "Contribution below minimum");

        _purchaseTokens(msg.sender, ethToUSDT, "ETH");
    }

    /**
     * @notice Converts ETH amount to USDT equivalent using Uniswap.
     * @param ethAmount The amount of ETH to convert.
     * @return usdtAmount The estimated USDT amount for the given ETH.
     */
    function convertETHtoUSDT(uint256 ethAmount) public view returns (uint256 usdtAmount) {
        require(ethAmount > 0, "ETH amount must be greater than zero");

        // Define the Uniswap path: WETH -> USDT
        address;
        path[0] = WETH;
        path[1] = address(usdt);

        // Get the amount of USDT for the ETH amount
        uint256[] memory amountsOut = uniswapRouter.getAmountsOut(ethAmount, path);
        return amountsOut[1]; // Return the USDT amount
    }

    /**
     * @notice Buy tokens using a stablecoin.
     * @param stableCoin The stablecoin used (USDT, USDC, or DAI).
     * @param amount The amount of stablecoin to contribute.
     */
    function buyWithStableCoin(IERC20 stableCoin, uint256 amount) external whenNotPaused {
        require(
            stableCoin == usdt || stableCoin == usdc || stableCoin == dai,
            "Unsupported stablecoin"
        );
        require(amount >= MIN_CONTRIBUTION, "Amount below minimum contribution");

        stableCoin.safeTransferFrom(msg.sender, address(this), amount);
        _purchaseTokens(msg.sender, amount, "Stablecoin");
    }

    /**
     * @notice Claim purchased tokens after the presale ends.
     */
    function claim() external {
        require(isFinalized, "Presale not finalized");
        uint256 claimableAmount = tokenClaims[msg.sender];
        require(claimableAmount > 0, "No claimable tokens");

        tokenClaims[msg.sender] = 0;
        token.safeTransfer(msg.sender, claimableAmount);

        emit TokensClaimed(msg.sender, claimableAmount);
    }

    // Other methods omitted for brevity...

    /**
     * @dev Internal helper to handle token purchases.
     * @param buyer The address of the buyer.
     * @param paymentAmount The payment amount in USDT equivalent.
     * @param paymentMethod The payment method used ("ETH" or "Stablecoin").
     */
    function _purchaseTokens(
        address buyer,
        uint256 paymentAmount,
        string memory paymentMethod
    ) internal {
        require(whitelist[buyer], "Address not whitelisted");
        require(totalRaised + paymentAmount <= hardcap, "Hardcap exceeded");

        Stage storage stage = stages[currentStageIndex];
        uint256 tokensToBuy = (paymentAmount * 1e18) / stage.price; // Calculate tokens
        require(stage.tokenAmount >= tokensToBuy, "Insufficient tokens in stage");

        contributions[buyer] += paymentAmount;
        tokenClaims[buyer] += tokensToBuy;
        totalRaised += paymentAmount;
        totalSold += tokensToBuy;

        stage.tokenAmount -= tokensToBuy;
        if (stage.tokenAmount == 0) {
            currentStageIndex++;
        }

        emit TokensPurchased(buyer, tokensToBuy, paymentAmount, paymentMethod);
    }
}

Key Changes

1. Uniswap Integration:
   • Added the convertETHtoUSDT function using Uniswap’s getAmountsOut to fetch real-time conversion rates.
   • Integrated Uniswap router and WETH addresses in the constructor.
2. Dynamic ETH Conversion:
   • Used Uniswap’s liquidity pools to calculate USDT equivalent for ETH payments.
3. Gas Optimization:
   • Kept price queries (convertETHtoUSDT) separate from token purchase logic.

---

Example Deployment Parameters

• Uniswap Router: 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f (Ethereum Mainnet Uniswap V2 Router).
• WETH Address: 0xC02aaa39b223FE8D0a0e5C4F27eAD9083C756Cc2.

This updated version ensures real-time ETH-to-USDT price conversion for accurate contributions during the presale.

Conclusion

This intelligent contract of the DeFi-Central token presale is rich in feature powerhouse design, meant for seamless fundraising in the decentralized finance ecosystem. The inclusion of multi-payment methods, staged selling of the token, whitelist, and refund mechanisms therein all point to the fact that flexibility, safety, and user inclusiveness were held dear in writing the contract. It integrates with UniSwap for real-time ETH-to-USDT conversions. This will provide dynamic pricing and allow more people to access this pre-sale. Above is a basic example that lays the groundwork for a scalable, open, and equitable presale in a token sale.

This is the first of articles on developing, testing, and integrating the DeFi-Central ecosystem. In future articles, we shall delve more into practical aspects, including:

• How to test the DeFi-Central smart contract on Sepolia’s testnet?
  A step-by-step procedure as to the deployment and interaction with Ethereum’s Sepolia testnet to make sure that everything goes all right, without mainnet risks after going live.
• How to Deploy the DeFi-Central Presale Smart-Contract into a Frontend?
  Explain with examples, and describe, in simple words, everything regarding creating a user-oriented interface of interaction with smart contracts so as to give more ease in taking part in such a presale event at convenience.

Stay tuned, as it is an ongoing journey we are at, to see the transformation of DeFi-Central into a fully fledged end-to-end product within the wide world of DeFi space.

https://defi-central.net/BlockchainTraining.html

Comprehensive Blockchain Learning Roadmap

A Philosophical Take on Blockchain