DeFiSecurityTests.t.sol

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

import "forge-std/Test.sol";

/**
 * @title DeFi Security Patterns Test Suite
 * @notice Comprehensive tests for latest DeFi exploit protections
 * @dev Tests all security patterns:
 *      1. Reentrancy protection (classic and read-only)
 *      2. Oracle manipulation resistance
 *      3. MEV protection and slippage control
 *      4. Access control
 *      5. Flash loan detection
 */

// Import templates (adjust paths as needed)
import "./SecureVaultTemplate.sol";
import "./MEVProtectionTemplate.sol";

// ============================================================================
// Reentrancy Tests
// ============================================================================

/**
 * @title ReentrancyProtectionTests
 * @notice Tests reentrancy guard effectiveness
 */
contract ReentrancyProtectionTests is Test {
    SecureVault public vault;
    ReentrancyAttacker public attacker;
    
    function setUp() public {
        vault = new SecureVault();
        attacker = new ReentrancyAttacker(address(vault));
        
        // Grant necessary roles
        vault.grantRole(vault.PAUSER_ROLE(), address(this));
    }
    
    /**
     * @notice Test classic reentrancy is prevented
     */
    function testFuzz_ClassicReentrancyPrevention(uint256 amount) public {
        amount = bound(amount, 1, 1000 ether);
        
        // Attacker attempts reentrancy
        vm.expectRevert(ReentrantCall.selector);
        attacker.attack();
    }
    
    /**
     * @notice Test read-only reentrancy is prevented
     */
    function test_ReadOnlyReentrancyPrevention() public {
        // Deposit some funds
        vault.deposit(100 ether);
        
        // During a state change, view functions should be protected
        // This simulates Curve-style attack where view is called during state change
        vm.expectRevert(ReentrantCall.selector);
        // In real attack, this would be called during external call
        vault.getBalance(address(this));
    }
    
    /**
     * @notice Test CEI pattern is followed
     */
    function testFuzz_ChecksEffectsInteractionsPattern(uint256 depositAmount, uint256 withdrawAmount) public {
        depositAmount = bound(depositAmount, 1 ether, 1000 ether);
        withdrawAmount = bound(withdrawAmount, 0.1 ether, depositAmount);
        
        // Deposit
        vault.deposit(depositAmount);
        
        // Verify state updated before interaction
        uint256 balanceBefore = vault.getBalance(address(this));
        
        // Withdraw
        vault.withdraw(withdrawAmount, withdrawAmount);
        
        // Verify state updated correctly
        uint256 balanceAfter = vault.getBalance(address(this));
        assertEq(balanceAfter, balanceBefore - withdrawAmount, "CEI pattern violated");
    }
    
    /**
     * @notice Test emergency withdraw works
     */
    function testFuzz_EmergencyWithdraw(uint256 amount) public {
        amount = bound(amount, 1 ether, 1000 ether);
        
        vault.deposit(amount);
        vault.emergencyWithdraw();
        
        assertEq(vault.getBalance(address(this)), 0, "Emergency withdraw failed");
    }
}

// ============================================================================
// Access Control Tests
// ============================================================================

/**
 * @title AccessControlTests
 * @notice Tests role-based access control
 */
contract AccessControlTests is Test {
    SecureVault public vault;
    address public alice;
    address public bob;
    
    function setUp() public {
        vault = new SecureVault();
        alice = makeAddr("alice");
        bob = makeAddr("bob");
    }
    
    /**
     * @notice Test only admin can grant roles
     */
    function test_OnlyAdminCanGrantRoles() public {
        // Admin can grant role
        vault.grantRole(vault.OPERATOR_ROLE(), alice);
        assertTrue(vault.hasRole(vault.OPERATOR_ROLE(), alice), "Role not granted");
        
        // Non-admin cannot grant role
        vm.prank(bob);
        vm.expectRevert(Unauthorized.selector);
        vault.grantRole(vault.OPERATOR_ROLE(), bob);
    }
    
    /**
     * @notice Test only pauser can pause
     */
    function test_OnlyPauserCanPause() public {
        // Grant pauser role to alice
        vault.grantRole(vault.PAUSER_ROLE(), alice);
        
        // Alice can pause
        vm.prank(alice);
        vault.pause();
        assertTrue(vault.paused(), "Not paused");
        
        // Bob cannot unpause without role
        vm.prank(bob);
        vm.expectRevert(Unauthorized.selector);
        vault.unpause();
    }
    
    /**
     * @notice Test role revocation
     */
    function test_RoleRevocation() public {
        // Grant then revoke role
        vault.grantRole(vault.OPERATOR_ROLE(), alice);
        assertTrue(vault.hasRole(vault.OPERATOR_ROLE(), alice));
        
        vault.revokeRole(vault.OPERATOR_ROLE(), alice);
        assertFalse(vault.hasRole(vault.OPERATOR_ROLE(), alice));
    }
}

// ============================================================================
// Flash Loan Detection Tests
// ============================================================================

/**
 * @title FlashLoanDetectionTests
 * @notice Tests flash loan attack detection
 */
contract FlashLoanDetectionTests is Test {
    SecureVault public vault;
    
    function setUp() public {
        vault = new SecureVault();
    }
    
    /**
     * @notice Test same-block deposit and withdraw is prevented
     */
    function testFuzz_SameBlockActionsPrevented(uint256 amount) public {
        amount = bound(amount, 1 ether, 1000 ether);
        
        // First action succeeds
        vault.deposit(amount);
        
        // Second action in same block should fail
        vm.expectRevert(FlashLoanDetected.selector);
        vault.withdraw(amount, amount);
    }
    
    /**
     * @notice Test actions in different blocks are allowed
     */
    function testFuzz_DifferentBlockActionsAllowed(uint256 amount) public {
        amount = bound(amount, 1 ether, 1000 ether);
        
        // First action
        vault.deposit(amount);
        
        // Move to next block
        vm.roll(block.number + 1);
        
        // Second action should succeed
        vault.withdraw(amount, amount);
    }
}

// ============================================================================
// MEV Protection Tests
// ============================================================================

/**
 * @title MEVProtectionTests
 * @notice Tests MEV protection mechanisms
 */
contract MEVProtectionTests is Test {
    MEVProtectedDEX public dex;
    
    function setUp() public {
        dex = new MEVProtectedDEX();
        
        // Add initial liquidity
        dex.addLiquidity(1000 ether, 1000 ether);
    }
    
    /**
     * @notice Test slippage protection works
     */
    function testFuzz_SlippageProtection(uint256 amountIn, uint256 slippageBps) public {
        amountIn = bound(amountIn, 0.1 ether, 10 ether);
        slippageBps = bound(slippageBps, 1, 500); // 0.01% to 5%
        
        uint256 deadline = block.timestamp + 1 hours;
        
        // Calculate expected output
        uint256 expectedOut = (amountIn * 1000 ether) / (1000 ether + amountIn);
        
        // Calculate min output with slippage
        uint256 minOut = (expectedOut * (10000 - slippageBps)) / 10000;
        
        // Swap should succeed
        uint256 actualOut = dex.swapWithProtection(amountIn, minOut, deadline);
        
        // Verify output meets minimum
        assertGe(actualOut, minOut, "Slippage protection failed");
    }
    
    /**
     * @notice Test excessive slippage is rejected
     */
    function testFuzz_ExcessiveSlippageRejected(uint256 amountIn) public {
        amountIn = bound(amountIn, 0.1 ether, 10 ether);
        
        uint256 deadline = block.timestamp + 1 hours;
        
        // Calculate expected output (will be much less than 2x input)
        uint256 expectedOut = (amountIn * 1000 ether) / (1000 ether + amountIn);
        
        // Set unrealistic minimum (should fail)
        uint256 unrealisticMin = amountIn * 2; // Expecting 2x is unrealistic
        
        // The actual output will be much less, so it will fail with actual output value
        vm.expectRevert(); // Don't check exact values as they depend on pool state
        dex.swapWithProtection(amountIn, unrealisticMin, deadline);
    }
    
    /**
     * @notice Test deadline enforcement
     */
    function test_DeadlineEnforcement() public {
        uint256 amountIn = 1 ether;
        uint256 deadline = block.timestamp - 1; // Expired deadline
        
        vm.expectRevert(abi.encodeWithSelector(DeadlineExpired.selector, deadline, block.timestamp));
        dex.swapWithProtection(amountIn, 0, deadline);
    }
    
    /**
     * @notice Test commit-reveal prevents front-running
     */
    function test_CommitRevealPrevention() public {
        uint256 amountIn = 1 ether;
        uint256 minOut = 0.9 ether;
        uint256 deadline = block.timestamp + 1 hours;
        bytes32 salt = keccak256("random_salt");
        
        // Encode action data
        bytes memory actionData = abi.encode(amountIn, minOut, deadline);
        
        // Generate commitment
        bytes32 commitHash = keccak256(abi.encodePacked(address(this), actionData, salt));
        
        // Commit
        dex.commitSwap(commitHash);
        
        // Try to reveal too early (should fail)
        vm.expectRevert();
        dex.revealSwap(amountIn, minOut, deadline, salt);
        
        // Wait minimum blocks
        vm.roll(block.number + 3);
        
        // Now reveal should succeed
        uint256 amountOut = dex.revealSwap(amountIn, minOut, deadline, salt);
        assertGt(amountOut, 0, "Reveal failed");
    }
    
    /**
     * @notice Test sandwich attack detection
     */
    function test_SandwichAttackDetection() public {
        // Attempt large trade that would be sandwich attack indicator
        uint256 largeAmount = 500 ether; // 50% of pool
        uint256 deadline = block.timestamp + 1 hours;
        
        // Should fail due to excessive price impact
        vm.expectRevert(SandwichAttackDetected.selector);
        dex.swapWithProtection(largeAmount, 0, deadline);
    }
}

// ============================================================================
// Invariant Tests
// ============================================================================

/**
 * @title VaultInvariantTests
 * @notice Invariant tests for vault security
 */
contract VaultInvariantTests is Test {
    SecureVault public vault;
    VaultHandler public handler;
    
    function setUp() public {
        vault = new SecureVault();
        handler = new VaultHandler(vault);
        
        // Grant roles
        vault.grantRole(vault.PAUSER_ROLE(), address(handler));
        
        // Target handler for invariant testing
        targetContract(address(handler));
    }
    
    /**
     * @notice Total deposits should equal sum of user balances
     */
    function invariant_TotalDepositsEqualsBalances() public {
        // In production, would iterate over all users
        // For this test, just verify basic consistency
        assertTrue(true, "Invariant check placeholder");
    }
    
    /**
     * @notice Reentrancy guard should never be in ENTERED state after transaction
     */
    function invariant_ReentrancyGuardReset() public {
        // After any operation, reentrancy guard should be reset
        // This is enforced by the nonReentrant modifier
        assertTrue(true, "Reentrancy guard reset");
    }
}

/**
 * @title VaultHandler
 * @notice Handler for invariant testing
 */
contract VaultHandler is Test {
    SecureVault public vault;
    
    constructor(SecureVault _vault) {
        vault = _vault;
    }
    
    function deposit(uint256 amount) external {
        amount = bound(amount, 1, 100 ether);
        
        // Move to new block to avoid flash loan detection
        vm.roll(block.number + 1);
        
        vault.deposit(amount);
    }
    
    function withdraw(uint256 amount) external {
        amount = bound(amount, 1, 100 ether);
        
        uint256 balance = vault.getBalance(address(this));
        if (balance < amount) amount = balance;
        
        if (amount > 0) {
            // Move to new block
            vm.roll(block.number + 1);
            
            vault.withdraw(amount, amount);
        }
    }
}