Smart Contract Developer

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

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**
 * @title MyToken
 * @author Your Name
 * @notice A simple ERC20 token with minting capability
 * @dev Inherits OpenZeppelin ERC20 and Ownable
 */
contract MyToken is ERC20, Ownable, ReentrancyGuard {
    uint256 public constant MAX_SUPPLY = 1_000_000 * 1e18;

    error ExceedsMaxSupply(uint256 requested, uint256 available);

    event TokensMinted(address indexed to, uint256 amount);

    constructor() ERC20("MyToken", "MTK") Ownable(msg.sender) {}

    function mint(address to, uint256 amount) external onlyOwner {
        if (totalSupply() + amount > MAX_SUPPLY) {
            revert ExceedsMaxSupply(amount, MAX_SUPPLY - totalSupply());
        }
        _mint(to, amount);
        emit TokensMinted(to, amount);
    }
}

// VULNERABLE: State updated after external call
function withdraw(uint256 amount) external {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
    balances[msg.sender] -= amount; // Too late -- attacker re-entered above
}

// FIXED: Checks-Effects-Interactions pattern + ReentrancyGuard
function withdraw(uint256 amount) external nonReentrant {
    // Checks
    if (balances[msg.sender] < amount) revert InsufficientBalance();

    // Effects (update state BEFORE external call)
    balances[msg.sender] -= amount;

    // Interactions (external call last)
    (bool success, ) = msg.sender.call{value: amount}("");
    if (!success) revert TransferFailed();
}

// VULNERABLE: No access control on critical function
function setPrice(uint256 newPrice) external {
    price = newPrice;
}

// VULNERABLE: tx.origin check (phishable)
function withdraw() external {
    require(tx.origin == owner, "Not owner");
    // Attacker tricks owner into calling malicious contract that calls this
}

// FIXED: Use msg.sender with role-based access
function setPrice(uint256 newPrice) external onlyOwner {
    price = newPrice;
}

// For complex roles, use AccessControl from OpenZeppelin
// bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
// function setPrice(uint256 newPrice) external onlyRole(ADMIN_ROLE) { ... }

// VULNERABLE: Swap with no slippage protection
function swap(address tokenIn, uint256 amountIn) external {
    uint256 amountOut = calculateOutput(amountIn);
    // Attacker sees this in mempool, sandwiches the trade
    IERC20(tokenOut).transfer(msg.sender, amountOut);
}

// FIXED: User-specified minimum output
function swap(
    address tokenIn,
    uint256 amountIn,
    uint256 minAmountOut, // slippage protection
    uint256 deadline       // time protection
) external {
    if (block.timestamp > deadline) revert Expired();
    uint256 amountOut = calculateOutput(amountIn);
    if (amountOut < minAmountOut) revert SlippageExceeded();
    IERC20(tokenOut).transfer(msg.sender, amountOut);
}

// VULNERABLE: Spot price from a single DEX (easily manipulated with flash loans)
function getPrice() public view returns (uint256) {
    return dexPair.getReserves(); // Manipulable in same transaction
}

// FIXED: Use time-weighted average price (TWAP) or Chainlink oracle
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

function getPrice() public view returns (uint256) {
    (, int256 answer, , uint256 updatedAt, ) = priceFeed.latestRoundData();
    if (answer <= 0) revert InvalidPrice();
    if (block.timestamp - updatedAt > 3600) revert StalePrice();
    return uint256(answer);
}

// EXPENSIVE: Each storage slot is 32 bytes, each SSTORE costs 20,000 gas (cold)
// Pack variables into same slot when possible

// BAD: 3 storage slots (96 bytes)
uint256 amount;    // slot 0 (32 bytes)
address user;      // slot 1 (20 bytes, but uses full slot)
bool active;       // slot 2 (1 byte, but uses full slot)

// GOOD: 2 storage slots (52 bytes, user+active packed into slot 1)
uint256 amount;    // slot 0
address user;      // slot 1 (20 bytes)
bool active;       // slot 1 (1 byte, packed with user)

// 1. Cache storage reads in memory
// BAD
function process() external {
    for (uint256 i = 0; i < items.length; i++) { // reads items.length from storage each iteration
        // ...
    }
}
// GOOD
function process() external {
    uint256 len = items.length; // single SLOAD
    for (uint256 i = 0; i < len; i++) {
        // ...
    }
}

// 2. Use calldata instead of memory for read-only function args
// BAD
function processArray(uint256[] memory data) external { ... }
// GOOD
function processArray(uint256[] calldata data) external { ... }

// 3. Use custom errors instead of revert strings
// BAD: ~256 bytes of deployment cost per string
require(amount > 0, "Amount must be greater than zero");
// GOOD: ~64 bytes, cheaper to deploy and to revert
error ZeroAmount();
if (amount == 0) revert ZeroAmount();

// 4. Use unchecked for provably safe arithmetic
function sum(uint256 a, uint256 b) internal pure returns (uint256) {
    // Only use when you can mathematically prove no overflow
    unchecked { return a + b; }
}

// 5. Short-circuit conditionals (put cheap check first)
// BAD
if (expensiveCall() && msg.sender == owner) { ... }
// GOOD
if (msg.sender == owner && expensiveCall()) { ... }

// test/MyToken.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

contract MyTokenTest is Test {
    MyToken public token;
    address public owner = makeAddr("owner");
    address public alice = makeAddr("alice");

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

    function test_MintSuccess() public {
        vm.prank(owner);
        token.mint(alice, 1000e18);
        assertEq(token.balanceOf(alice), 1000e18);
    }

    function test_MintRevertsForNonOwner() public {
        vm.prank(alice);
        vm.expectRevert();
        token.mint(alice, 1000e18);
    }

    function test_MintRevertsExceedMaxSupply() public {
        vm.prank(owner);
        vm.expectRevert();
        token.mint(alice, 1_000_001e18);
    }

    // Fuzz testing -- Foundry generates random inputs
    function testFuzz_MintWithinSupply(uint256 amount) public {
        amount = bound(amount, 1, 1_000_000e18);
        vm.prank(owner);
        token.mint(alice, amount);
        assertEq(token.balanceOf(alice), amount);
    }

    // Invariant: total supply never exceeds MAX_SUPPLY
    function invariant_SupplyNeverExceedsMax() public view {
        assertLe(token.totalSupply(), token.MAX_SUPPLY());
    }
}

# Foundry commands
forge build                     # Compile contracts
forge test -vvv                 # Run tests (verbose)
forge test --gas-report         # Show gas usage per function
forge coverage                  # Show code coverage
forge snapshot                  # Create gas snapshot for comparison
forge script script/Deploy.s.sol --rpc-url $RPC --broadcast  # Deploy