// Tốt: Đóng gói 2 biến uint128 vào 1 slot
uint128 a; // 16 bytes
uint128 b; // 16 bytes

// Không tốt: sử dụng 2 slot do có một biến uint256
uint128 a;
uint256 b; 

receive() external payable {
  // Xử lý khi nhận ETH hợp lệ
}

fallback() external payable {
  // Xử lý các cuộc gọi không xác định
}

function basicTransferETH(address payable recipient, uint256 amount) external {
  require(address(this).balance >= amount, "Insufficient balance");
  recipient.transfer(amount);
}

function basicSendETH(address payable recipient, uint256 amount) external {
  require(address(this).balance >= amount, "Insufficient balance");
  bool success = recipient.send(amount);
  require(success, "Failed to send Ether");
}

function safeTransferETH(address payable recipient, uint256 amount) external payable {
  require(address(this).balance >= amount, "Insufficient balance");
  (bool sent, ) = recipient.call{value: amount}("");
  require(sent, "Failed to send Ether");
}

bool success = IERC20(tokenAddress).transfer(to, amount);
require(success, "Token transfer failed");

function pay() public payable {
  require(msg.value > 0, "No ETH sent");
  address payer = msg.sender;
}

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

interface IERC20 {
  function transfer(address to, uint256 amount) external returns (bool);
}

contract DeepDiveContract {
  // ❌ Mặt hạn chế về storage packing
  uint128 bigNumber;
  uint256 veryBigNumber;

  // ✅ Tối ưu lưu trữ với storage packing
  uint128 smallA;
  uint128 smallB;

  // Sự kiện
  event Received(address sender, uint256 amount, bytes data, bytes4 sig);
  event PaymentSent(address recipient, uint256 amount);
  event TokenSent(address recipient, uint256 amount, address tokenAddress);

  // Nhận ETH
  receive() external payable {
    emit Received(msg.sender, msg.value, msg.data, msg.sig);
  }

  fallback() external payable {
    emit Received(msg.sender, msg.value, msg.data, msg.sig);
  }

  // Gửi ETH sử dụng call
  function sendEther(address payable _to) external payable {
    require(msg.value > 0, "Send some ETH to forward");
    (bool sent, ) = _to.call{value: msg.value}("");
    require(sent, "Failed to send Ether");
    emit PaymentSent(_to, msg.value);
  }

  // Gửi token ERC20
  function sendToken(address tokenAddress, address to, uint256 amount) external {
    bool success = IERC20(tokenAddress).transfer(to, amount);
    require(success, "Token transfer failed");
    emit TokenSent(to, amount, tokenAddress);
  }

  // Ghi dữ liệu vào storage không tối ưu
  function writeBadStorage(uint128 _bigNumber, uint256 _veryBigNumber) external {
    bigNumber = _bigNumber;
    veryBigNumber = _veryBigNumber;
  }

  // Ghi dữ liệu vào storage tối ưu
  function writeGoodStorage(uint128 _smallA, uint128 _smallB) external {
    smallA = _smallA;
    smallB = _smallB;
  }

  // Đọc storage không tối ưu
  function viewBadStorage() external view returns (uint128, uint256) {
    return (bigNumber, veryBigNumber);
  }

  // Đọc storage tối ưu
  function viewGoodStorage() external view returns (uint128, uint128) {
    return (smallA, smallB);
  }
}