contract TransparentUpgradeableProxy {
    bytes32 private constant _ADMIN_SLOT = 
        bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1);
    bytes32 private constant _IMPLEMENTATION_SLOT = 
        bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1);

    modifier ifAdmin() {
        require(msg.sender == _getAdmin(), "Transparent: chỉ admin");
        _;
    }

    function upgrade(address newImplementation) external ifAdmin {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    fallback() external payable {
        _delegate(_getImplementation());
    }
}

function _delegate(address implementation) internal {
    assembly {
        calldatacopy(0, 0, calldatasize())
        let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
        returndatacopy(0, 0, returndatasize())

        switch result
        case 0 { revert(0, returndatasize()) }
        default { return(0, returndatasize()) }
    }
}

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

contract MyContractV1 is UUPSUpgradeable, OwnableUpgradeable {
    uint256 public value;

    function initialize(uint256 _value) public initializer {
        __Ownable_init();
        __UUPSUpgradeable_init();
        value = _value;
    }

    function _authorizeUpgrade(address newImplementation) 
        internal 
        override 
        onlyOwner 
    {
        // Thêm logic xác thực nâng cấp tại đây
        require(newImplementation != address(0), "Thực thi không hợp lệ");
    }

    function setValue(uint256 _value) external {
        value = _value;
    }
}

contract Diamond {
    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }

    enum FacetCutAction { Add, Replace, Remove }

    mapping(bytes4 => address) internal selectorToFacet;

    function diamondCut(
        FacetCut[] memory _diamondCut,
        address _init,
        bytes memory _calldata
    ) external {
        for (uint256 i = 0; i < _diamondCut.length; i++) {
            if (_diamondCut[i].action == FacetCutAction.Add) {
                _addFunctions(_diamondCut[i].facetAddress, _diamondCut[i].functionSelectors);
            } else if (_diamondCut[i].action == FacetCutAction.Replace) {
                _replaceFunctions(_diamondCut[i].facetAddress, _diamondCut[i].functionSelectors);
            } else {
                _removeFunctions(_diamondCut[i].facetAddress, _diamondCut[i].functionSelectors);
            }
        }

        emit DiamondCut(_diamondCut, _init, _calldata);
    }
}

contract V1 {
    uint256 public a;  // ô 0
    uint256 public b;  // ô 1
}

contract V2 {
    uint256 public b;  // ô 0 - LÀM HỎNG DỮ LIỆU!
    uint256 public a;  // ô 1 - LÀM HỎNG DỮ LIỆU!
    uint256 public c;  // ô 2
}

contract V1 {
    uint256 public a;  // ô 0
    uint256 public b;  // ô 1
}

contract V2 {
    uint256 public a;  // ô 0 - vẫn giữ nguyên
    uint256 public b;  // ô 1 - vẫn giữ nguyên  
    uint256 public c;  // ô 2 - mới
}

contract MyContract {
    uint256 public value1;
    uint256 public value2;

    // Dự trữ các ô lưu trữ cho biến trong tương lai
    uint256[48] private __gap;
}

contract UpgradeTimelock {
    uint256 public constant DELAY = 2 days;
    mapping(bytes32 => bool) public queuedTransactions;

    function queueTransaction(
        address target,
        bytes memory data,
        uint256 eta
    ) external onlyAdmin returns (bytes32) {
        require(eta >= block.timestamp + DELAY, "Thời gian chưa đủ");

        bytes32 txHash = keccak256(abi.encode(target, data, eta));
        queuedTransactions[txHash] = true;

        return txHash;
    }
}

function executeTransaction(
    address target,
    bytes memory data,
    uint256 eta
) external onlyAdmin {
    bytes32 txHash = keccak256(abi.encode(target, data, eta));

    require(queuedTransactions[txHash], "Chưa được đưa vào hàng đợi");
    require(block.timestamp >= eta, "Quá sớm");

    (bool success,) = target.call(data);
    require(success, "Thi hành thất bại");

    delete queuedTransactions[txHash];
}

npm install @openzeppelin/contracts-upgradeable
npm install @openzeppelin/hardhat-upgrades

const { ethers, upgrades } = require("hardhat");

async function main() {
    const MyContract = await ethers.getContractFactory("MyContract");
    const proxy = await upgrades.deployProxy(MyContract, [42]);
    await proxy.deployed();

    console.log("Proxy đã được triển khai tại:", proxy.address);
}