Przewodnik po kontrakcie standardowego mostu Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Zdarzenia *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Funkcje publiczne *
     ********************/

    /**
     * @dev pobiera adres odpowiedniego kontraktu mostu warstwy 2 (L2).
     * @return Adres odpowiedniego kontraktu mostu warstwy 2 (L2).
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev deponuje kwotę ERC-20 na saldo wywołującego w warstwie 2 (L2).
     * @param _l1Token Adres ERC-20 warstwy 1 (L1), który deponujemy
     * @param _l2Token Adres odpowiedniego ERC-20 warstwy 2 (L2) dla warstwy 1 (L1)
     * @param _amount Kwota ERC-20 do zdeponowania
     * @param _l2Gas Limit gazu wymagany do ukończenia depozytu w warstwie 2 (L2).
     * @param _data Opcjonalne dane do przekazania do warstwy 2 (L2). Te dane są dostarczane
     *        wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *        długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev deponuje kwotę ERC-20 na saldo odbiorcy w warstwie 2 (L2).
     * @param _l1Token Adres ERC-20 warstwy 1 (L1), który deponujemy
     * @param _l2Token Adres odpowiedniego ERC-20 warstwy 2 (L2) dla warstwy 1 (L1)
     * @param _to Adres warstwy 2 (L2), na który ma zostać uznana wypłata.
     * @param _amount Kwota ERC-20 do zdeponowania.
     * @param _l2Gas Limit gazu wymagany do ukończenia depozytu w warstwie 2 (L2).
     * @param _data Opcjonalne dane do przekazania do warstwy 2 (L2). Te dane są dostarczane
     *        wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *        długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Funkcje międzyłańcuchowe *
     *************************/

    /**
     * @dev Kończy wypłatę z warstwy 2 (L2) do warstwy 1 (L1) i uznaje środki na saldzie odbiorcy
     * tokena ERC-20 warstwy 1 (L1).
     * To wywołanie nie powiedzie się, jeśli zainicjowana wypłata z warstwy 2 (L2) nie została sfinalizowana.
     *
     * @param _l1Token Adres tokena warstwy 1 (L1), dla którego ma zostać wykonane finalizeWithdrawal.
     * @param _l2Token Adres tokena warstwy 2 (L2), gdzie zainicjowano wypłatę.
     * @param _from Adres warstwy 2 (L2) inicjujący transfer.
     * @param _to Adres warstwy 1 (L1), na który ma zostać uznana wypłata.
     * @param _amount Kwota ERC-20 do zdeponowania.
     * @param _data Dane dostarczone przez nadawcę w warstwie 2 (L2). Te dane są dostarczane
     *   wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *   długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    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 {
    /**********
     * Zdarzenia *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Funkcje publiczne *
     ********************/

    /**
     * @dev Deponuje kwotę ETH na saldo wywołującego w warstwie 2 (L2).
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Deponuje kwotę ETH na saldo odbiorcy w warstwie 2 (L2).
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Funkcje międzyłańcuchowe *
     *************************/

    /**
     * @dev Kończy wypłatę z warstwy 2 (L2) do warstwy 1 (L1) i uznaje środki na saldzie odbiorcy
     * tokena ETH warstwy 1 (L1). Ponieważ tylko xDomainMessenger może wywołać tę funkcję, nigdy nie zostanie ona wywołana
     * przed sfinalizowaniem wypłaty.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Kontrakt pomocniczy dla kontraktów wykonujących komunikację międzydomenową
 *
 * Użyty kompilator: zdefiniowany przez dziedziczący kontrakt
 */
contract CrossDomainEnabled {
    /*************
     * Zmienne *
     *************/

    // Kontrakt komunikatora używany do wysyłania i odbierania wiadomości z innej domeny.
    address public messenger;

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

    /**
     * @param _messenger Adres CrossDomainMessenger w bieżącej warstwie.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Modyfikatory funkcji *
     **********************/

    /**
     * Wymusza, aby modyfikowana funkcja mogła być wywoływana tylko przez określone konto międzydomenowe.
     * @param _sourceDomainAccount Jedyne konto w domenie źródłowej, które jest
     *  uwierzytelnione do wywołania tej funkcji.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Funkcje wewnętrzne *
     **********************/

    /**
     * Pobiera komunikator, zazwyczaj z pamięci (storage). Ta funkcja jest udostępniona na wypadek, gdyby kontrakt potomny
     * musiał ją nadpisać.
     * @return Adres kontraktu komunikatora międzydomenowego, który powinien zostać użyty.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Wysyła wiadomość do konta w innej domenie
     * @param _crossDomainTarget Zamierzony odbiorca w domenie docelowej
     * @param _message Dane do wysłania do celu (zazwyczaj dane wywołania do funkcji z
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit Limit gazu (gasLimit) dla odbioru wiadomości w domenie docelowej.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev Most ETH i ERC-20 warstwy 1 (L1) to kontrakt, który przechowuje zdeponowane środki warstwy 1 (L1) i standardowe
 * tokeny, które są w użyciu w warstwie 2 (L2). Synchronizuje on odpowiedni most warstwy 2 (L2), informując go o depozytach
 * i nasłuchując nowo sfinalizowanych wypłat.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inicjalizacja *
     ******************/

    /**
     * @param _l1messenger Adres komunikatora warstwy 1 (L1) używanego do komunikacji międzyłańcuchowej.
     * @param _l2TokenBridge Adres standardowego mostu warstwy 2 (L2).
     */
    // slither-disable-next-line external-function

    /**************
     * Deponowanie *
     **************/

    /** @dev Modyfikator wymagający, aby nadawca był EOA. To sprawdzenie mogłoby zostać ominięte przez złośliwy
     *  kontrakt za pomocą initcode, ale zapobiega błędowi użytkownika, którego chcemy uniknąć.
     */
    modifier onlyEOA() {
        // Używane do zatrzymania depozytów z kontraktów (unikanie przypadkowo utraconych tokenów)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Ta funkcja może zostać wywołana bez danych,
     * aby zdeponować kwotę ETH na saldo wywołującego w warstwie 2 (L2).
     * Ponieważ funkcja receive nie przyjmuje danych, konserwatywna
     * domyślna kwota jest przekazywana do warstwy 2 (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 Wykonuje logikę dla depozytów poprzez przechowywanie ETH i informowanie bramki ETH warstwy 2 (L2) o
     * depozycie.
     * @param _from Konto, z którego ma zostać pobrany depozyt w warstwie 1 (L1).
     * @param _to Konto, któremu ma zostać przekazany depozyt w warstwie 2 (L2).
     * @param _l2Gas Limit gazu wymagany do ukończenia depozytu w warstwie 2 (L2).
     * @param _data Opcjonalne dane do przekazania do warstwy 2 (L2). Te dane są dostarczane
     *        wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *        długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Konstruuje dane wywołania dla wywołania 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 Wykonuje logikę dla depozytów poprzez poinformowanie kontraktu zdeponowanego tokena warstwy 2 (L2)
     * o depozycie i wywołanie handlera w celu zablokowania środków warstwy 1 (L1). (np. transferFrom)
     *
     * @param _l1Token Adres ERC-20 warstwy 1 (L1), który deponujemy
     * @param _l2Token Adres odpowiedniego ERC-20 warstwy 2 (L2) dla warstwy 1 (L1)
     * @param _from Konto, z którego ma zostać pobrany depozyt w warstwie 1 (L1)
     * @param _to Konto, któremu ma zostać przekazany depozyt w warstwie 2 (L2)
     * @param _amount Kwota ERC-20 do zdeponowania.
     * @param _l2Gas Limit gazu wymagany do ukończenia depozytu w warstwie 2 (L2).
     * @param _data Opcjonalne dane do przekazania do warstwy 2 (L2). Te dane są dostarczane
     *        wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *        długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Konstruuje dane wywołania dla _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Wysyła dane wywołania do warstwy 2 (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);
    }

    /*************************
     * Funkcje międzyłańcuchowe *
     *************************/

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

        // Kiedy wypłata jest finalizowana w warstwie 1 (L1), most warstwy 1 (L1) transferuje środki do wypłacającego
        // 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);
    }


    /*****************************
     * Tymczasowe - Migracja ETH *
     *****************************/

    /**
     * @dev Dodaje saldo ETH do konta. Ma to na celu umożliwienie migracji ETH
     * ze starej bramki do nowej bramki.
     * UWAGA: Zostaje to pozostawione tylko na jedną aktualizację, abyśmy mogli otrzymać zmigrowane ETH ze
     * starego kontraktu
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Adres standardowego mostu warstwy 2 (L2).
     * @param _l1Token Adres odpowiedniego tokena warstwy 1 (L1).
     * @param _name Nazwa 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 bibliotek */
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ów */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev Standardowy most warstwy 2 (L2) to kontrakt, który współpracuje ze standardowym mostem warstwy 1 (L1), aby
 * umożliwić przejścia ETH i ERC-20 między warstwą 1 (L1) a warstwą 2 (L2).
 * Ten kontrakt działa jako wybijający nowe tokeny, gdy dowiaduje się o depozytach w standardowym moście
 * warstwy 1 (L1).
 * Ten kontrakt działa również jako spalający tokeny przeznaczone do wypłaty, informując most
 * warstwy 1 (L1) o konieczności uwolnienia środków warstwy 1 (L1).
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Referencje do zewnętrznych kontraktów *
     ********************************/

    address public l1TokenBridge;

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

    /**
     * @param _l2CrossDomainMessenger Komunikator międzydomenowy używany przez ten kontrakt.
     * @param _l1TokenBridge Adres mostu warstwy 1 (L1) wdrożonego w głównym łańcuchu.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Wypłacanie *
     ***************/

    /**
     * @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 Wykonuje logikę dla wypłat poprzez spalenie tokena i poinformowanie
     *      bramki tokena warstwy 1 (L1) o wypłacie.
     * @param _l2Token Adres tokena warstwy 2 (L2), gdzie inicjowana jest wypłata.
     * @param _from Konto, z którego ma zostać pobrana wypłata w warstwie 2 (L2).
     * @param _to Konto, któremu ma zostać przekazana wypłata w warstwie 1 (L1).
     * @param _amount Kwota tokena do wypłaty.
     * @param _l1Gas Nieużywane, ale dołączone ze względu na potencjalną kompatybilność w przyszłości.
     * @param _data Opcjonalne dane do przekazania do warstwy 1 (L1). Te dane są dostarczane
     *        wyłącznie dla wygody zewnętrznych kontraktów. Poza wymuszaniem maksymalnej
     *        długości, te kontrakty nie dają żadnych gwarancji co do ich zawartości.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Kiedy wypłata jest inicjowana, spalamy środki wypłacającego, aby zapobiec późniejszemu
        // użyciu w warstwie 2 (L2)
        // 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
            );
        }

        // Wysyła wiadomość w górę do mostu warstwy 1 (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);
    }

    /************************************
     * Funkcja międzyłańcuchowa: Deponowanie *
     ************************************/

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

        } else {
            // Albo token warstwy 2 (L2), do którego dokonywany jest depozyt, nie zgadza się co do poprawnego adresu
            // swojego tokena warstwy 1 (L1), albo nie obsługuje poprawnego interfejsu.
            // Powinno to mieć miejsce tylko wtedy, gdy istnieje złośliwy token warstwy 2 (L2), lub jeśli użytkownik w jakiś sposób
            // określił zły adres tokena warstwy 2 (L2) do zdeponowania.
            // W obu przypadkach zatrzymujemy proces tutaj i konstruujemy wiadomość
            // wypłaty, aby użytkownicy mogli w niektórych przypadkach odzyskać swoje środki.
            // Nie ma sposobu, aby całkowicie zapobiec złośliwym kontraktom tokenów, ale to ogranicza
            // błędy użytkowników i łagodzi niektóre formy złośliwego zachowania kontraktów.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // zamieniono tutaj _to i _from, aby odesłać depozyt z powrotem do nadawcy
                _from,
                _amount,
                _data
            );

            // Wysyła wiadomość w górę do mostu warstwy 1 (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);
        }
    }
}