Průvodce kontraktem standardního mostu Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Události *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Veřejné funkce *
     ********************/

    /**
     * @dev získá adresu odpovídajícího kontraktu mostu na vrstvě 2.
     * @return Adresa odpovídajícího kontraktu mostu na vrstvě 2.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev vloží částku ERC-20 na zůstatek volajícího na vrstvě 2.
     * @param _l1Token Adresa ERC-20 na vrstvě 1, který vkládáme
     * @param _l2Token Adresa příslušného ERC-20 na vrstvě 2 k vrstvě 1
     * @param _amount Částka ERC-20 k vložení
     * @param _l2Gas Limit gas požadovaný k dokončení vkladu na vrstvě 2.
     * @param _data Volitelná data k předání na vrstvu 2. Tato data jsou poskytována
     *        výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *        délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev vloží částku ERC-20 na zůstatek příjemce na vrstvě 2.
     * @param _l1Token Adresa ERC-20 na vrstvě 1, který vkládáme
     * @param _l2Token Adresa příslušného ERC-20 na vrstvě 2 k vrstvě 1
     * @param _to Adresa na vrstvě 2, které se má připsat výběr.
     * @param _amount Částka ERC-20 k vložení.
     * @param _l2Gas Limit gas požadovaný k dokončení vkladu na vrstvě 2.
     * @param _data Volitelná data k předání na vrstvu 2. Tato data jsou poskytována
     *        výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *        délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Meziřetězcové funkce *
     *************************/

    /**
     * @dev Dokončí výběr z vrstvy 2 na vrstvu 1 a připíše prostředky na zůstatek příjemce
     * tokenu ERC-20 na vrstvě 1.
     * Toto volání selže, pokud inicializovaný výběr z vrstvy 2 nebyl dokončen.
     *
     * @param _l1Token Adresa tokenu na vrstvě 1, pro který se má provést finalizeWithdrawal.
     * @param _l2Token Adresa tokenu na vrstvě 2, kde byl výběr zahájen.
     * @param _from Adresa na vrstvě 2 iniciující převod.
     * @param _to Adresa na vrstvě 1, které se má připsat výběr.
     * @param _amount Částka ERC-20 k vložení.
     * @param _data Data poskytnutá odesílatelem na vrstvě 2. Tato data jsou poskytována
     *   výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *   délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    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 {
    /**********
     * Události *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Veřejné funkce *
     ********************/

    /**
     * @dev Vloží částku ETH na zůstatek volajícího na vrstvě 2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Vloží částku ETH na zůstatek příjemce na vrstvě 2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Meziřetězcové funkce *
     *************************/

    /**
     * @dev Dokončí výběr z vrstvy 2 na vrstvu 1 a připíše prostředky na zůstatek příjemce
     * tokenu ETH na vrstvě 1. Jelikož tuto funkci může volat pouze xDomainMessenger, nikdy nebude volána
     * před dokončením výběru.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Pomocný kontrakt pro kontrakty provádějící mezidoménovou komunikaci
 *
 * Použitý kompilátor: definován dědícím kontraktem
 */
contract CrossDomainEnabled {
    /*************
     * Proměnné *
     *************/

    // Kontrakt messengeru používaný k odesílání a přijímání zpráv z jiné domény.
    address public messenger;

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

    /**
     * @param _messenger Adresa CrossDomainMessengeru na aktuální vrstvě.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Modifikátory funkcí *
     **********************/

    /**
     * Vynucuje, že modifikovaná funkce je volatelná pouze specifickým mezidoménovým účtem.
     * @param _sourceDomainAccount Jediný účet v původní doméně, který je
     *  ověřen k volání této funkce.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Interní funkce *
     **********************/

    /**
     * Získá messenger, obvykle z úložiště. Tato funkce je vystavena pro případ, že by ji podřízený kontrakt
     * potřeboval přepsat.
     * @return Adresa kontraktu mezidoménového messengeru, který by měl být použit.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Odešle zprávu na účet v jiné doméně
     * @param _crossDomainTarget Zamýšlený příjemce v cílové doméně
     * @param _message Data k odeslání cíli (obvykle data volání pro funkci s
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit Limit gas pro přijetí zprávy v cílové doméně.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev Most pro ETH a ERC-20 na vrstvě 1 je kontrakt, který uchovává vložené prostředky z vrstvy 1 a standardní
 * tokeny, které se používají na vrstvě 2. Synchronizuje odpovídající most na vrstvě 2, informuje ho o vkladech
 * a naslouchá mu ohledně nově dokončených výběrů.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inicializace *
     ******************/

    /**
     * @param _l1messenger Adresa messengeru na vrstvě 1 používaná pro meziřetězcovou komunikaci.
     * @param _l2TokenBridge Adresa standardního mostu na vrstvě 2.
     */
    // slither-disable-next-line external-function

    /**************
     * Vkládání *
     **************/

    /** @dev Modifikátor vyžadující, aby odesílatel byl EOA. Tuto kontrolu by mohl obejít škodlivý
     *  kontrakt přes initcode, ale řeší to uživatelskou chybu, které se chceme vyhnout.
     */
    modifier onlyEOA() {
        // Používá se k zastavení vkladů z kontraktů (zabraňuje náhodné ztrátě tokenů)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Tuto funkci lze volat bez dat
     * pro vložení částky ETH na zůstatek volajícího na vrstvě 2.
     * Jelikož funkce receive nepřijímá data, na vrstvu 2 se předává konzervativní
     * výchozí částka.
     */
    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 Provádí logiku pro vklady uložením ETH a informováním brány ETH na vrstvě 2 o
     * vkladu.
     * @param _from Účet, ze kterého se má stáhnout vklad na vrstvě 1.
     * @param _to Účet, kterému se má předat vklad na vrstvě 2.
     * @param _l2Gas Limit gas požadovaný k dokončení vkladu na vrstvě 2.
     * @param _data Volitelná data k předání na vrstvu 2. Tato data jsou poskytována
     *        výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *        délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Sestaví data volání pro volání 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 Provádí logiku pro vklady informováním kontraktu vloženého tokenu na vrstvě 2
     * o vkladu a zavoláním handleru pro uzamčení prostředků na vrstvě 1. (např. transferFrom)
     *
     * @param _l1Token Adresa ERC-20 na vrstvě 1, který vkládáme
     * @param _l2Token Adresa příslušného ERC-20 na vrstvě 2 k vrstvě 1
     * @param _from Účet, ze kterého se má stáhnout vklad na vrstvě 1
     * @param _to Účet, kterému se má předat vklad na vrstvě 2
     * @param _amount Částka ERC-20 k vložení.
     * @param _l2Gas Limit gas požadovaný k dokončení vkladu na vrstvě 2.
     * @param _data Volitelná data k předání na vrstvu 2. Tato data jsou poskytována
     *        výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *        délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Sestaví data volání pro _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Odešle data volání na vrstvu 2
        // 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);
    }

    /*************************
     * Meziřetězcové funkce *
     *************************/

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

        // Když je výběr dokončen na vrstvě 1, most na vrstvě 1 převede prostředky vybírajícímu
        // 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);
    }


    /*****************************
     * Dočasné - Migrace ETH *
     *****************************/

    /**
     * @dev Přidá zůstatek ETH na účet. Toto má umožnit migraci ETH
     * ze staré brány na novou bránu.
     * POZNÁMKA: Toto je ponecháno pouze pro jeden upgrade, abychom mohli přijmout migrované ETH ze
     * starého kontraktu
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Adresa standardního mostu na vrstvě 2.
     * @param _l1Token Adresa odpovídajícího tokenu na vrstvě 1.
     * @param _name Název ERC-20.
     * @param _symbol Symbol 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);
    }
}

/* Importy knihoven */
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";

/* Importy kontraktů */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev Standardní most na vrstvě 2 je kontrakt, který spolupracuje se standardním mostem na vrstvě 1, aby
 * umožnil přechody ETH a ERC-20 mezi vrstvou 1 a vrstvou 2.
 * Tento kontrakt slouží k ražení nových tokenů, když se dozví o vkladech do standardního mostu na vrstvě 1.
 * Tento kontrakt také slouží ke spalování tokenů určených k výběru a informuje most na vrstvě 1,
 * aby uvolnil prostředky na vrstvě 1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Odkazy na externí kontrakty *
     ********************************/

    address public l1TokenBridge;

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

    /**
     * @param _l2CrossDomainMessenger Mezidoménový messenger používaný tímto kontraktem.
     * @param _l1TokenBridge Adresa mostu na vrstvě 1 nasazeného na hlavním řetězci.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Vybírá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 Provádí logiku pro výběry tím, že spálí token a informuje
     *      bránu tokenu na vrstvě 1 o výběru.
     * @param _l2Token Adresa tokenu na vrstvě 2, kde je zahájen výběr.
     * @param _from Účet, ze kterého se má stáhnout výběr na vrstvě 2.
     * @param _to Účet, kterému se má předat výběr na vrstvě 1.
     * @param _amount Částka tokenu k výběru.
     * @param _l1Gas Nepoužito, ale zahrnuto z důvodu potenciální budoucí kompatibility.
     * @param _data Volitelná data k předání na vrstvu 1. Tato data jsou poskytována
     *        výhradně pro usnadnění externím kontraktům. Kromě vynucení maximální
     *        délky tyto kontrakty neposkytují žádné záruky ohledně jejich obsahu.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Když je zahájen výběr, spálíme prostředky vybírajícího, abychom zabránili následnému
        // použití na vrstvě 2
        // 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
            );
        }

        // Odešle zprávu nahoru do mostu na vrstvě 1
        // 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);
    }

    /************************************
     * Meziřetězcová funkce: Vkládání *
     ************************************/

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

        } else {
            // Buď token na vrstvě 2, do kterého se vkládá, nesouhlasí se správnou adresou
            // svého tokenu na vrstvě 1, nebo nepodporuje správné rozhraní.
            // To by se mělo stát pouze v případě, že existuje škodlivý token na vrstvě 2, nebo pokud uživatel nějakým způsobem
            // zadal špatnou adresu tokenu na vrstvě 2 pro vklad.
            // V obou případech zde proces zastavíme a sestavíme výběrovou
            // zprávu, aby uživatelé mohli v některých případech získat své prostředky zpět.
            // Neexistuje žádný způsob, jak zcela zabránit škodlivým kontraktům tokenů, ale toto omezuje
            // uživatelskou chybu a zmírňuje některé formy škodlivého chování kontraktu.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // zde jsme prohodili _to a _from, abychom vklad odrazili zpět odesílateli
                _from,
                _amount,
                _data
            );

            // Odešle zprávu nahoru do mostu na vrstvě 1
            // slither-disable-next-line reentrancy-events
            sendCrossDomainMessage(l1TokenBridge, 0, message);
            // slither-disable-next-line reentrancy-events
            emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
        }
    }
}