Recorrido por el contrato del puente estándar de Optimism

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Eventos *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Funciones públicas *
     ********************/

    /**
     * @dev obtiene la dirección del contrato de puente de L2 correspondiente.
     * @return Dirección del contrato de puente de L2 correspondiente.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev deposita una cantidad de ERC20 en el saldo del llamador en L2.
     * @param _l1Token Dirección del ERC20 de L1 que estamos depositando
     * @param _l2Token Dirección del respectivo ERC20 de L2
     * @param _amount Cantidad del ERC20 a depositar
     * @param _l2Gas Límite de gas requerido para completar el depósito en L2.
     * @param _data Datos opcionales para reenviar a L2. Estos datos se proporcionan
     *        únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *        estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev deposita una cantidad de ERC20 en el saldo de un destinatario en L2.
     * @param _l1Token Dirección del ERC20 de L1 que estamos depositando
     * @param _l2Token Dirección del respectivo ERC20 de L2
     * @param _to Dirección de L2 en la que acreditar el depósito.
     * @param _amount Cantidad del ERC20 a depositar.
     * @param _l2Gas Límite de gas requerido para completar el depósito en L2.
     * @param _data Datos opcionales para reenviar a L2. Estos datos se proporcionan
     *        únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *        estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Funciones entre cadenas *
     *************************/

    /**
     * @dev Completa una retirada de L2 a L1 y acredita los fondos al saldo del
     * token ERC20 de L1 del destinatario.
     * Esta llamada fallará si la retirada iniciada desde L2 no se ha finalizado.
     *
     * @param _l1Token Dirección del token de L1 para finalizeWithdrawal.
     * @param _l2Token Dirección del token de L2 donde se inició la retirada.
     * @param _from Dirección de L2 que inicia la transferencia.
     * @param _to Dirección de L1 en la que acreditar la retirada.
     * @param _amount Cantidad del ERC20 a depositar.
     * @param _data Datos proporcionados por el remitente en L2. Estos datos se proporcionan
     *   únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *   estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    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 {
    /**********
     * Eventos *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Funciones públicas *
     ********************/

    /**
     * @dev Deposita una cantidad de ETH en el saldo del llamador en L2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Deposita una cantidad de ETH en el saldo de un destinatario en L2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Funciones entre cadenas *
     *************************/

    /**
     * @dev Completa una retirada de L2 a L1 y acredita los fondos en el saldo del
     * token ETH de L1 del destinatario. Dado que solo el xDomainMessenger puede llamar a esta función, nunca se llamará
     * antes de que se finalice la retirada.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Contrato auxiliar para contratos que realizan comunicaciones entre dominios
 *
 * Compilador utilizado: definido por el contrato que hereda
 */
contract CrossDomainEnabled {
    /*************
     * Variables *
     *************/

    // Contrato de mensajero utilizado para enviar y recibir mensajes desde el otro dominio.
    address public messenger;

    /***************
     * Constructor *
     ***************/

    /**
     * @param _messenger Dirección del CrossDomainMessenger en la capa actual.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Modificadores de función *
     **********************/

    /**
     * @dev Exige que la función modificada solo pueda ser llamada por una cuenta específica entre dominios.
     * @param _sourceDomainAccount La única cuenta en el dominio de origen que está
     *  autenticada para llamar a esta función.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Funciones internas *
     **********************/

    /**
     * @dev Obtiene el mensajero, normalmente del almacenamiento. Esta función se expone en caso de que un contrato secundario
     * necesite anularla.
     * @return La dirección del contrato de mensajero entre dominios que se debe utilizar.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * @dev Envía un mensaje a una cuenta en otro dominio
     * @param _crossDomainTarget El destinatario previsto en el dominio de destino
     * @param _message Los datos para enviar al objetivo (normalmente datos de llamada a una función con
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit El límite de gas para la recepción del mensaje en el dominio de destino.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev El puente ERC20 y ETH de L1 es un contrato que almacena los fondos de L1 depositados y los tokens
 * estándar que están en uso en L2. Sincroniza un puente de L2 correspondiente, informándole de los depósitos
 * y escuchándolo para las retiradas recién finalizadas.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inicialización *
     ******************/

    /**
     * @param _l1messenger Dirección del mensajero de L1 que se utiliza para las comunicaciones entre cadenas.
     * @param _l2TokenBridge Dirección del puente estándar de L2.
     */
    // slither-disable-next-line external-function

    /**************
     * Depósito *
     **************/

    /** @dev Modificador que requiere que el remitente sea una EOA.  Esta comprobación podría ser
     *  eludida por un contrato malicioso a través de initcode, pero se encarga del error de usuario que queremos evitar.
     */
    modifier onlyEOA() {
        // Se utiliza para detener los depósitos de los contratos (evitar la pérdida accidental de tokens)
        require(!Address.isContract(msg.sender), "Cuenta no es EOA");
        _;
    }

    /**
     * @dev Se puede llamar a esta función sin datos
     * para depositar una cantidad de ETH en el saldo del llamador en L2.
     * Como la función de recepción no toma datos, se reenvía una
     * cantidad conservadora por defecto a 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 Realiza la lógica de los depósitos almacenando el ETH e informando a la puerta de enlace de ETH de L2
     * del depósito.
     * @param _from Cuenta de la que se retira el depósito en L1.
     * @param _to Cuenta a la que se entrega el depósito en L2.
     * @param _l2Gas Límite de gas requerido para completar el depósito en L2.
     * @param _data Datos opcionales para reenviar a L2. Estos datos se proporcionan
     *        únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *        estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Construir datos de llamada para la llamada a 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 Realiza la lógica de los depósitos informando al contrato de token
     * depositado en L2 del depósito y llamando a un manejador para bloquear los fondos de L1. (p. ej., transferFrom)
     *
     * @param _l1Token Dirección del ERC20 de L1 que estamos depositando
     * @param _l2Token Dirección del respectivo ERC20 de L2
     * @param _from Cuenta de la que se retira el depósito en L1
     * @param _to Cuenta a la que se entrega el depósito en L2
     * @param _amount Cantidad del ERC20 a depositar.
     * @param _l2Gas Límite de gas requerido para completar el depósito en L2.
     * @param _data Datos opcionales para reenviar a L2. Estos datos se proporcionan
     *        únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *        estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Construir datos de llamada para _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Enviar datos de llamada a 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);
    }

    /*************************
     * Funciones entre cadenas *
     *************************/

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

        // Cuando se finaliza una retirada en L1, el puente de L1 transfiere los fondos al retirante
        // 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);
    }


    /*****************************
     * Temporal - Migración de ETH *
     *****************************/

    /**
     * @dev Añade saldo de ETH a la cuenta. Esto está destinado a permitir que el ETH
     * se migre de una puerta de enlace antigua a una nueva.
     * NOTA: Esto se deja solo para una actualización para que podamos recibir el ETH migrado desde el
     * contrato antiguo
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Dirección del puente estándar de L2.
     * @param _l1Token Dirección del token de L1 correspondiente.
     * @param _name Nombre del ERC20.
     * @param _symbol Símbolo del ERC20.
     */
    constructor(
        address _l2Bridge,
        address _l1Token,
        string memory _name,
        string memory _symbol
    ) ERC20(_name, _symbol) {
        l1Token = _l1Token;
        l2Bridge = _l2Bridge;
    }

    modifier onlyL2Bridge() {
        require(msg.sender == l2Bridge, "Solo el puente L2 puede mintear y quemar");
        _;
    }


    // 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);
    }
}

/* Library Imports */
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";

/* Contract Imports */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev El puente estándar de L2 es un contrato que funciona junto con el puente estándar de L1 para
 * permitir las transiciones de ETH y ERC20 entre L1 y L2.
 * Este contrato actúa como un minteador de nuevos tokens cuando recibe información sobre depósitos en el puente
 * estándar de L1.
 * Este contrato también actúa como un quemador de los tokens destinados a la retirada, informando al puente de L1
 * para que libere los fondos de L1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Referencias a contratos externos *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Constructor *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Mensajero entre dominios utilizado por este contrato.
     * @param _l1TokenBridge Dirección del puente de L1 implementado en la cadena principal.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Retirada *
     ***************/

    /**
     * @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 Realiza la lógica de las retiradas quemando el token e informando
     *      a la puerta de enlace de tokens de L1 de la retirada.
     * @param _l2Token Dirección del token de L2 donde se inicia la retirada.
     * @param _from Cuenta de la que se retira el token en L2.
     * @param _to Cuenta a la que se entrega la retirada en L1.
     * @param _amount Cantidad del token a retirar.
     * @param _l1Gas No se utiliza, pero se incluye para posibles consideraciones de compatibilidad futura.
     * @param _data Datos opcionales para reenviar a L1. Estos datos se proporcionan
     *        únicamente para la comodidad de los contratos externos. Aparte de imponer una longitud máxima,
     *        estos contratos no ofrecen ninguna garantía sobre su contenido.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Cuando se inicia una retirada, quemamos los fondos del retirante para evitar un uso posterior en 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
            );
        }

        // Enviar mensaje al puente de 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);
    }

    /************************************
     * Función entre cadenas: Depósito *
     ************************************/

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

        } else {
            // O bien el token de L2 en el que se está depositando no está de acuerdo con la dirección correcta
            // de su token de L1, o no admite la interfaz correcta.
            // Esto solo debería ocurrir si hay un token de L2 malicioso, o si un usuario de alguna manera
            // especificó la dirección de token de L2 incorrecta para depositar.
            // En cualquier caso, detenemos el proceso aquí y construimos un mensaje de retirada
            // para que los usuarios puedan recuperar sus fondos en algunos casos.
            // No hay forma de evitar por completo los contratos de tokens maliciosos, pero esto limita
            // los errores del usuario y mitiga algunas formas de comportamiento malicioso de los contratos.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // se cambiaron _to y _from aquí para devolver el depósito al remitente
                _from,
                _amount,
                _data
            );

            // Enviar mensaje al puente de 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);
        }
    }
}