Passo a passo do contrato da ponte padrão do Optimism

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

    event ERC20DepositInitiated(

    /********************
     * Funções Públicas *
     ********************/

    /**
     * @dev obtém o endereço do contrato de ponte da l2 correspondente.
     * @return Endereço do contrato de ponte da l2 correspondente.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev deposita uma quantia do ERC-20 no saldo do chamador na l2.
     * @param _l1Token Endereço do ERC-20 da l1 que estamos depositando
     * @param _l2Token Endereço do respectivo ERC-20 da l2 da l1
     * @param _amount Quantia do ERC-20 a depositar
     * @param _l2Gas Limite de gás exigido para concluir o depósito na l2.
     * @param _data Dados opcionais para encaminhar para a l2. Estes dados são fornecidos
     *        exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *        comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev deposita uma quantia de ERC-20 no saldo de um destinatário na l2.
     * @param _l1Token Endereço do ERC-20 da l1 que estamos depositando
     * @param _l2Token Endereço do respectivo ERC-20 da l2 da l1
     * @param _to Endereço da l2 para creditar o saque.
     * @param _amount Quantia do ERC-20 a depositar.
     * @param _l2Gas Limite de gás exigido para concluir o depósito na l2.
     * @param _data Dados opcionais para encaminhar para a l2. Estes dados são fornecidos
     *        exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *        comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Funções Cross-chain *
     *************************/

    /**
     * @dev Conclui um saque da l2 para a l1 e credita fundos no saldo do destinatário do
     * token ERC-20 da l1.
     * Esta chamada falhará se o saque inicializado da l2 não tiver sido finalizado.
     *
     * @param _l1Token Endereço do token da l1 para o qual fazer finalizeWithdrawal.
     * @param _l2Token Endereço do token da l2 onde o saque foi iniciado.
     * @param _from Endereço da l2 iniciando a transferência.
     * @param _to Endereço da l1 para creditar o saque.
     * @param _amount Quantia do ERC-20 a depositar.
     * @param _data Dados fornecidos pelo remetente na l2. Estes dados são fornecidos
     *   exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *   comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    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(
        .
        .
        .
    );

    /********************
     * Funções Públicas *
     ********************/

    /**
     * @dev Deposita uma quantia do ETH no saldo do chamador na l2.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev Deposita uma quantia de ETH no saldo de um destinatário na l2.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Funções Cross-chain *
     *************************/

    /**
     * @dev Conclui um saque da l2 para a l1 e credita fundos no saldo do destinatário do
     * token ETH da l1. Como apenas o xDomainMessenger pode chamar esta função, ela nunca será chamada
     * antes que o saque seja finalizado.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Contrato auxiliar para contratos realizando comunicações entre domínios
 *
 * Compilador usado: definido pelo contrato herdeiro
 */
contract CrossDomainEnabled {
    /*************
     * Variáveis *
     *************/

    // Contrato mensageiro usado para enviar e receber mensagens do outro domínio.
    address public messenger;

    /***************
     * Construtor *
     ***************/

    /**
     * @param _messenger Endereço do CrossDomainMessenger na camada atual.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Modificadores de Função *
     **********************/

    /**
     * Exige que a função modificada seja chamável apenas por uma conta de domínio cruzado específica.
     * @param _sourceDomainAccount A única conta no domínio de origem que está
     *  autenticada para chamar esta função.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Funções Internas *
     **********************/

    /**
     * Obtém o mensageiro, geralmente do armazenamento. Esta função é exposta caso um contrato filho
     * precise sobrescrever.
     * @return O endereço do contrato mensageiro de domínio cruzado que deve ser usado.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Envia uma mensagem para uma conta em outro domínio
     * @param _crossDomainTarget O destinatário pretendido no domínio de destino
     * @param _message Os dados a enviar para o alvo (geralmente dados de chamada para uma função com
     *  `onlyFromCrossDomainAccount()`)
     * @param _gasLimit O limite de gás para o recebimento da mensagem no domínio de destino.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev A ponte de ETH e ERC-20 da l1 é um contrato que armazena fundos da l1 depositados e tokens
 * padrão que estão em uso na l2. Ela sincroniza uma ponte da l2 correspondente, informando-a sobre depósitos
 * e ouvindo-a para saques recém-finalizados.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Inicialização *
     ******************/

    /**
     * @param _l1messenger Endereço do mensageiro da l1 sendo usado para comunicações cross-chain.
     * @param _l2TokenBridge Endereço da ponte padrão da l2.
     */
    // slither-disable-next-line external-function

    /**************
     * Depositando *
     **************/

    /** @dev Modificador exigindo que o remetente seja EOA. Esta verificação poderia ser contornada por um contrato
     *  malicioso via initcode, mas cuida do erro de usuário que queremos evitar.
     */
    modifier onlyEOA() {
        // Usado para impedir depósitos de contratos (evitar tokens perdidos acidentalmente)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Esta função pode ser chamada sem dados
     * para depositar uma quantia de ETH no saldo do chamador na l2.
     * Como a função receive não recebe dados, uma quantia padrão
     * conservadora é encaminhada para 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 Executa a lógica para depósitos armazenando o ETH e informando o Gateway de ETH da l2 sobre
     * o depósito.
     * @param _from Conta de onde retirar o depósito na l1.
     * @param _to Conta para a qual dar o depósito na l2.
     * @param _l2Gas Limite de gás exigido para concluir o depósito na l2.
     * @param _data Dados opcionais para encaminhar para a l2. Estes dados são fornecidos
     *        exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *        comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // Constrói dados de chamada para a chamada 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 Executa a lógica para depósitos informando o contrato de Token Depositado da l2
     * sobre o depósito e chamando um manipulador para bloquear os fundos da l1. (ex., transferFrom)
     *
     * @param _l1Token Endereço do ERC-20 da l1 que estamos depositando
     * @param _l2Token Endereço do respectivo ERC-20 da l2 da l1
     * @param _from Conta de onde retirar o depósito na l1
     * @param _to Conta para a qual dar o depósito na l2
     * @param _amount Quantia do ERC-20 a depositar.
     * @param _l2Gas Limite de gás exigido para concluir o depósito na l2.
     * @param _data Dados opcionais para encaminhar para a l2. Estes dados são fornecidos
     *        exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *        comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // Constrói dados de chamada para _l2Token.finalizeDeposit(_to, _amount)
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // Envia dados de chamada para 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);
    }

    /*************************
     * Funções 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 um saque é finalizado na l1, a ponte da l1 transfere os fundos para o sacador
        // 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);
    }


    /*****************************
     * Temporário - Migrando ETH *
     *****************************/

    /**
     * @dev Adiciona saldo de ETH à conta. Isso tem o objetivo de permitir que o ETH
     * seja migrado de um gateway antigo para um novo gateway.
     * NOTA: Isso é deixado para apenas uma atualização para que possamos receber o ETH migrado do
     * contrato antigo
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge Endereço da ponte padrão da l2.
     * @param _l1Token Endereço do token da l1 correspondente.
     * @param _name Nome do ERC-20.
     * @param _symbol Símbolo do 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);
    }
}

/* Importações de Biblioteca */
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";

/* Importações de Contrato */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev A ponte Padrão da l2 é um contrato que trabalha em conjunto com a ponte Padrão da l1 para
 * permitir transições de ETH e ERC-20 entre a l1 e a l2.
 * Este contrato atua como um cunhador para novos tokens quando ouve sobre depósitos na ponte Padrão
 * da l1.
 * Este contrato também atua como um queimador dos tokens destinados a saque, informando a ponte
 * da l1 para liberar fundos da l1.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Referências de Contratos Externos *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Construtor *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Mensageiro de domínio cruzado usado por este contrato.
     * @param _l1TokenBridge Endereço da ponte da l1 implantada na cadeia principal.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Sacando *
     ***************/

    /**
     * @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 Executa a lógica para saques queimando o token e informando
     *      o Gateway de token da l1 sobre o saque.
     * @param _l2Token Endereço do token da l2 onde o saque é iniciado.
     * @param _from Conta de onde retirar o saque na l2.
     * @param _to Conta para a qual dar o saque na l1.
     * @param _amount Quantia do token a sacar.
     * @param _l1Gas Não utilizado, mas incluído para potenciais considerações de compatibilidade futura.
     * @param _data Dados opcionais para encaminhar para a l1. Estes dados são fornecidos
     *        exclusivamente como uma conveniência para contratos externos. Além de exigir um
     *        comprimento máximo, estes contratos não fornecem garantias sobre seu conteúdo.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Quando um saque é iniciado, nós queimamos os fundos do sacador para evitar o uso
        // subsequente na 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
            );
        }

        // Envia mensagem para a ponte da 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);
    }

    /************************************
     * Função Cross-chain: Depositando *
     ************************************/

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

        } else {
            // Ou o token da l2 no qual está sendo depositado discorda sobre o endereço correto
            // de seu token da l1, ou não suporta a interface correta.
            // Isso só deve acontecer se houver um token da l2 malicioso, ou se um usuário de alguma forma
            // especificou o endereço errado do token da l2 para depositar.
            // Em ambos os casos, nós paramos o processo aqui e construímos uma mensagem
            // de saque para que os usuários possam retirar seus fundos em alguns casos.
            // Não há como evitar contratos de token maliciosos totalmente, mas isso limita
            // o erro do usuário e mitiga algumas formas de comportamento malicioso de contrato.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // trocou o _to e _from aqui para devolver o depósito ao remetente
                _from,
                _amount,
                _data
            );

            // Envia mensagem para a ponte da 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);
        }
    }
}