🪙 Day 13 of #30DaysOfSolidity — Building a Token Sale (Sell Your ERC-20 for ETH with Foundry)

day-13-token-sale/
├── src/
│   ├── MyToken.sol
│   └── TokenSale.sol
├── script/
│   └── Deploy.s.sol
├── test/
│   └── TokenSale.t.sol
├── foundry.toml
└── README.md

curl -L https://foundry.paradigm.xyz | bash
foundryup

forge init day-13-token-sale
cd day-13-token-sale

forge install OpenZeppelin/openzeppelin-contracts

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

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

/// @title MyToken - Simple ERC20 Token
contract MyToken is ERC20, Ownable {
    constructor(string memory name_, string memory symbol_, uint256 initialSupply)
        ERC20(name_, symbol_)
    {
        _mint(msg.sender, initialSupply * 10 ** decimals());
    }

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

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

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

/// @title TokenSale - Sell tokens for ETH
contract TokenSale is Ownable {
    IERC20 public token;
    uint256 public tokensPerEth;
    bool public saleActive;

    event TokensPurchased(address indexed buyer, uint256 ethSpent, uint256 tokensBought);
    event PriceUpdated(uint256 oldPrice, uint256 newPrice);
    event SaleToggled(bool active);
    event EtherWithdrawn(address indexed to, uint256 amount);
    event TokensWithdrawn(address indexed to, uint256 amount);

    constructor(address tokenAddress, uint256 _tokensPerEth) {
        require(tokenAddress != address(0), "Invalid token address");
        token = IERC20(tokenAddress);
        tokensPerEth = _tokensPerEth;
        saleActive = true;
    }

    function buyTokens() public payable {
        require(saleActive, "Sale not active");
        require(msg.value > 0, "Send ETH to buy tokens");

        uint256 tokensToBuy = (msg.value * tokensPerEth) / 1 ether;
        require(tokensToBuy > 0, "Not enough ETH for 1 token");

        require(token.balanceOf(address(this)) >= tokensToBuy, "Not enough tokens");

        token.transfer(msg.sender, tokensToBuy);
        emit TokensPurchased(msg.sender, msg.value, tokensToBuy);
    }

    function setPrice(uint256 _tokensPerEth) external onlyOwner {
        require(_tokensPerEth > 0, "Invalid price");
        emit PriceUpdated(tokensPerEth, _tokensPerEth);
        tokensPerEth = _tokensPerEth;
    }

    function toggleSale(bool _active) external onlyOwner {
        saleActive = _active;
        emit SaleToggled(_active);
    }

    function withdrawEther(address payable to) external onlyOwner {
        uint256 amount = address(this).balance;
        require(amount > 0, "No Ether");
        (bool sent, ) = to.call{value: amount}("");
        require(sent, "Transfer failed");
        emit EtherWithdrawn(to, amount);
    }

    function withdrawTokens(address to) external onlyOwner {
        uint256 amount = token.balanceOf(address(this));
        require(amount > 0, "No tokens");
        token.transfer(to, amount);
        emit TokensWithdrawn(to, amount);
    }

    receive() external payable {
        buyTokens();
    }
}

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

import "forge-std/Script.sol";
import "../src/MyToken.sol";
import "../src/TokenSale.sol";

contract Deploy is Script {
    function run() external {
        vm.startBroadcast();

        // Deploy ERC20 Token
        MyToken token = new MyToken("MyToken", "MTK", 1_000_000);

        // Deploy Token Sale
        uint256 price = 1000 * 10 ** 18; // 1000 tokens per 1 ETH
        TokenSale sale = new TokenSale(address(token), price);

        // Transfer tokens to sale contract
        token.transfer(address(sale), 100_000 * 10 ** 18);

        vm.stopBroadcast();
    }
}

forge build

anvil

forge script script/Deploy.s.sol:Deploy --rpc-url http://127.0.0.1:8545 --private-key <YOUR_PRIVATE_KEY> --broadcast