Panduan kontrak jembatan standar Optimism

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
Salin

1pragma solidity >0.5.0 <0.9.0;
Salin

1/**
2 * @title IL1ERC20Bridge
3 */
4interface IL1ERC20Bridge {
5    /* *********
6     * Event *
7     ********* */
8    /**********
9     * Events *
10     **********/
11
12    event ERC20DepositInitiated(
Tampilkan semuaSalin

1        address indexed _l1Token,
2        address indexed _l2Token,
Salin

1        address indexed _from,
2        address _to,
3        uint256 _amount,
4        bytes _data
5    );
Salin

1    event ERC20WithdrawalFinalized(
2        address indexed _l1Token,
3        address indexed _l2Token,
4        address indexed _from,
5        address _to,
6        uint256 _amount,
7        bytes _data
8    );
Salin

1
2    /* *******************
3     * Fungsi Publik *
4     ******************* */
5    /********************
6     * Public Functions *
7     ********************/
8
9    /**
10     * @dev mendapatkan alamat dari kontrak jembatan L2 yang sesuai.
11     * @return Alamat dari kontrak jembatan L2 yang sesuai.
12     */
13    function l2TokenBridge() external returns (address);
Tampilkan semuaSalin

1    /**
2     * @dev mendepositkan sejumlah ERC20 ke saldo pemanggil di L2.
3     * @param _l1Token Alamat ERC20 L1 yang kita depositkan
4     * @param _l2Token Alamat ERC20 L2 yang masing-masing dari L1
5     * @param _amount Jumlah ERC20 yang akan didepositkan
6     * @param _l2Gas Batas gas yang diperlukan untuk menyelesaikan deposit di L2.
7     * @param _data Data opsional untuk diteruskan ke L2. Data ini disediakan
8     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
9     *        panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
10     */
11    function depositERC20(
12        address _l1Token,
13        address _l2Token,
14        uint256 _amount,
15        uint32 _l2Gas,
16        bytes calldata _data
17    ) external;
Tampilkan semuaSalin

1    /**
2     * @dev mendepositkan sejumlah ERC20 ke saldo penerima di L2.
3     * @param _l1Token Alamat ERC20 L1 yang kita depositkan
4     * @param _l2Token Alamat ERC20 L2 yang masing-masing dari L1
5     * @param _to Alamat L2 untuk mengkreditkan penarikan.
6     * @param _amount Jumlah ERC20 yang akan didepositkan.
7     * @param _l2Gas Batas gas yang diperlukan untuk menyelesaikan deposit di L2.
8     * @param _data Data opsional untuk diteruskan ke L2. Data ini disediakan
9     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
10     *        panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
11     */
12    function depositERC20To(
13        address _l1Token,
14        address _l2Token,
15        address _to,
16        uint256 _amount,
17        uint32 _l2Gas,
18        bytes calldata _data
19    ) external;
Tampilkan semuaSalin

1    /* ************************
2     * Fungsi Lintas-rantai *
3     ************************ */
4    /*************************
5     * Cross-chain Functions *
6     *************************/
7
8    /**
9     * @dev Menyelesaikan penarikan dari L2 ke L1, dan mengkreditkan dana ke saldo penerima dari
10     * token ERC20 L1.
11     * Panggilan ini akan gagal jika penarikan yang diinisialisasi dari L2 belum diselesaikan.
12     *
13     * @param _l1Token Alamat token L1 untuk finalizeWithdrawal.
14     * @param _l2Token Alamat token L2 tempat penarikan diinisiasi.
15     * @param _from Alamat L2 yang menginisiasi transfer.
16     * @param _to Alamat L1 untuk mengkreditkan penarikan.
17     * @param _amount Jumlah ERC20 yang akan didepositkan.
18     * @param _data Data yang disediakan oleh pengirim di L2. Data ini disediakan
19     *   semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
20     *   panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
21     */
22    function finalizeERC20Withdrawal(
23        address _l1Token,
24        address _l2Token,
25        address _from,
26        address _to,
27        uint256 _amount,
28        bytes calldata _data
29    ) external;
30}
Tampilkan semuaSalin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4import "./IL1ERC20Bridge.sol";
5
6/**
7 * @title IL1StandardBridge
8 */
9interface IL1StandardBridge is IL1ERC20Bridge {
10    /* *********
11     * Event *
12     ********* */
13    /**********
14     * Events *
15     **********/
16    event ETHDepositInitiated(
17        address indexed _from,
18        address indexed _to,
19        uint256 _amount,
20        bytes _data
21    );
Tampilkan semuaSalin

1    event ETHWithdrawalFinalized(
2        .
3        .
4        .
5    );
6
7    /* *******************
8     * Fungsi Publik *
9     ******************* */
10    /********************
11     * Public Functions *
12     ********************/
13
14    /**
15     * @dev Mendepositkan sejumlah ETH ke saldo pemanggil di L2.
16            .
17            .
18            .
19     */
20    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
21
22    /**
23     * @dev Mendepositkan sejumlah ETH ke saldo penerima di L2.
24            .
25            .
26            .
27     */
28    function depositETHTo(
29        address _to,
30        uint32 _l2Gas,
31        bytes calldata _data
32    ) external payable;
33
34    /* ************************
35     * Fungsi Lintas-rantai *
36     ************************ */
37    /*************************
38     * Cross-chain Functions *
39     *************************/
40
41    /**
42     * @dev Menyelesaikan penarikan dari L2 ke L1, dan mengkreditkan dana ke saldo penerima dari
43     * token ETH L1. Karena hanya xDomainMessenger yang dapat memanggil fungsi ini, fungsi ini tidak akan pernah dipanggil
44     * sebelum penarikan diselesaikan.
45                .
46                .
47                .
48     */
49    function finalizeETHWithdrawal(
50        address _from,
51        address _to,
52        uint256 _amount,
53        bytes calldata _data
54    ) external;
55}
Tampilkan semuaSalin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4/* Impor Antarmuka */
5/* Interface Imports */
6import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
Salin

1/**
2 * @title CrossDomainEnabled
3 * @dev Kontrak pembantu untuk kontrak yang melakukan komunikasi lintas-domain
4 *
5 * Kompiler yang digunakan: ditentukan oleh kontrak yang mewarisi
6 */
7contract CrossDomainEnabled {
8    /* ************
9     * Variabel *
10     ************ */
11    /*************
12     * Variables *
13     *************/
14
15    // Messenger contract used to send and receive messages from the other domain. // Kontrak Messenger yang digunakan untuk mengirim dan menerima pesan dari domain lain.
16    address public messenger;
17
18    /* **************
19     * Konstruktor *
20     ************** */
21    /***************
22     * Constructor *
23     ***************/
24
25    /**
26     * @param _messenger Alamat CrossDomainMessenger di lapisan saat ini.
27     */
28    constructor(address _messenger) {
29        messenger = _messenger;
30    }
Tampilkan semuaSalin

1
2    /* *********************
3     * Pengubah Fungsi *
4     ********************* */
5    /**********************
6     * Function Modifiers *
7     **********************/
8
9    /**
10     * Menegakkan bahwa fungsi yang diubah hanya dapat dipanggil oleh akun lintas-domain tertentu.
11     * @param _sourceDomainAccount Satu-satunya akun di domain asal yang
12     *  diautentikasi untuk memanggil fungsi ini.
13     */
14    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
Tampilkan semuaSalin

1        require(
2            msg.sender == address(getCrossDomainMessenger()),
3            "OVM_XCHAIN: messenger contract unauthenticated"
4        );
Salin

1
2        require(
3            getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
4            "OVM_XCHAIN: wrong sender of cross-domain message"
5        );
Salin

1
2        _;
3    }
4
5    /* *********************
6     * Fungsi Internal *
7     ********************* */
8    /**********************
9     * Internal Functions *
10     **********************/
11
12    /**
13     * Mendapatkan messenger, biasanya dari penyimpanan. Fungsi ini diekspos jika kontrak anak
14     * perlu menimpanya.
15     * @return Alamat kontrak messenger lintas-domain yang harus digunakan.
16     */
17    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
18        return ICrossDomainMessenger(messenger);
19    }
Tampilkan semuaSalin

1
2    /**
3     * Mengirim pesan ke akun di domain lain
4     * @param _crossDomainTarget Penerima yang dituju di domain tujuan
5     * @param _message Data yang akan dikirim ke target (biasanya calldata ke fungsi dengan
6     *  `onlyFromCrossDomainAccount()`)
7     * @param _gasLimit Batas gas untuk penerimaan pesan di domain tujuan.
8     */
9    function sendCrossDomainMessage(
10        address _crossDomainTarget,
11        uint32 _gasLimit,
12        bytes memory _message
Tampilkan semuaSalin

1    ) internal {
2        // slither-disable-next-line reentrancy-events, reentrancy-benign // slither-disable-next-line reentrancy-events, reentrancy-benign
Salin

1        getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
2    }
3}
Salin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
Salin

1/* Impor Antarmuka */
2/* Interface Imports */
3import { IL1StandardBridge } from "./IL1StandardBridge.sol";
4import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
Salin

1import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
Salin

1import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
Salin

1/* Impor Pustaka */
2/* Library Imports */
3import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
Salin

1import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
Salin

1import { Address } from "@openzeppelin/contracts/utils/Address.sol";
Salin

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

1/**
2 * @title L1StandardBridge
3 * @dev Jembatan ETH dan ERC20 L1 adalah kontrak yang menyimpan dana L1 yang didepositkan dan token
4 * standar yang digunakan di L2. Ini menyinkronkan jembatan L2 yang sesuai, menginformasikannya tentang deposit
5 * dan mendengarkannya untuk penarikan yang baru saja diselesaikan.
6 *
7 */
8contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
9    using SafeERC20 for IERC20;
Tampilkan semuaSalin

1
2    /* *******************************
3     * Referensi Kontrak Eksternal *
4     ******************************* */
5    /********************************
6     * External Contract References *
7     ********************************/
8
9    address public l2TokenBridge;
Tampilkan semuaSalin

1
2    // Maps L1 token to L2 token to balance of the L1 token deposited // Memetakan token L1 ke token L2 ke saldo token L1 yang didepositkan
3    mapping(address => mapping(address => uint256)) public deposits;
Salin

1
2    /* **************
3     * Konstruktor *
4     ************** */
5    /***************
6     * Constructor *
7     ***************/
8
9    // This contract lives behind a proxy, so the constructor parameters will go unused. // Kontrak ini berada di balik proxy, sehingga parameter konstruktor tidak akan digunakan.
10    constructor() CrossDomainEnabled(address(0)) {}
Tampilkan semuaSalin

1    /* *****************
2     * Inisialisasi *
3     ***************** */
4    /******************
5     * Initialization *
6     ******************/
7
8    /**
9     * @param _l1messenger Alamat Messenger L1 yang digunakan untuk komunikasi lintas-rantai.
10     * @param _l2TokenBridge Alamat jembatan standar L2.
11     */
12    // slither-disable-next-line external-function // slither-disable-next-line external-function
Tampilkan semuaSalin

1    function initialize(address _l1messenger, address _l2TokenBridge) public {
2        require(messenger == address(0), "Contract has already been initialized.");
Salin

1        messenger = _l1messenger;
2        l2TokenBridge = _l2TokenBridge;
3    }
Salin

1
2    /* *************
3     * Mendepositkan *
4     ************* */
5    /**************
6     * Depositing *
7     **************/
8
9    /** @dev Pengubah yang mengharuskan pengirim adalah EOA. Pemeriksaan ini dapat dilewati oleh kontrak
10     *  berbahaya melalui initcode, tetapi ini menangani kesalahan pengguna yang ingin kita hindari.
11     */
12    modifier onlyEOA() {
13        // Used to stop deposits from contracts (avoid accidentally lost tokens) // Digunakan untuk menghentikan deposit dari kontrak (menghindari token hilang secara tidak sengaja)
14        require(!Address.isContract(msg.sender), "Account not EOA");
15        _;
16    }
Tampilkan semuaSalin

1    /**
2     * @dev Fungsi ini dapat dipanggil tanpa data
3     * untuk mendepositkan sejumlah ETH ke saldo pemanggil di L2.
4     * Karena fungsi receive tidak menerima data, jumlah default
5     * yang konservatif diteruskan ke L2.
6     */
7    receive() external payable onlyEOA {
8        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
9    }
Tampilkan semuaSalin

1    /**
2     * @inheritdoc IL1StandardBridge
3     */
4    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
5        _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
6    }
7
8    /**
9     * @inheritdoc IL1StandardBridge
10     */
11    function depositETHTo(
12        address _to,
13        uint32 _l2Gas,
14        bytes calldata _data
15    ) external payable {
16        _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
17    }
Tampilkan semuaSalin

1    /**
2     * @dev Melakukan logika untuk deposit dengan menyimpan ETH dan menginformasikan Gateway ETH L2 tentang
3     * deposit tersebut.
4     * @param _from Akun untuk menarik deposit di L1.
5     * @param _to Akun untuk memberikan deposit di L2.
6     * @param _l2Gas Batas gas yang diperlukan untuk menyelesaikan deposit di L2.
7     * @param _data Data opsional untuk diteruskan ke L2. Data ini disediakan
8     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
9     *        panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
10     */
11    function _initiateETHDeposit(
12        address _from,
13        address _to,
14        uint32 _l2Gas,
15        bytes memory _data
16    ) internal {
17        // Construct calldata for finalizeDeposit call // Membangun calldata untuk panggilan finalizeDeposit
18        bytes memory message = abi.encodeWithSelector(
Tampilkan semuaSalin

1            IL2ERC20Bridge.finalizeDeposit.selector,
2            address(0),
3            Lib_PredeployAddresses.OVM_ETH,
4            _from,
5            _to,
6            msg.value,
7            _data
8        );
Salin

1        // Send calldata into L2 // Mengirim calldata ke L2
2        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
3        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
Salin

1        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
2        emit ETHDepositInitiated(_from, _to, msg.value, _data);
3    }
Salin

1    /**
2     * @inheritdoc IL1ERC20Bridge
3     */
4    function depositERC20(
5		.
6		.
7		.
8    ) external virtual onlyEOA {
9        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
10    }
11
12    /**
13     * @inheritdoc IL1ERC20Bridge
14     */
15    function depositERC20To(
16		.
17		.
18		.
19    ) external virtual {
20        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
21    }
Tampilkan semuaSalin

1    /**
2     * @dev Melakukan logika untuk deposit dengan menginformasikan kontrak Token yang Didepositkan L2
3     * tentang deposit tersebut dan memanggil penangan untuk mengunci dana L1. (misalnya, transferFrom)
4     *
5     * @param _l1Token Alamat ERC20 L1 yang kita depositkan
6     * @param _l2Token Alamat ERC20 L2 yang masing-masing dari L1
7     * @param _from Akun untuk menarik deposit di L1
8     * @param _to Akun untuk memberikan deposit di L2
9     * @param _amount Jumlah ERC20 yang akan didepositkan.
10     * @param _l2Gas Batas gas yang diperlukan untuk menyelesaikan deposit di L2.
11     * @param _data Data opsional untuk diteruskan ke L2. Data ini disediakan
12     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
13     *        panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
14     */
15    function _initiateERC20Deposit(
16        address _l1Token,
17        address _l2Token,
18        address _from,
19        address _to,
20        uint256 _amount,
21        uint32 _l2Gas,
22        bytes calldata _data
23    ) internal {
Tampilkan semuaSalin

1        // When a deposit is initiated on L1, the L1 Bridge transfers the funds to itself for future // Ketika deposit diinisiasi di L1, Jembatan L1 mentransfer dana ke dirinya sendiri untuk
2        // withdrawals. safeTransferFrom also checks if the contract has code, so this will fail if // penarikan di masa mendatang. safeTransferFrom juga memeriksa apakah kontrak memiliki kode, sehingga ini akan gagal jika
3        // _from is an EOA or address(0). // _from adalah EOA atau address(0).
4        // slither-disable-next-line reentrancy-events, reentrancy-benign // slither-disable-next-line reentrancy-events, reentrancy-benign
5        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
Salin

1        // Construct calldata for _l2Token.finalizeDeposit(_to, _amount) // Membangun calldata untuk _l2Token.finalizeDeposit(_to, _amount)
2        bytes memory message = abi.encodeWithSelector(
3            IL2ERC20Bridge.finalizeDeposit.selector,
4            _l1Token,
5            _l2Token,
6            _from,
7            _to,
8            _amount,
9            _data
10        );
11
12        // Send calldata into L2 // Mengirim calldata ke L2
13        // slither-disable-next-line reentrancy-events, reentrancy-benign // slither-disable-next-line reentrancy-events, reentrancy-benign
14        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
15
16        // slither-disable-next-line reentrancy-benign // slither-disable-next-line reentrancy-benign
17        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
Tampilkan semuaSalin

1
2        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
3        emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
4    }
5
6    /* ************************
7     * Fungsi Lintas-rantai *
8     ************************ */
9    /*************************
10     * Cross-chain Functions *
11     *************************/
12
13    /**
14     * @inheritdoc IL1StandardBridge
15     */
16    function finalizeETHWithdrawal(
17        address _from,
18        address _to,
19        uint256 _amount,
20        bytes calldata _data
Tampilkan semuaSalin

1    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
Salin

1        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
2        (bool success, ) = _to.call{ value: _amount }(new bytes(0));
Salin

1        require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
2
3        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
4        emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
Salin

1    }
2
3    /**
4     * @inheritdoc IL1ERC20Bridge
5     */
6    function finalizeERC20Withdrawal(
7        address _l1Token,
8        address _l2Token,
9        address _from,
10        address _to,
11        uint256 _amount,
12        bytes calldata _data
13    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
Tampilkan semuaSalin

1        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
Salin

1
2        // When a withdrawal is finalized on L1, the L1 Bridge transfers the funds to the withdrawer // Ketika penarikan diselesaikan di L1, Jembatan L1 mentransfer dana ke penarik
3        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
4        IERC20(_l1Token).safeTransfer(_to, _amount);
5
6        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
7        emit ERC20WithdrawalFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
8    }
9
10
11    /* ****************************
12     * Sementara - Migrasi ETH *
13     **************************** */
14    /*****************************
15     * Temporary - Migrating ETH *
16     *****************************/
17
18    /**
19     * @dev Menambahkan saldo ETH ke akun. Ini dimaksudkan untuk memungkinkan ETH
20     * dimigrasikan dari gateway lama ke gateway baru.
21     * CATATAN: Ini dibiarkan hanya untuk satu peningkatan sehingga kita dapat menerima ETH yang dimigrasikan dari
22     * kontrak lama
23     */
24    function donateETH() external payable {}
25}
Tampilkan semuaSalin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
Salin

1import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
Salin

1interface IL2StandardERC20 is IERC20, IERC165 {
2    function l1Token() external returns (address);
Salin

1
2    function mint(address _to, uint256 _amount) external;
3
4    function burn(address _from, uint256 _amount) external;
5
6    event Mint(address indexed _account, uint256 _amount);
7    event Burn(address indexed _account, uint256 _amount);
8}
Salin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
Salin

1import "./IL2StandardERC20.sol";
2
3contract L2StandardERC20 is IL2StandardERC20, ERC20 {
4    address public l1Token;
5    address public l2Bridge;
Salin

1
2    /**
3     * @param _l2Bridge Alamat jembatan standar L2.
4     * @param _l1Token Alamat token L1 yang sesuai.
5     * @param _name Nama ERC20.
6     * @param _symbol Simbol ERC20.
7     */
8    constructor(
9        address _l2Bridge,
10        address _l1Token,
11        string memory _name,
12        string memory _symbol
13    ) ERC20(_name, _symbol) {
14        l1Token = _l1Token;
15        l2Bridge = _l2Bridge;
16    }
Tampilkan semuaSalin

1
2    modifier onlyL2Bridge() {
3        require(msg.sender == l2Bridge, "Only L2 Bridge can mint and burn");
4        _;
5    }
6
7
8    // slither-disable-next-line external-function // slither-disable-next-line external-function
9    function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
10        bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); // ERC165 // ERC165
11        bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^
12            IL2StandardERC20.mint.selector ^
13            IL2StandardERC20.burn.selector;
14        return _interfaceId == firstSupportedInterface || _interfaceId == secondSupportedInterface;
15    }
Tampilkan semuaSalin

1    // slither-disable-next-line external-function // slither-disable-next-line external-function
2    function mint(address _to, uint256 _amount) public virtual onlyL2Bridge {
3        _mint(_to, _amount);
4
5        emit Mint(_to, _amount);
6    }
7
8    // slither-disable-next-line external-function // slither-disable-next-line external-function
9    function burn(address _from, uint256 _amount) public virtual onlyL2Bridge {
10        _burn(_from, _amount);
11
12        emit Burn(_from, _amount);
13    }
14}
Tampilkan semuaSalin

1// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4/* Impor Antarmuka */
5/* Interface Imports */
6import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
7import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
8import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
Salin

1/* Impor Pustaka */
2/* Library Imports */
3import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
4import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
5import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
6
7/* Impor Kontrak */
8/* Contract Imports */
9import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
10
11/**
12 * @title L2StandardBridge
13 * @dev Jembatan Standar L2 adalah kontrak yang bekerja sama dengan jembatan Standar L1 untuk
14 * memungkinkan transisi ETH dan ERC20 antara L1 dan L2.
15 * Kontrak ini bertindak sebagai minter untuk token baru ketika mendengar tentang deposit ke jembatan
16 * Standar L1.
17 * Kontrak ini juga bertindak sebagai pembakar token yang ditujukan untuk penarikan, menginformasikan jembatan
18 * L1 untuk melepaskan dana L1.
19 */
20contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
21    /* *******************************
22     * Referensi Kontrak Eksternal *
23     ******************************* */
24    /********************************
25     * External Contract References *
26     ********************************/
27
28    address public l1TokenBridge;
Tampilkan semuaSalin

1
2    /* **************
3     * Konstruktor *
4     ************** */
5    /***************
6     * Constructor *
7     ***************/
8
9    /**
10     * @param _l2CrossDomainMessenger Messenger lintas-domain yang digunakan oleh kontrak ini.
11     * @param _l1TokenBridge Alamat jembatan L1 yang disebarkan ke rantai utama.
12     */
13    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
14        CrossDomainEnabled(_l2CrossDomainMessenger)
15    {
16        l1TokenBridge = _l1TokenBridge;
17    }
18
19    /* **************
20     * Penarikan *
21     ************** */
22    /***************
23     * Withdrawing *
24     ***************/
25
26    /**
27     * @inheritdoc IL2ERC20Bridge
28     */
29    function withdraw(
30        address _l2Token,
31        uint256 _amount,
32        uint32 _l1Gas,
33        bytes calldata _data
34    ) external virtual {
35        _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
36    }
37
38    /**
39     * @inheritdoc IL2ERC20Bridge
40     */
41    function withdrawTo(
42        address _l2Token,
43        address _to,
44        uint256 _amount,
45        uint32 _l1Gas,
46        bytes calldata _data
47    ) external virtual {
48        _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
49    }
Tampilkan semuaSalin

1
2    /**
3     * @dev Melakukan logika untuk penarikan dengan membakar token dan menginformasikan
4     *      Gateway token L1 tentang penarikan tersebut.
5     * @param _l2Token Alamat token L2 tempat penarikan diinisiasi.
6     * @param _from Akun untuk menarik penarikan di L2.
7     * @param _to Akun untuk memberikan penarikan di L1.
8     * @param _amount Jumlah token yang akan ditarik.
9     * @param _l1Gas Tidak digunakan, tetapi disertakan untuk pertimbangan kompatibilitas ke depan yang potensial.
10     * @param _data Data opsional untuk diteruskan ke L1. Data ini disediakan
11     *        semata-mata sebagai kemudahan untuk kontrak eksternal. Selain dari menegakkan
12     *        panjang maksimum, kontrak ini tidak memberikan jaminan tentang kontennya.
13     */
14    function _initiateWithdrawal(
15        address _l2Token,
16        address _from,
17        address _to,
18        uint256 _amount,
19        uint32 _l1Gas,
20        bytes calldata _data
21    ) internal {
22        // When a withdrawal is initiated, we burn the withdrawer's funds to prevent subsequent L2 // Ketika penarikan diinisiasi, kami membakar dana penarik untuk mencegah penggunaan L2
23        // usage // selanjutnya
24        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
25        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
Tampilkan semuaSalin

1
2        // Construct calldata for l1TokenBridge.finalizeERC20Withdrawal(_to, _amount) // Membangun calldata untuk l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
3        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
4        address l1Token = IL2StandardERC20(_l2Token).l1Token();
5        bytes memory message;
6
7        if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
Salin

1            message = abi.encodeWithSelector(
2                IL1StandardBridge.finalizeETHWithdrawal.selector,
3                _from,
4                _to,
5                _amount,
6                _data
7            );
8        } else {
9            message = abi.encodeWithSelector(
10                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
11                l1Token,
12                _l2Token,
13                _from,
14                _to,
15                _amount,
16                _data
17            );
18        }
19
20        // Send message up to L1 bridge // Mengirim pesan ke jembatan L1
21        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
22        sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
23
24        // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
25        emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);
26    }
27
28    /* ***********************************
29     * Fungsi Lintas-rantai: Mendepositkan *
30     *********************************** */
31    /************************************
32     * Cross-chain Function: Depositing *
33     ************************************/
34
35    /**
36     * @inheritdoc IL2ERC20Bridge
37     */
38    function finalizeDeposit(
39        address _l1Token,
40        address _l2Token,
41        address _from,
42        address _to,
43        uint256 _amount,
44        bytes calldata _data
Tampilkan semuaSalin

1    ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
Salin

1        // Check the target token is compliant and // Memeriksa apakah token target mematuhi dan
2        // verify the deposited token on L1 matches the L2 deposited token representation here // memverifikasi token yang didepositkan di L1 cocok dengan representasi token yang didepositkan di L2 di sini
3        if (
4            // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
5            ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
6            _l1Token == IL2StandardERC20(_l2Token).l1Token()
Salin

1        ) {
2            // When a deposit is finalized, we credit the account on L2 with the same amount of // Ketika deposit diselesaikan, kami mengkreditkan akun di L2 dengan jumlah yang sama dari
3            // tokens. // token.
4            // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
5            IL2StandardERC20(_l2Token).mint(_to, _amount);
6            // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
7            emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
Salin

1        } else {
2            // Either the L2 token which is being deposited-into disagrees about the correct address // Entah token L2 yang sedang didepositkan tidak setuju tentang alamat yang benar
3            // of its L1 token, or does not support the correct interface. // dari token L1-nya, atau tidak mendukung antarmuka yang benar.
4            // This should only happen if there is a  malicious L2 token, or if a user somehow // Ini seharusnya hanya terjadi jika ada token L2 yang berbahaya, atau jika pengguna entah bagaimana
5            // specified the wrong L2 token address to deposit into. // menentukan alamat token L2 yang salah untuk didepositkan.
6            // In either case, we stop the process here and construct a withdrawal // Dalam kedua kasus tersebut, kami menghentikan proses di sini dan membangun pesan
7            // message so that users can get their funds out in some cases. // penarikan sehingga pengguna bisa mengeluarkan dana mereka dalam beberapa kasus.
8            // There is no way to prevent malicious token contracts altogether, but this does limit // Tidak ada cara untuk mencegah kontrak token berbahaya sepenuhnya, tetapi ini membatasi
9            // user error and mitigate some forms of malicious contract behavior. // kesalahan pengguna dan memitigasi beberapa bentuk perilaku kontrak yang berbahaya.
Tampilkan semuaSalin

1            bytes memory message = abi.encodeWithSelector(
2                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
3                _l1Token,
4                _l2Token,
5                _to, // switched the _to and _from here to bounce back the deposit to the sender // menukar _to dan _from di sini untuk memantulkan kembali deposit ke pengirim
6                _from,
7                _amount,
8                _data
9            );
10
11            // Send message up to L1 bridge // Mengirim pesan ke jembatan L1
12            // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
13            sendCrossDomainMessage(l1TokenBridge, 0, message);
14            // slither-disable-next-line reentrancy-events // slither-disable-next-line reentrancy-events
15            emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
16        }
17    }
18}
Tampilkan semuaSalin