Panduan kontrak jembatan standar Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Peristiwa *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Fungsi Publik *
     ********************/

    /**
     * @dev dapatkan alamat dari kontrak jembatan l2 yang sesuai.
     * @return Alamat dari kontrak jembatan l2 yang sesuai.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev depositkan sejumlah ERC-20 ke saldo pemanggil di l2.
     * @param _l1Token Alamat dari ERC-20 l1 yang kita depositkan
     * @param _l2Token Alamat dari ERC-20 l2 yang sesuai dengan l1
     * @param _amount Jumlah ERC-20 yang akan didepositkan
     * @param _l2Gas Batas gas yang diwajibkan untuk menyelesaikan deposit di l2.
     * @param _data Data opsional untuk diteruskan ke l2. Data ini disediakan
     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *        kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev depositkan sejumlah ERC-20 ke saldo penerima di l2.
     * @param _l1Token Alamat dari ERC-20 l1 yang kita depositkan
     * @param _l2Token Alamat dari ERC-20 l2 yang sesuai dengan l1
     * @param _to alamat l2 untuk mengkreditkan penarikan.
     * @param _amount Jumlah ERC-20 yang akan didepositkan.
     * @param _l2Gas Batas gas yang diwajibkan untuk menyelesaikan deposit di l2.
     * @param _data Data opsional untuk diteruskan ke l2. Data ini disediakan
     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *        kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Fungsi Lintas Rantai *
     *************************/

    /**
     * @dev Selesaikan penarikan dari l2 ke l1, dan kreditkan dana ke saldo penerima dari
     * token ERC-20 l1.
     * Panggilan ini akan gagal jika penarikan yang diinisialisasi dari l2 belum diselesaikan.
     *
     * @param _l1Token Alamat token l1 untuk finalizeWithdrawal.
     * @param _l2Token Alamat token l2 tempat penarikan diinisialisasi.
     * @param _from alamat l2 yang menginisialisasi transfer.
     * @param _to alamat l1 untuk mengkreditkan penarikan.
     * @param _amount Jumlah ERC-20 yang akan didepositkan.
     * @param _data Data yang disediakan oleh pengirim di l2. Data ini disediakan
     *   semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *   kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    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 {
    /**********
     * Peristiwa *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Fungsi Publik *
     ********************/

    /**
     * @dev Depositkan sejumlah ETH ke saldo pemanggil di l2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Depositkan sejumlah ETH ke saldo penerima di l2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Fungsi Lintas Rantai *
     *************************/

    /**
     * @dev Selesaikan penarikan dari l2 ke l1, dan kreditkan dana ke saldo penerima dari
     * token ETH l1. Karena hanya xDomainMessenger yang dapat memanggil fungsi ini, fungsi ini tidak akan pernah dipanggil
     * sebelum penarikan diselesaikan.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Kontrak pembantu untuk kontrak yang melakukan komunikasi lintas domain
 *
 * Kompilator yang digunakan: ditentukan oleh kontrak yang mewarisi
 */
contract CrossDomainEnabled {
    /*************
     * Variabel *
     *************/

    // Kontrak utusan yang digunakan untuk mengirim dan menerima pesan dari domain lain.
    address public messenger;

    /***************
     * Konstruktor *
     ***************/

    /**
     * @param _messenger Alamat dari CrossDomainMessenger di lapisan saat ini.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Pengubah Fungsi *
     **********************/

    /**
     * Mewajibkan bahwa fungsi yang diubah hanya dapat dipanggil oleh akun lintas domain tertentu.
     * @param _sourceDomainAccount Satu-satunya akun di domain asal yang
     *  diautentikasi untuk memanggil fungsi ini.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Fungsi Internal *
     **********************/

    /**
     * Mendapatkan utusan, biasanya dari penyimpanan. Fungsi ini diekspos jika kontrak anak
     * perlu menimpanya.
     * @return Alamat dari kontrak utusan lintas domain yang harus digunakan.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Mengirim pesan ke akun di domain lain
     * @param _crossDomainTarget Penerima yang dituju di domain tujuan
     * @param _message Data yang akan dikirim ke target (biasanya data panggilan ke fungsi dengan
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit Batas gas untuk penerimaan pesan di domain target.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev Jembatan ETH dan ERC-20 l1 adalah kontrak yang menyimpan dana l1 yang didepositkan dan standar
 * token yang digunakan di l2. Ini menyinkronkan jembatan l2 yang sesuai, menginformasikannya tentang deposit
 * dan mendengarkannya untuk penarikan yang baru saja diselesaikan.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inisialisasi *
     ******************/

    /**
     * @param _l1messenger Alamat Utusan l1 yang digunakan untuk komunikasi lintas rantai.
     * @param _l2TokenBridge Alamat jembatan standar l2.
     */
    // slither-disable-next-line external-function

    /**************
     * Mendepositkan *
     **************/

    /** @dev Pengubah yang mewajibkan pengirim adalah EOA.  Pemeriksaan ini dapat dilewati oleh kontrak
     *  berbahaya melalui initcode, tetapi ini menangani kesalahan pengguna yang ingin kita hindari.
     */
    modifier onlyEOA() {
        // Digunakan untuk menghentikan deposit dari kontrak (menghindari token yang hilang secara tidak sengaja)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Fungsi ini dapat dipanggil tanpa data
     * untuk mendepositkan sejumlah ETH ke saldo pemanggil di l2.
     * Karena fungsi receive tidak menerima data, jumlah
     * bawaan yang konservatif diteruskan ke 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 Melakukan logika untuk deposit dengan menyimpan ETH dan menginformasikan Gateway ETH l2 tentang
     * deposit tersebut.
     * @param _from Akun untuk menarik deposit dari l1.
     * @param _to Akun untuk memberikan deposit di l2.
     * @param _l2Gas Batas gas yang diwajibkan untuk menyelesaikan deposit di l2.
     * @param _data Data opsional untuk diteruskan ke l2. Data ini disediakan
     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *        kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Bangun data panggilan untuk panggilan 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 Melakukan logika untuk deposit dengan menginformasikan kontrak Token yang Didepositkan l2
     * tentang deposit tersebut dan memanggil penangan untuk mengunci dana l1. (misalnya, transferFrom)
     *
     * @param _l1Token Alamat dari ERC-20 l1 yang kita depositkan
     * @param _l2Token Alamat dari ERC-20 l2 yang sesuai dengan l1
     * @param _from Akun untuk menarik deposit dari l1
     * @param _to Akun untuk memberikan deposit di l2
     * @param _amount Jumlah ERC-20 yang akan didepositkan.
     * @param _l2Gas Batas gas yang diwajibkan untuk menyelesaikan deposit di l2.
     * @param _data Data opsional untuk diteruskan ke l2. Data ini disediakan
     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *        kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Bangun data panggilan untuk _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Kirim data panggilan ke 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);
    }

    /*************************
     * Fungsi Lintas Rantai *
     *************************/

    /**
     * @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) {

        // Ketika penarikan diselesaikan di l1, jembatan l1 mentransfer dana ke penarik
        // 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);
    }


    /*****************************
     * Sementara - Memigrasikan ETH *
     *****************************/

    /**
     * @dev Menambahkan saldo ETH ke akun. Ini dimaksudkan untuk memungkinkan ETH
     * dimigrasikan dari gateway lama ke gateway baru.
     * CATATAN: Ini dibiarkan hanya untuk satu peningkatan sehingga kita dapat menerima ETH yang dimigrasikan dari
     * kontrak lama
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Alamat dari jembatan standar l2.
     * @param _l1Token Alamat dari token l1 yang sesuai.
     * @param _name Nama ERC-20.
     * @param _symbol Simbol 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);
    }
}

/* Impor Pustaka */
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";

/* Impor Kontrak */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev Jembatan Standar l2 adalah kontrak yang bekerja sama dengan jembatan Standar l1 untuk
 * memungkinkan transisi ETH dan ERC-20 antara l1 dan l2.
 * Kontrak ini bertindak sebagai pencetak untuk token baru ketika mendengar tentang deposit ke jembatan Standar
 * l1.
 * Kontrak ini juga bertindak sebagai pembakar token yang ditujukan untuk penarikan, menginformasikan jembatan
 * l1 untuk melepaskan dana l1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Referensi Kontrak Eksternal *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Konstruktor *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Utusan lintas domain yang digunakan oleh kontrak ini.
     * @param _l1TokenBridge Alamat jembatan l1 yang disebarkan ke rantai utama.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Menarik *
     ***************/

    /**
     * @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 Melakukan logika untuk penarikan dengan membakar token dan menginformasikan
     *      Gateway token l1 tentang penarikan tersebut.
     * @param _l2Token Alamat token l2 tempat penarikan diinisialisasi.
     * @param _from Akun untuk menarik penarikan dari l2.
     * @param _to Akun untuk memberikan penarikan di l1.
     * @param _amount Jumlah token yang akan ditarik.
     * @param _l1Gas Tidak digunakan, tetapi disertakan untuk pertimbangan kompatibilitas ke depan yang potensial.
     * @param _data Data opsional untuk diteruskan ke l1. Data ini disediakan
     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain mewajibkan panjang maksimum,
     *        kontrak ini tidak memberikan jaminan tentang kontennya.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Ketika penarikan diinisialisasi, kami membakar dana penarik untuk mencegah l2 berikutnya
        // penggunaan
        // 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
            );
        }

        // Kirim pesan ke jembatan 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);
    }

    /************************************
     * Fungsi Lintas Rantai: Mendepositkan *
     ************************************/

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

        } else {
            // Entah token l2 yang sedang didepositkan tidak setuju tentang alamat yang benar
            // dari token l1-nya, atau tidak mendukung antarmuka yang benar.
            // Ini seharusnya hanya terjadi jika ada token l2 yang berbahaya, atau jika pengguna entah bagaimana
            // menentukan alamat token l2 yang salah untuk didepositkan.
            // Dalam kedua kasus tersebut, kami menghentikan proses di sini dan membangun penarikan
            // pesan sehingga pengguna dapat mengeluarkan dana mereka dalam beberapa kasus.
            // Tidak ada cara untuk mencegah kontrak token berbahaya sama sekali, tetapi ini membatasi
            // kesalahan pengguna dan memitigasi beberapa bentuk perilaku kontrak yang berbahaya.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // menukar _to dan _from di sini untuk memantulkan kembali deposit ke pengirim
                _from,
                _amount,
                _data
            );

            // Kirim pesan ke jembatan 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);
        }
    }
}