옵티미즘 표준 브릿지 컨트랙트 살펴보기

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * 이벤트 *
     **********/

    event ERC20DepositInitiated(

    /********************
     * 퍼블릭 함수 *
     ********************/

    /**
     * @dev 해당하는 l2 브릿지 컨트랙트의 주소를 가져옵니다.
     * @return 해당하는 l2 브릿지 컨트랙트의 주소.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev l2에 있는 호출자의 잔고로 일정량의 ERC-20을 예치합니다.
     * @param _l1Token 예치하려는 l1 ERC-20의 주소
     * @param _l2Token 해당 l1에 대응하는 l2 ERC-20의 주소
     * @param _amount 예치할 ERC-20의 양
     * @param _l2Gas l2에서 예치를 완료하는 데 필요한 가스 한도.
     * @param _data l2로 전달할 선택적 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev l2에 있는 수신자의 잔고로 일정량의 ERC-20을 예치합니다.
     * @param _l1Token 예치하려는 l1 ERC-20의 주소
     * @param _l2Token 해당 l1에 대응하는 l2 ERC-20의 주소
     * @param _to 인출 금액을 입금할 l2 주소.
     * @param _amount 예치할 ERC-20의 양.
     * @param _l2Gas l2에서 예치를 완료하는 데 필요한 가스 한도.
     * @param _data l2로 전달할 선택적 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * 크로스체인 함수 *
     *************************/

    /**
     * @dev l2에서 l1으로의 인출을 완료하고, 수신자의 l1 ERC-20 토큰 잔고에 자금을 입금합니다.
     * l2에서 초기화된 인출이 완료되지 않은 경우 이 호출은 실패합니다.
     *
     * @param _l1Token finalizeWithdrawal을 수행할 l1 토큰의 주소.
     * @param _l2Token 인출이 시작된 l2 토큰의 주소.
     * @param _from 전송을 시작하는 l2 주소.
     * @param _to 인출 금액을 입금할 l1 주소.
     * @param _amount 예치할 ERC-20의 양.
     * @param _data l2의 송신자가 제공한 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    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 {
    /**********
     * 이벤트 *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * 퍼블릭 함수 *
     ********************/

    /**
     * @dev l2에 있는 호출자의 잔고로 일정량의 ETH를 예치합니다.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev l2에 있는 수신자의 잔고로 일정량의 ETH를 예치합니다.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * 크로스체인 함수 *
     *************************/

    /**
     * @dev l2에서 l1으로의 인출을 완료하고, 수신자의 l1 ETH 토큰 잔고에 자금을 입금합니다. xDomainMessenger만이 이 함수를 호출할 수 있으므로, 인출이 완료되기 전에는 절대 호출되지 않습니다.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev 크로스 도메인 통신을 수행하는 컨트랙트를 위한 헬퍼 컨트랙트
 *
 * 사용된 컴파일러: 상속받는 컨트랙트에서 정의됨
 */
contract CrossDomainEnabled {
    /*************
     * 변수 *
     *************/

    // 다른 도메인과 메시지를 주고받는 데 사용되는 메신저 컨트랙트.
    address public messenger;

    /***************
     * 생성자 *
     ***************/

    /**
     * @param _messenger 현재 레이어에 있는 CrossDomainMessenger의 주소.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * 함수 제어자 *
     **********************/

    /**
     * 제어자가 적용된 함수는 특정 크로스 도메인 계정만 호출할 수 있도록 강제합니다.
     * @param _sourceDomainAccount 이 함수를 호출할 수 있도록 인증된 출발지 도메인의 유일한 계정.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * 내부 함수 *
     **********************/

    /**
     * 일반적으로 스토리지에서 메신저를 가져옵니다. 이 함수는 자식 컨트랙트가 오버라이드해야 할 경우를 대비해 노출됩니다.
     * @return 사용해야 하는 크로스 도메인 메신저 컨트랙트의 주소.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * 다른 도메인의 계정으로 메시지를 전송합니다
     * @param _crossDomainTarget 목적지 도메인의 의도된 수신자
     * @param _message 대상에게 보낼 데이터 (일반적으로 `onlyFromCrossDomainAccount()`가 있는 함수에 대한 콜 데이터)
     * @param _gasLimit 대상 도메인에서 메시지를 수신하기 위한 가스 한도.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

    /******************
     * 초기화 *
     ******************/

    /**
     * @param _l1messenger 크로스체인 통신에 사용되는 l1 메신저 주소.
     * @param _l2TokenBridge l2 표준 브릿지 주소.
     */
    // slither-disable-next-line external-function

    /**************
     * 예치 *
     **************/

    /** @dev 송신자가 EOA일 것을 요구하는 제어자. 악의적인 컨트랙트가 initcode를 통해 이 확인을 우회할 수 있지만, 우리가 피하고자 하는 사용자 오류를 처리합니다.
     */
    modifier onlyEOA() {
        // 컨트랙트로부터의 예치를 중단하는 데 사용됩니다 (실수로 토큰을 잃어버리는 것을 방지)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev 이 함수는 데이터 없이 호출되어
     * l2에 있는 호출자의 잔고로 일정량의 ETH를 예치할 수 있습니다.
     * receive 함수는 데이터를 받지 않으므로, 보수적인
     * 기본 금액이 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 ETH를 저장하고 l2 ETH 게이트웨이에 예치 사실을 알림으로써 예치 로직을 수행합니다.
     * @param _from l1에서 예치금을 가져올 계정.
     * @param _to l2에서 예치금을 받을 계정.
     * @param _l2Gas l2에서 예치를 완료하는 데 필요한 가스 한도.
     * @param _data l2로 전달할 선택적 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // 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 l2 예치 토큰 컨트랙트에 예치 사실을 알리고 핸들러를 호출하여 l1 자금을 잠금으로써 예치 로직을 수행합니다. (예: transferFrom)
     *
     * @param _l1Token 예치하려는 l1 ERC-20의 주소
     * @param _l2Token 해당 l1에 대응하는 l2 ERC-20의 주소
     * @param _from l1에서 예치금을 가져올 계정
     * @param _to l2에서 예치금을 받을 계정
     * @param _amount 예치할 ERC-20의 양.
     * @param _l2Gas l2에서 예치를 완료하는 데 필요한 가스 한도.
     * @param _data l2로 전달할 선택적 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // _l2Token.finalizeDeposit(_to, _amount)를 위한 콜 데이터 구성
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

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

    /*************************
     * 크로스체인 함수 *
     *************************/

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

        // l1에서 인출이 완료되면, l1 브릿지는 인출자에게 자금을 전송합니다
        // 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);
    }


    /*****************************
     * 임시 - ETH 마이그레이션 *
     *****************************/

    /**
     * @dev 계정에 ETH 잔고를 추가합니다. 이는 ETH가
     * 이전 게이트웨이에서 새 게이트웨이로 마이그레이션될 수 있도록 하기 위함입니다.
     * 참고: 이는 이전 컨트랙트로부터 마이그레이션된 ETH를 받을 수 있도록 단 한 번의 업그레이드를 위해서만 남겨둡니다
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge l2 표준 브릿지의 주소.
     * @param _l1Token 해당하는 l1 토큰의 주소.
     * @param _name ERC-20 이름.
     * @param _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);
    }
}

/* 라이브러리 임포트 */
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";

/* 컨트랙트 임포트 */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev l2 표준 브릿지는 l1 표준 브릿지와 함께 작동하여
 * l1과 l2 간의 ETH 및 ERC-20 전환을 가능하게 하는 컨트랙트입니다.
 * 이 컨트랙트는 l1 표준 브릿지로의 예치 소식을 들었을 때 새로운 토큰의 발행자 역할을 합니다.
 * 또한 이 컨트랙트는 인출을 목적으로 하는 토큰을 소각하는 역할을 하며, l1 브릿지에 l1 자금을 해제하도록 알립니다.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * 외부 컨트랙트 참조 *
     ********************************/

    address public l1TokenBridge;

    /***************
     * 생성자 *
     ***************/

    /**
     * @param _l2CrossDomainMessenger 이 컨트랙트에서 사용하는 크로스 도메인 메신저.
     * @param _l1TokenBridge 메인 체인에 배포된 l1 브릿지의 주소.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * 인출 *
     ***************/

    /**
     * @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 토큰을 소각하고 l1 토큰 게이트웨이에 인출 사실을 알림으로써
     *      인출 로직을 수행합니다.
     * @param _l2Token 인출이 시작된 l2 토큰의 주소.
     * @param _from l2에서 인출금을 가져올 계정.
     * @param _to l1에서 인출금을 받을 계정.
     * @param _amount 인출할 토큰의 양.
     * @param _l1Gas 사용되지 않지만, 잠재적인 상위 호환성 고려를 위해 포함됨.
     * @param _data l1으로 전달할 선택적 데이터. 이 데이터는 외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대 길이를 강제하는 것 외에, 이 컨트랙트들은 그 내용에 대해 어떠한 보장도 하지 않습니다.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // 인출이 시작되면, 후속 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
            );
        }

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

    /************************************
     * 크로스체인 함수: 예치 *
     ************************************/

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

        } else {
            // 예치 대상인 l2 토큰이 올바른 주소에 대해 동의하지 않거나
            // 자신의 l1 토큰의 올바른 인터페이스를 지원하지 않습니다.
            // 이는 악의적인 l2 토큰이 있거나, 사용자가 어떤 이유로든
            // 예치할 잘못된 l2 토큰 주소를 지정한 경우에만 발생해야 합니다.
            // 어느 경우든, 여기서 프로세스를 중단하고 인출
            // 메시지를 구성하여 일부 경우에 사용자가 자금을 빼낼 수 있도록 합니다.
            // 악의적인 토큰 컨트랙트를 완전히 방지할 방법은 없지만, 이는
            // 사용자 오류를 제한하고 일부 형태의 악의적인 컨트랙트 동작을 완화합니다.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // 예치금을 송신자에게 되돌려주기 위해 여기서 _to와 _from을 바꿨습니다
                _from,
                _amount,
                _data
            );

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