Comment développer et déployer un ERC-20 sur Ethereum en 2026

curl -L https://foundry.paradigm.xyz | bash
foundryup
forge --version
cast --version
anvil --version

forge init erc20-token --template https://github.com/foundry-rs/forge-template
cd erc20-token
git init
git add .
git commit -m "Initial Foundry ERC-20 project"
forge install

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
remappings = [
  "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
]

[profile.default.rpc_storage_caching]
chains = { sepolia = { mode = "local" } }

[profile.default.fuzz]
runs = 10000
seed = 123456789

[profile.default.wallets]
from_key = "${PRIVATE_KEY}"

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract MyToken is ERC20, ERC20Pausable, Ownable, ReentrancyGuard {
    mapping(address => bool) public blacklist;

    event Blacklisted(address indexed account);
    event Unblacklisted(address indexed account);

    constructor() ERC20("MyToken", "MTK") Ownable(msg.sender) {
        _mint(msg.sender, 1_000_000 * 10**decimals());
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function blacklistAddress(address account) public onlyOwner {
        blacklist[account] = true;
        emit Blacklisted(account);
    }

    function unblacklistAddress(address account) public onlyOwner {
        blacklist[account] = false;
        emit Unblacklisted(account);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override(ERC20, ERC20Pausable)
    {
        require(!blacklist[from] && !blacklist[to], "Blacklisted address");
        super._beforeTokenTransfer(from, to, amount);
    }

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

    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import {Test, console} from "forge-std/Test.sol";
import {MyToken} from "../src/MyToken.sol";

contract MyTokenTest is Test {
    MyToken token;
    address owner = makeAddr("owner");
    address user = makeAddr("user");
    address blackUser = makeAddr("blackUser");

    function setUp() public {
        vm.prank(owner);
        token = new MyToken();
    }

    function testInitialSupply() public {
        assertEq(token.totalSupply(), 1_000_000 * 10**token.decimals());
        assertEq(token.balanceOf(owner), 1_000_000 * 10**token.decimals());
    }

    function testMint() public {
        uint256 mintAmount = 100 * 10**token.decimals();
        vm.prank(owner);
        token.mint(user, mintAmount);
        assertEq(token.balanceOf(user), mintAmount);
    }

    function testPause() public {
        vm.prank(owner);
        token.pause();
        vm.expectRevert("Pausable: paused");
        token.transfer(user, 1);
        vm.prank(owner);
        token.unpause();
    }

    function testBlacklist() public {
        vm.startPrank(owner);
        token.blacklistAddress(blackUser);
        vm.stopPrank();
        vm.expectRevert("Blacklisted address");
        vm.prank(blackUser);
        token.transfer(user, 1);
    }

    function testFuzzBurn(uint256 amount) public {
        vm.assume(amount <= token.balanceOf(owner));
        vm.prank(owner);
        token.burn(amount);
        assertEq(token.balanceOf(owner), 1_000_000 * 10**token.decimals() - amount);
    }

    function testInvariantTotalSupply() public {
        uint256 initial = token.totalSupply();
        // Mint/burn/pause ne change pas l'invariant
        assertEq(token.totalSupply(), initial);
    }
}

forge build
forge test --gas-report
forge test --fuzz-runs 10000
forge snapshot

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

import {Script, console} from "forge-std/Script.sol";
import {MyToken} from "../src/MyToken.sol";

contract Deploy is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);
        
        MyToken token = new MyToken();
        console.log("MyToken deployed to:", address(token));
        console.log("Owner:", token.owner());
        console.log("Total Supply:", token.totalSupply());

        vm.stopBroadcast();
    }
}

export PRIVATE_KEY=0xYourPrivateKeyHere
export SEPOLIA_RPC_URL=https://rpc.sepolia.org  # ou Alchemy
forge script script/Deploy.s.sol:Deploy --rpc-url $SEPOLIA_RPC_URL --broadcast --verify --etherscan-api-key $ETHERSCAN_API_KEY --legacy