Hướng dẫn chi tiết hợp đồng cầu nối tiêu chuẩn của Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Sự kiện *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Các hàm công khai *
     ********************/

    /**
     * @dev lấy Địa chỉ của hợp đồng cầu nối l2 tương ứng.
     * @return Địa chỉ của hợp đồng cầu nối l2 tương ứng.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev nạp một lượng ERC-20 vào số dư của người gọi trên l2.
     * @param _l1Token Địa chỉ của ERC-20 l1 mà chúng ta đang nạp
     * @param _l2Token Địa chỉ của ERC-20 l2 tương ứng với l1
     * @param _amount Số lượng ERC-20 cần nạp
     * @param _l2Gas Giới hạn Gas yêu cầu để hoàn thành việc nạp trên l2.
     * @param _data Dữ liệu tùy chọn để chuyển tiếp đến l2. Dữ liệu này được cung cấp
     *        chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *        độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev nạp một lượng ERC-20 vào số dư của người nhận trên l2.
     * @param _l1Token Địa chỉ của ERC-20 l1 mà chúng ta đang nạp
     * @param _l2Token Địa chỉ của ERC-20 l2 tương ứng với l1
     * @param _to Địa chỉ l2 để ghi có khoản rút tiền.
     * @param _amount Số lượng ERC-20 cần nạp.
     * @param _l2Gas Giới hạn Gas yêu cầu để hoàn thành việc nạp trên l2.
     * @param _data Dữ liệu tùy chọn để chuyển tiếp đến l2. Dữ liệu này được cung cấp
     *        chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *        độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Các hàm chéo chuỗi *
     *************************/

    /**
     * @dev Hoàn thành việc rút tiền từ l2 sang l1 và ghi có tiền vào số dư của người nhận đối với
     * token ERC-20 l1.
     * Lệnh gọi này sẽ thất bại nếu khoản rút tiền được khởi tạo từ l2 chưa được hoàn tất.
     *
     * @param _l1Token Địa chỉ của token l1 để finalizeWithdrawal.
     * @param _l2Token Địa chỉ của token l2 nơi khoản rút tiền được khởi tạo.
     * @param _from Địa chỉ l2 khởi tạo việc chuyển.
     * @param _to Địa chỉ l1 để ghi có khoản rút tiền.
     * @param _amount Số lượng ERC-20 cần nạp.
     * @param _data Dữ liệu được cung cấp bởi người gửi trên l2. Dữ liệu này được cung cấp
     *   chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *   độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function finalizeERC20Withdrawal(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >0.5.0 <0.9.0;

import "./IL1ERC20Bridge.sol";

/**
 * @title IL1StandardBridge
 */
interface IL1StandardBridge is IL1ERC20Bridge {
    /**********
     * Sự kiện *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Các hàm công khai *
     ********************/

    /**
     * @dev Nạp một lượng ETH vào số dư của người gọi trên l2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Nạp một lượng ETH vào số dư của người nhận trên l2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Các hàm chéo chuỗi *
     *************************/

    /**
     * @dev Hoàn thành việc rút tiền từ l2 sang l1 và ghi có tiền vào số dư của người nhận đối với
     * token ETH l1. Vì chỉ xDomainMessenger mới có thể gọi hàm này, nó sẽ không bao giờ được gọi
     * trước khi khoản rút tiền được hoàn tất.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Hợp đồng trợ giúp cho các hợp đồng thực hiện giao tiếp chéo miền
 *
 * Trình biên dịch được sử dụng: được xác định bởi hợp đồng kế thừa
 */
contract CrossDomainEnabled {
    /*************
     * Các biến *
     *************/

    // Hợp đồng Messenger được sử dụng để gửi và nhận thông điệp từ miền khác.
    address public messenger;

    /***************
     * Hàm khởi tạo *
     ***************/

    /**
     * @param _messenger Địa chỉ của CrossDomainMessenger trên lớp hiện tại.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Các modifier của hàm *
     **********************/

    /**
     * Bắt buộc rằng hàm được sửa đổi chỉ có thể được gọi bởi một tài khoản chéo miền cụ thể.
     * @param _sourceDomainAccount Tài khoản duy nhất trên miền gốc được
     *  xác thực để gọi hàm này.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Các hàm nội bộ *
     **********************/

    /**
     * Lấy messenger, thường là từ bộ nhớ. Hàm này được hiển thị trong trường hợp một hợp đồng con
     * cần ghi đè.
     * @return Địa chỉ của hợp đồng messenger chéo miền nên được sử dụng.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Gửi một thông điệp đến một tài khoản trên miền khác
     * @param _crossDomainTarget Người nhận dự kiến trên miền đích
     * @param _message Dữ liệu để gửi đến mục tiêu (thường là dữ liệu lệnh gọi đến một hàm có
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit Giới hạn Gas cho việc nhận thông điệp trên miền đích.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev Cầu nối ETH và ERC-20 l1 là một hợp đồng lưu trữ tiền l1 đã nạp và các token
 * tiêu chuẩn đang được sử dụng trên l2. Nó đồng bộ hóa một cầu nối l2 tương ứng, thông báo cho nó về các khoản nạp
 * và lắng nghe nó đối với các khoản rút tiền mới được hoàn tất.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Khởi tạo *
     ******************/

    /**
     * @param _l1messenger Địa chỉ Messenger l1 đang được sử dụng cho các giao tiếp chéo chuỗi.
     * @param _l2TokenBridge Địa chỉ cầu nối tiêu chuẩn l2.
     */
    // slither-disable-next-line external-function

    /**************
     * Nạp tiền *
     **************/

    /** @dev Modifier yêu cầu người gửi phải là EOA. Kiểm tra này có thể bị vượt qua bởi một hợp đồng
     *  độc hại thông qua initcode, nhưng nó xử lý lỗi người dùng mà chúng ta muốn tránh.
     */
    modifier onlyEOA() {
        // Được sử dụng để ngăn chặn việc nạp tiền từ các hợp đồng (tránh vô tình làm mất token)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Hàm này có thể được gọi mà không cần dữ liệu
     * để nạp một lượng ETH vào số dư của người gọi trên l2.
     * Vì hàm receive không nhận dữ liệu, một số lượng mặc định
     * thận trọng sẽ được chuyển tiếp đến l2.
     */
    receive() external payable onlyEOA {
        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
    }

    /**
     * @inheritdoc IL1StandardBridge
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
        _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
    }

    /**
     * @inheritdoc IL1StandardBridge
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable {
        _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
    }

    /**
     * @dev Thực hiện logic cho các khoản nạp bằng cách lưu trữ ETH và thông báo cho Cổng ETH l2 về
     * khoản nạp.
     * @param _from Tài khoản để kéo khoản nạp từ trên l1.
     * @param _to Tài khoản để cung cấp khoản nạp cho trên l2.
     * @param _l2Gas Giới hạn Gas yêu cầu để hoàn thành việc nạp trên l2.
     * @param _data Dữ liệu tùy chọn để chuyển tiếp đến l2. Dữ liệu này được cung cấp
     *        chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *        độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Xây dựng dữ liệu lệnh gọi cho lệnh gọi finalizeDeposit
        bytes memory message = abi.encodeWithSelector(

    /**
     * @inheritdoc IL1ERC20Bridge
     */
    function depositERC20(
		.
		.
		.
    ) external virtual onlyEOA {
        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
    }

    /**
     * @inheritdoc IL1ERC20Bridge
     */
    function depositERC20To(
		.
		.
		.
    ) external virtual {
        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
    }

    /**
     * @dev Thực hiện logic cho các khoản nạp bằng cách thông báo cho hợp đồng Token Đã nạp l2
     * về khoản nạp và gọi một trình xử lý để khóa tiền l1. (ví dụ: transferFrom)
     *
     * @param _l1Token Địa chỉ của ERC-20 l1 mà chúng ta đang nạp
     * @param _l2Token Địa chỉ của ERC-20 l2 tương ứng với l1
     * @param _from Tài khoản để kéo khoản nạp từ trên l1
     * @param _to Tài khoản để cung cấp khoản nạp cho trên l2
     * @param _amount Số lượng ERC-20 cần nạp.
     * @param _l2Gas Giới hạn Gas yêu cầu để hoàn thành việc nạp trên l2.
     * @param _data Dữ liệu tùy chọn để chuyển tiếp đến l2. Dữ liệu này được cung cấp
     *        chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *        độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Xây dựng dữ liệu lệnh gọi cho _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Gửi dữ liệu lệnh gọi vào l2
        // slither-disable-next-line reentrancy-events, reentrancy-benign
        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);

        // slither-disable-next-line reentrancy-benign
        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;

        // slither-disable-next-line reentrancy-events
        emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
    }

    /*************************
     * Các hàm chéo chuỗi *
     *************************/

    /**
     * @inheritdoc IL1StandardBridge
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data

    }

    /**
     * @inheritdoc IL1ERC20Bridge
     */
    function finalizeERC20Withdrawal(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external onlyFromCrossDomainAccount(l2TokenBridge) {

        // Khi một khoản rút tiền được hoàn tất trên l1, cầu nối l1 sẽ chuyển tiền cho người rút tiền
        // slither-disable-next-line reentrancy-events
        IERC20(_l1Token).safeTransfer(_to, _amount);

        // slither-disable-next-line reentrancy-events
        emit ERC20WithdrawalFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
    }


    /*****************************
     * Tạm thời - Di chuyển ETH *
     *****************************/

    /**
     * @dev Thêm số dư ETH vào tài khoản. Điều này nhằm cho phép ETH
     * được di chuyển từ một cổng cũ sang một cổng mới.
     * LƯU Ý: Điều này chỉ được giữ lại cho một lần nâng cấp để chúng ta có thể nhận được ETH đã di chuyển từ
     * hợp đồng cũ
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Địa chỉ của cầu nối tiêu chuẩn l2.
     * @param _l1Token Địa chỉ của token l1 tương ứng.
     * @param _name Tên ERC-20.
     * @param _symbol Ký hiệu ERC-20.
     */
    constructor(
        address _l2Bridge,
        address _l1Token,
        string memory _name,
        string memory _symbol
    ) ERC20(_name, _symbol) {
        l1Token = _l1Token;
        l2Bridge = _l2Bridge;
    }

    modifier onlyL2Bridge() {
        require(msg.sender == l2Bridge, "Only L2 Bridge can mint and burn");
        _;
    }


    // slither-disable-next-line external-function
    function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
        bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); // ERC165
        bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^
            IL2StandardERC20.mint.selector ^
            IL2StandardERC20.burn.selector;
        return _interfaceId == firstSupportedInterface || _interfaceId == secondSupportedInterface;
    }

    // slither-disable-next-line external-function
    function mint(address _to, uint256 _amount) public virtual onlyL2Bridge {
        _mint(_to, _amount);

        emit Mint(_to, _amount);
    }

    // slither-disable-next-line external-function
    function burn(address _from, uint256 _amount) public virtual onlyL2Bridge {
        _burn(_from, _amount);

        emit Burn(_from, _amount);
    }
}

/* Nhập thư viện */
import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";

/* Nhập hợp đồng */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev Cầu nối tiêu chuẩn l2 là một hợp đồng hoạt động cùng với cầu nối tiêu chuẩn l1 để
 * cho phép các quá trình chuyển đổi ETH và ERC-20 giữa l1 và l2.
 * Hợp đồng này hoạt động như một công cụ đúc cho các token mới khi nó nghe về các khoản nạp vào cầu nối tiêu chuẩn
 * l1.
 * Hợp đồng này cũng hoạt động như một công cụ đốt các token dự định để rút tiền, thông báo cho cầu nối
 * l1 để giải phóng tiền l1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Tham chiếu hợp đồng bên ngoài *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Hàm khởi tạo *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Messenger chéo miền được sử dụng bởi hợp đồng này.
     * @param _l1TokenBridge Địa chỉ của cầu nối l1 được triển khai trên chuỗi chính.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Rút tiền *
     ***************/

    /**
     * @inheritdoc IL2ERC20Bridge
     */
    function withdraw(
        address _l2Token,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) external virtual {
        _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
    }

    /**
     * @inheritdoc IL2ERC20Bridge
     */
    function withdrawTo(
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) external virtual {
        _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
    }

    /**
     * @dev Thực hiện logic cho các khoản rút tiền bằng cách đốt token và thông báo
     *      cho Cổng token l1 về khoản rút tiền.
     * @param _l2Token Địa chỉ của token l2 nơi khoản rút tiền được khởi tạo.
     * @param _from Tài khoản để kéo khoản rút tiền từ trên l2.
     * @param _to Tài khoản để cung cấp khoản rút tiền cho trên l1.
     * @param _amount Số lượng token cần rút.
     * @param _l1Gas Không được sử dụng, nhưng được bao gồm cho các cân nhắc tương thích chuyển tiếp tiềm năng.
     * @param _data Dữ liệu tùy chọn để chuyển tiếp đến l1. Dữ liệu này được cung cấp
     *        chỉ để tạo sự thuận tiện cho các hợp đồng bên ngoài. Ngoài việc bắt buộc
     *        độ dài tối đa, các hợp đồng này không cung cấp đảm bảo nào về nội dung của nó.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Khi một khoản rút tiền được khởi tạo, chúng ta đốt tiền của người rút tiền để ngăn chặn việc sử dụng l2
        // sau đó
        // slither-disable-next-line reentrancy-events
        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);

            message = abi.encodeWithSelector(
                IL1StandardBridge.finalizeETHWithdrawal.selector,
                _from,
                _to,
                _amount,
                _data
            );
        } else {
            message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                l1Token,
                _l2Token,
                _from,
                _to,
                _amount,
                _data
            );
        }

        // Gửi thông điệp lên cầu nối l1
        // slither-disable-next-line reentrancy-events
        sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);

        // slither-disable-next-line reentrancy-events
        emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);
    }

    /************************************
     * Hàm chéo chuỗi: Nạp tiền *
     ************************************/

    /**
     * @inheritdoc IL2ERC20Bridge
     */
    function finalizeDeposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data

        } else {
            // Hoặc token l2 đang được nạp vào không đồng ý về Địa chỉ chính xác
            // của token l1 của nó, hoặc không hỗ trợ giao diện chính xác.
            // Điều này chỉ nên xảy ra nếu có một token l2 độc hại, hoặc nếu một người dùng bằng cách nào đó
            // đã chỉ định sai Địa chỉ token l2 để nạp vào.
            // Trong cả hai trường hợp, chúng ta dừng quá trình ở đây và xây dựng một
            // thông điệp rút tiền để người dùng có thể lấy tiền của họ ra trong một số trường hợp.
            // Không có cách nào để ngăn chặn hoàn toàn các hợp đồng token độc hại, nhưng điều này giới hạn
            // lỗi người dùng và giảm thiểu một số hình thức hành vi hợp đồng độc hại.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // đã chuyển đổi _to và _from ở đây để trả lại khoản nạp cho người gửi
                _from,
                _amount,
                _data
            );

            // Gửi thông điệp lên cầu nối l1
            // slither-disable-next-line reentrancy-events
            sendCrossDomainMessage(l1TokenBridge, 0, message);
            // slither-disable-next-line reentrancy-events
            emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
        }
    }
}