Panoramica del contratto del ponte standard di Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Eventi *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Funzioni pubbliche *
     ********************/

    /**
     * @dev ottiene l'indirizzo del contratto ponte l2 corrispondente.
     * @return Indirizzo del contratto ponte l2 corrispondente.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev deposita una quantità di ERC-20 sul saldo del chiamante sul l2.
     * @param _l1Token Indirizzo dell'ERC-20 sul l1 che stiamo depositando
     * @param _l2Token Indirizzo del rispettivo ERC-20 sul l2 del l1
     * @param _amount Quantità di ERC-20 da depositare
     * @param _l2Gas Limite di gas richiesto per completare il deposito sul l2.
     * @param _data Dati opzionali da inoltrare al l2. Questi dati sono forniti
     *        esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev deposita una quantità di ERC-20 sul saldo di un destinatario sul l2.
     * @param _l1Token Indirizzo dell'ERC-20 sul l1 che stiamo depositando
     * @param _l2Token Indirizzo del rispettivo ERC-20 sul l2 del l1
     * @param _to Indirizzo l2 a cui accreditare il prelievo.
     * @param _amount Quantità di ERC-20 da depositare.
     * @param _l2Gas Limite di gas richiesto per completare il deposito sul l2.
     * @param _data Dati opzionali da inoltrare al l2. Questi dati sono forniti
     *        esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Funzioni cross-chain *
     *************************/

    /**
     * @dev Completa un prelievo dal l2 al l1 e accredita i fondi sul saldo del destinatario del
     * token ERC-20 sul l1.
     * Questa chiamata fallirà se il prelievo inizializzato dal l2 non è stato finalizzato.
     *
     * @param _l1Token Indirizzo del token l1 per cui eseguire finalizeWithdrawal.
     * @param _l2Token Indirizzo del token l2 in cui è stato avviato il prelievo.
     * @param _from Indirizzo l2 che avvia il trasferimento.
     * @param _to Indirizzo l1 a cui accreditare il prelievo.
     * @param _amount Quantità di ERC-20 da depositare.
     * @param _data Dati forniti dal mittente sul l2. Questi dati sono forniti
     *   esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *   lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    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 {
    /**********
     * Eventi *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Funzioni pubbliche *
     ********************/

    /**
     * @dev Deposita una quantità di ETH sul saldo del chiamante sul l2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Deposita una quantità di ETH sul saldo di un destinatario sul l2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Funzioni cross-chain *
     *************************/

    /**
     * @dev Completa un prelievo dal l2 al l1 e accredita i fondi sul saldo del destinatario del
     * token ETH sul l1. Poiché solo xDomainMessenger può chiamare questa funzione, non verrà mai chiamata
     * prima che il prelievo sia finalizzato.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Contratto di supporto per i contratti che eseguono comunicazioni cross-domain
 *
 * Compilatore utilizzato: definito dal contratto che eredita
 */
contract CrossDomainEnabled {
    /*************
     * Variabili *
     *************/

    // Contratto messenger utilizzato per inviare e ricevere messaggi dall'altro dominio.
    address public messenger;

    /***************
     * Costruttore *
     ***************/

    /**
     * @param _messenger Indirizzo del CrossDomainMessenger sul layer corrente.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Modificatori di funzione *
     **********************/

    /**
     * Impone che la funzione modificata sia chiamabile solo da uno specifico account cross-domain.
     * @param _sourceDomainAccount L'unico account sul dominio di origine che è
     *  autenticato per chiamare questa funzione.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Funzioni interne *
     **********************/

    /**
     * Ottiene il messenger, di solito dallo storage. Questa funzione è esposta nel caso in cui un contratto figlio
     * debba sovrascriverla.
     * @return L'indirizzo del contratto messenger cross-domain che dovrebbe essere utilizzato.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Invia un messaggio a un account su un altro dominio
     * @param _crossDomainTarget Il destinatario previsto sul dominio di destinazione
     * @param _message I dati da inviare alla destinazione (di solito dati di chiamata a una funzione con
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit Il gasLimit per la ricezione del messaggio sul dominio di destinazione.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev Il ponte per ETH ed ERC-20 sul l1 è un contratto che memorizza i fondi l1 depositati e i token
 * standard che sono in uso sul l2. Sincronizza un ponte l2 corrispondente, informandolo dei depositi
 * e ascoltandolo per i prelievi appena finalizzati.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inizializzazione *
     ******************/

    /**
     * @param _l1messenger Indirizzo del Messenger l1 utilizzato per le comunicazioni cross-chain.
     * @param _l2TokenBridge Indirizzo del ponte standard l2.
     */
    // slither-disable-next-line external-function

    /**************
     * Deposito *
     **************/

    /** @dev Modificatore che richiede che il mittente sia un EOA. Questo controllo potrebbe essere aggirato da un contratto
     *  malevolo tramite initcode, ma si occupa dell'errore dell'utente che vogliamo evitare.
     */
    modifier onlyEOA() {
        // Utilizzato per fermare i depositi dai contratti (evitare token persi accidentalmente)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Questa funzione può essere chiamata senza dati
     * per depositare una quantità di ETH sul saldo del chiamante sul l2.
     * Poiché la funzione receive non accetta dati, una quantità predefinita
     * conservativa viene inoltrata al 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 Esegue la logica per i depositi memorizzando gli ETH e informando il Gateway ETH l2 del
     * deposito.
     * @param _from Account da cui prelevare il deposito sul l1.
     * @param _to Account a cui dare il deposito sul l2.
     * @param _l2Gas Limite di gas richiesto per completare il deposito sul l2.
     * @param _data Dati opzionali da inoltrare al l2. Questi dati sono forniti
     *        esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Costruisce i dati di chiamata per la chiamata 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 Esegue la logica per i depositi informando il contratto Deposited Token l2
     * del deposito e chiamando un gestore per bloccare i fondi l1. (es., transferFrom)
     *
     * @param _l1Token Indirizzo dell'ERC-20 sul l1 che stiamo depositando
     * @param _l2Token Indirizzo del rispettivo ERC-20 sul l2 del l1
     * @param _from Account da cui prelevare il deposito sul l1
     * @param _to Account a cui dare il deposito sul l2
     * @param _amount Quantità di ERC-20 da depositare.
     * @param _l2Gas Limite di gas richiesto per completare il deposito sul l2.
     * @param _data Dati opzionali da inoltrare al l2. Questi dati sono forniti
     *        esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Costruisce i dati di chiamata per _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Invia i dati di chiamata nel 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);
    }

    /*************************
     * Funzioni cross-chain *
     *************************/

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

        // Quando un prelievo viene finalizzato sul l1, il ponte l1 trasferisce i fondi a chi effettua il prelievo
        // 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);
    }


    /*****************************
     * Temporaneo - Migrazione di ETH *
     *****************************/

    /**
     * @dev Aggiunge saldo in ETH all'account. Questo ha lo scopo di consentire la migrazione di ETH
     * da un vecchio gateway a un nuovo gateway.
     * NOTA: Questo viene lasciato solo per un aggiornamento in modo da poter ricevere gli ETH migrati dal
     * vecchio contratto
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Indirizzo del ponte standard l2.
     * @param _l1Token Indirizzo del token l1 corrispondente.
     * @param _name Nome dell'ERC-20.
     * @param _symbol Simbolo dell'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);
    }
}

/* Importazioni di librerie */
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";

/* Importazioni di contratti */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev Il ponte standard l2 è un contratto che lavora insieme al ponte standard l1 per
 * abilitare le transizioni di ETH ed ERC-20 tra l1 e l2.
 * Questo contratto agisce per coniare nuovi token quando viene a conoscenza di depositi nel ponte standard
 * l1.
 * Questo contratto agisce anche per bruciare i token destinati al prelievo, informando il ponte
 * l1 di rilasciare i fondi l1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Riferimenti a contratti esterni *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Costruttore *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Messenger cross-domain utilizzato da questo contratto.
     * @param _l1TokenBridge Indirizzo del ponte l1 distribuito sulla catena principale.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Prelievo *
     ***************/

    /**
     * @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 Esegue la logica per i prelievi andando a bruciare il token e informando
     *      il Gateway del token l1 del prelievo.
     * @param _l2Token Indirizzo del token l2 in cui viene avviato il prelievo.
     * @param _from Account da cui prelevare il prelievo sul l2.
     * @param _to Account a cui dare il prelievo sul l1.
     * @param _amount Quantità del token da prelevare.
     * @param _l1Gas Inutilizzato, ma incluso per potenziali considerazioni di compatibilità futura.
     * @param _data Dati opzionali da inoltrare al l1. Questi dati sono forniti
     *        esclusivamente per comodità per i contratti esterni. A parte l'imposizione di una
     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Quando viene avviato un prelievo, andiamo a bruciare i fondi di chi effettua il prelievo per prevenire un successivo
        // utilizzo sul 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
            );
        }

        // Invia il messaggio al ponte 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);
    }

    /************************************
     * Funzione cross-chain: Deposito *
     ************************************/

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

        } else {
            // O il token l2 in cui si sta depositando non concorda sull'indirizzo corretto
            // del suo token l1, oppure non supporta l'interfaccia corretta.
            // Questo dovrebbe accadere solo se c'è un token l2 malevolo, o se un utente in qualche modo
            // ha specificato l'indirizzo del token l2 sbagliato in cui depositare.
            // In entrambi i casi, fermiamo il processo qui e costruiamo un
            // messaggio di prelievo in modo che gli utenti possano recuperare i propri fondi in alcuni casi.
            // Non c'è modo di prevenire del tutto i contratti token malevoli, ma questo limita
            // l'errore dell'utente e mitiga alcune forme di comportamento malevolo del contratto.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // scambiati _to e _from qui per rimbalzare il deposito al mittente
                _from,
                _amount,
                _data
            );

            // Invia il messaggio al ponte 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);
        }
    }
}