Solidity Security

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract Vault is ReentrancyGuard {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) external nonReentrant {
        if (balances[msg.sender] < amount) revert InsufficientBalance();

        balances[msg.sender] -= amount;

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract TokenVault {
    using SafeERC20 for IERC20;

    function deposit(IERC20 token, uint256 amount) external {
        // SafeERC20 handles non-standard return values
        token.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(IERC20 token, uint256 amount) external {
        token.safeTransfer(msg.sender, amount);
    }

    function approveSpender(IERC20 token, address spender, uint256 amount) external {
        // forceApprove handles tokens requiring approval reset to 0 first (USDT)
        token.forceApprove(spender, amount);
    }
}

// WRONG: assuming 18 decimals
uint256 oneToken = 1e18;

// RIGHT: query decimals
uint8 decimals = IERC20Metadata(address(token)).decimals();
uint256 oneToken = 10 ** decimals;

// Common decimals:
// USDC: 6 decimals  (1 USDC = 1e6)
// USDT: 6 decimals  (1 USDT = 1e6)
// WBTC: 8 decimals  (1 WBTC = 1e8)
// DAI:  18 decimals (1 DAI  = 1e18)
// WETH: 18 decimals (1 WETH = 1e18)

import {Ownable2Step, Ownable} from "@openzeppelin/contracts/access/Ownable2Step.sol";

contract Protocol is Ownable2Step {
    constructor(address initialOwner) Ownable(initialOwner) {}

    function emergencyPause() external onlyOwner {
        _pause();
    }
}

bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

function pause() external onlyRole(PAUSER_ROLE) {
    _pause();
}

error ZeroAddress();
error ZeroAmount();
error InvalidBps(uint256 bps);
error ArrayLengthMismatch();
error ExceedsMaximum(uint256 value, uint256 maximum);

function setFee(uint256 feeBps) external onlyOwner {
    if (feeBps > 10_000) revert InvalidBps(feeBps);
    fee = feeBps;
}

function batchTransfer(address[] calldata recipients, uint256[] calldata amounts) external {
    if (recipients.length != amounts.length) revert ArrayLengthMismatch();
    if (recipients.length == 0) revert ZeroAmount();

    for (uint256 i; i < recipients.length; ++i) {
        if (recipients[i] == address(0)) revert ZeroAddress();
        if (amounts[i] == 0) revert ZeroAmount();
        _transfer(recipients[i], amounts[i]);
    }
}

function safeCall(address target, bytes calldata data)
    external
    returns (bytes memory)
{
    if (target.code.length == 0) revert NotAContract(target);

    (bool success, bytes memory returndata) = target.call(data);

    if (!success) {
        // Bubble up the revert reason
        if (returndata.length > 0) {
            assembly {
                revert(add(returndata, 0x20), mload(returndata))
            }
        }
        revert CallFailed(target);
    }

    return returndata;
}

// BAD: transfer() has 2300 gas stipend, can break with EIP-1884
payable(recipient).transfer(amount);

// BAD: send() silently fails
payable(recipient).send(amount);

// GOOD: low-level call with success check
(bool success,) = recipient.call{value: amount}("");
if (!success) revert ETHTransferFailed();

// BAD: relies on contract balance
function totalDeposits() external view returns (uint256) {
    return address(this).balance;
}

// GOOD: track deposits explicitly
uint256 public totalDeposited;

function deposit() external payable {
    totalDeposited += msg.value;
}