Optimism 표준 브리지 컨트랙트 둘러보기

1// SPDX-License-Identifier: MIT
복사

1pragma solidity >0.5.0 <0.9.0;
복사

1/**
2 * @title IL1ERC20Bridge
3 */
4interface IL1ERC20Bridge {
5    /**********
6     * 이벤트 *
7     **********/
8
9    event ERC20DepositInitiated(
모두 보기
복사

1        address indexed _l1Token,
2        address indexed _l2Token,
복사

1        address indexed _from,
2        address _to,
3        uint256 _amount,
4        bytes _data
5    );
복사

1    event ERC20WithdrawalFinalized(
2        address indexed _l1Token,
3        address indexed _l2Token,
4        address indexed _from,
5        address _to,
6        uint256 _amount,
7        bytes _data
8    );
복사

1
2    /********************
3     * 공개 함수 *
4     ********************/
5
6    /**
7     * @dev 해당하는 L2 브리지 컨트랙트의 주소를 가져옵니다.
8     * @return 해당하는 L2 브리지 컨트랙트의 주소입니다.
9     */
10    function l2TokenBridge() external returns (address);
모두 보기
복사

1    /**
2     * @dev ERC20의 일정 금액을 L2의 호출자 잔액으로 예치합니다.
3     * @param _l1Token 우리가 예치하는 L1 ERC20의 주소
4     * @param _l2Token 해당 L2 ERC20의 주소
5     * @param _amount 예치할 ERC20의 금액
6     * @param _l2Gas L2에서 예치를 완료하는 데 필요한 가스 한도
7     * @param _data L2로 전달할 선택적 데이터. 이 데이터는
8     *        외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
9     *        길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
10     */
11    function depositERC20(
12        address _l1Token,
13        address _l2Token,
14        uint256 _amount,
15        uint32 _l2Gas,
16        bytes calldata _data
17    ) external;
모두 보기
복사

1    /**
2     * @dev ERC20의 일정 금액을 L2의 수신자 잔액으로 예치합니다.
3     * @param _l1Token 우리가 예치하는 L1 ERC20의 주소
4     * @param _l2Token 해당 L2 ERC20의 주소
5     * @param _to 인출을 입금할 L2 주소.
6     * @param _amount 예치할 ERC20의 금액.
7     * @param _l2Gas L2에서 예치를 완료하는 데 필요한 가스 한도.
8     * @param _data L2로 전달할 선택적 데이터. 이 데이터는
9     *        외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
10     *        길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
11     */
12    function depositERC20To(
13        address _l1Token,
14        address _l2Token,
15        address _to,
16        uint256 _amount,
17        uint32 _l2Gas,
18        bytes calldata _data
19    ) external;
모두 보기
복사

1    /*************************
2     * 교차 체인 함수 *
3     *************************/
4
5    /**
6     * @dev L2에서 L1으로의 인출을 완료하고, 수신자의
7     * L1 ERC20 토큰 잔액에 자금을 입금합니다.
8     * 이 호출은 L2에서 시작된 인출이 완료되지 않은 경우 실패합니다.
9     *
10     * @param _l1Token finalizeWithdrawal을 수행할 L1 토큰의 주소.
11     * @param _l2Token 인출이 시작된 L2 토큰의 주소.
12     * @param _from 전송을 시작하는 L2 주소.
13     * @param _to 인출을 입금할 L1 주소.
14     * @param _amount 예치할 ERC20의 금액.
15     * @param _data L2의 발신자가 제공한 데이터. 이 데이터는
16     *   외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
17     *   길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
18     */
19    function finalizeERC20Withdrawal(
20        address _l1Token,
21        address _l2Token,
22        address _from,
23        address _to,
24        uint256 _amount,
25        bytes calldata _data
26    ) external;
27}
모두 보기
복사

1// SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4import "./IL1ERC20Bridge.sol";
5
6/**
7 * @title IL1StandardBridge
8 */
9interface IL1StandardBridge is IL1ERC20Bridge {
10    /**********
11     * 이벤트 *
12     **********/
13    event ETHDepositInitiated(
14        address indexed _from,
15        address indexed _to,
16        uint256 _amount,
17        bytes _data
18    );
모두 보기
복사

1    event ETHWithdrawalFinalized(
2        .
3        .
4        .
5    );
6
7    /********************
8     * 공개 함수 *
9     ********************/
10
11    /**
12     * @dev ETH의 일정 금액을 L2의 호출자 잔액으로 예치합니다.
13            .
14            .
15            .
16     */
17    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
18
19    /**
20     * @dev ETH의 일정 금액을 L2의 수신자 잔액으로 예치합니다.
21            .
22            .
23            .
24     */
25    function depositETHTo(
26        address _to,
27        uint32 _l2Gas,
28        bytes calldata _data
29    ) external payable;
30
31    /*************************
32     * 교차 체인 함수 *
33     *************************/
34
35    /**
36     * @dev L2에서 L1으로의 인출을 완료하고, 수신자의
37     * L1 ETH 토큰 잔액에 자금을 입금합니다. xDomainMessenger만이 이 함수를 호출할 수 있으므로
38     * 인출이 완료되기 전에는 절대 호출되지 않습니다.
39                .
40                .
41                .
42     */
43    function finalizeETHWithdrawal(
44        address _from,
45        address _to,
46        uint256 _amount,
47        bytes calldata _data
48    ) external;
49}
모두 보기
복사

1// SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4/* 인터페이스 임포트 */
5import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
복사

1/**
2 * @title CrossDomainEnabled
3 * @dev 교차 도메인 통신을 수행하는 컨트랙트를 위한 헬퍼 컨트랙트
4 *
5 * 사용된 컴파일러: 상속하는 컨트랙트에 의해 정의됨
6 */
7contract CrossDomainEnabled {
8    /*************
9     * 변수 *
10     *************/
11
12    // 다른 도메인으로부터 메시지를 보내고 받는 데 사용되는 메신저 컨트랙트.
13    address public messenger;
14
15    /***************
16     * 생성자 *
17     ***************/
18
19    /**
20     * @param _messenger 현재 레이어의 CrossDomainMessenger 주소.
21     */
22    constructor(address _messenger) {
23        messenger = _messenger;
24    }
모두 보기
복사

1
2    /**********************
3     * 함수 수정자 *
4     **********************/
5
6    /**
7     * 수정된 함수가 특정 교차 도메인 계정에서만 호출될 수 있도록 강제합니다.
8     * @param _sourceDomainAccount 이 함수를 호출할 수 있도록
9     *  인증된 유일한 원래 도메인 계정입니다.
10     */
11    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
모두 보기
복사

1        require(
2            msg.sender == address(getCrossDomainMessenger()),
3            "OVM_XCHAIN: 메신저 컨트랙트가 인증되지 않았습니다"
4        );
복사

1
2        require(
3            getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
4            "OVM_XCHAIN: 교차 도메인 메시지의 발신자가 잘못되었습니다"
5        );
복사

1
2        _;
3    }
4
5    /**********************
6     * 내부 함수 *
7     **********************/
8
9    /**
10     * 일반적으로 스토리지에서 메신저를 가져옵니다. 이 함수는 자식 컨트랙트가
11     * 재정의해야 할 경우를 대비하여 노출됩니다.
12     * @return 사용해야 할 교차 도메인 메신저 컨트랙트의 주소입니다.
13     */
14    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
15        return ICrossDomainMessenger(messenger);
16    }
모두 보기
복사

1
2    /**
3     * 다른 도메인의 계정으로 메시지를 보냅니다
4     * @param _crossDomainTarget 대상 도메인의 의도된 수신자
5     * @param _message 대상에게 보낼 데이터(일반적으로
6     *  `onlyFromCrossDomainAccount()`가 있는 함수에 대한 콜데이터)
7     * @param _gasLimit 대상 도메인에서 메시지를 수신하기 위한 gasLimit입니다.
8     */
9    function sendCrossDomainMessage(
10        address _crossDomainTarget,
11        uint32 _gasLimit,
12        bytes memory _message
모두 보기
복사

1    ) internal {
2        // slither-disable-next-line reentrancy-events, reentrancy-benign
복사

1        getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
2    }
3}
복사

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
복사

1/* 인터페이스 임포트 */
2import { IL1StandardBridge } from "./IL1StandardBridge.sol";
3import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
복사

1import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
복사

1import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
복사

1/* 라이브러리 임포트 */
2import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
복사

1import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
복사

1import { Address } from "@openzeppelin/contracts/utils/Address.sol";
복사

1import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
복사

1/**
2 * @title L1StandardBridge
3 * @dev L1 ETH 및 ERC20 브리지는 L2에서 사용 중인 예치된 L1 자금과 표준
4 * 토큰을 저장하는 컨트랙트입니다. 해당하는 L2 브리지를 동기화하여 예치 정보를 알리고
5 * 새로 완료된 인출을 수신합니다.
6 *
7 */
8contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
9    using SafeERC20 for IERC20;
모두 보기
복사

1
2    /********************************
3     * 외부 컨트랙트 참조 *
4     ********************************/
5
6    address public l2TokenBridge;
복사

1
2    // L1 토큰을 L2 토큰에 매핑하여 예치된 L1 토큰의 잔액을 관리
3    mapping(address => mapping(address => uint256)) public deposits;
복사

1
2    /***************
3     * 생성자 *
4     ***************/
5
6    // 이 컨트랙트는 프록시 뒤에 존재하므로 생성자 매개변수는 사용되지 않습니다.
7    constructor() CrossDomainEnabled(address(0)) {}
복사

1    /******************
2     * 초기화 *
3     ******************/
4
5    /**
6     * @param _l1messenger 교차 체인 통신에 사용되는 L1 메신저 주소.
7     * @param _l2TokenBridge L2 표준 브리지 주소.
8     */
9    // slither-disable-next-line external-function
모두 보기
복사

1    function initialize(address _l1messenger, address _l2TokenBridge) public {
2        require(messenger == address(0), "컨트랙트가 이미 초기화되었습니다.");
복사

1        messenger = _l1messenger;
2        l2TokenBridge = _l2TokenBridge;
3    }
복사

1
2    /**************
3     * 예치 *
4     **************/
5
6    /** @dev 발신자가 EOA여야 하는 수정자입니다. 이 검사는 악의적인
7     *  컨트랙트가 initcode를 통해 우회할 수 있지만, 우리가 피하고자 하는 사용자 오류를 처리합니다.
8     */
9    modifier onlyEOA() {
10        // 컨트랙트로부터의 예치를 중지하는 데 사용됩니다(실수로 토큰을 잃는 것을 방지)
11        require(!Address.isContract(msg.sender), "계정이 EOA가 아님");
12        _;
13    }
모두 보기
복사

1    /**
2     * @dev 이 함수는 데이터 없이 호출될 수 있습니다
3     * ETH의 일정 금액을 L2의 호출자 잔액으로 예치합니다.
4     * receive 함수는 데이터를 받지 않으므로, 보수적인
5     * 기본 금액이 L2로 전달됩니다.
6     */
7    receive() external payable onlyEOA {
8        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
9    }
모두 보기
복사

1    /**
2     * @inheritdoc IL1StandardBridge
3     */
4    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
5        _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
6    }
7
8    /**
9     * @inheritdoc IL1StandardBridge
10     */
11    function depositETHTo(
12        address _to,
13        uint32 _l2Gas,
14        bytes calldata _data
15    ) external payable {
16        _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
17    }
모두 보기
복사

1    /**
2     * @dev ETH를 저장하고 L2 ETH 게이트웨이에
3     * 예치를 알리는 예치 로직을 수행합니다.
4     * @param _from L1에서 예치를 가져올 계정.
5     * @param _to L2에서 예치를 줄 계정.
6     * @param _l2Gas L2에서 예치를 완료하는 데 필요한 가스 한도.
7     * @param _data L2로 전달할 선택적 데이터. 이 데이터는
8     *        외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
9     *        길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
10     */
11    function _initiateETHDeposit(
12        address _from,
13        address _to,
14        uint32 _l2Gas,
15        bytes memory _data
16    ) internal {
17        // finalizeDeposit 호출을 위한 콜데이터 구성
18        bytes memory message = abi.encodeWithSelector(
모두 보기
복사

1            IL2ERC20Bridge.finalizeDeposit.selector,
2            address(0),
3            Lib_PredeployAddresses.OVM_ETH,
4            _from,
5            _to,
6            msg.value,
7            _data
8        );
복사

1        // L2로 콜데이터 전송
2        // slither-disable-next-line reentrancy-events
3        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
복사

1        // slither-disable-next-line reentrancy-events
2        emit ETHDepositInitiated(_from, _to, msg.value, _data);
3    }
복사

1    /**
2     * @inheritdoc IL1ERC20Bridge
3     */
4    function depositERC20(
5		.
6		.
7		.
8    ) external virtual onlyEOA {
9        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
10    }
11
12    /**
13     * @inheritdoc IL1ERC20Bridge
14     */
15    function depositERC20To(
16		.
17		.
18		.
19    ) external virtual {
20        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
21    }
모두 보기
복사

1    /**
2     * @dev L2 예치 토큰
3     * 컨트랙트에 예치를 알리고 L1 자금을 락업하는 핸들러를 호출하여 예치 로직을 수행합니다. (예: transferFrom)
4     *
5     * @param _l1Token 우리가 예치하는 L1 ERC20의 주소
6     * @param _l2Token 해당 L2 ERC20의 주소
7     * @param _from L1에서 예치를 가져올 계정
8     * @param _to L2에서 예치를 줄 계정
9     * @param _amount 예치할 ERC20의 금액.
10     * @param _l2Gas L2에서 예치를 완료하는 데 필요한 가스 한도.
11     * @param _data L2로 전달할 선택적 데이터. 이 데이터는
12     *        외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
13     *        길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
14     */
15    function _initiateERC20Deposit(
16        address _l1Token,
17        address _l2Token,
18        address _from,
19        address _to,
20        uint256 _amount,
21        uint32 _l2Gas,
22        bytes calldata _data
23    ) internal {
모두 보기
복사

1        // L1에서 예치가 시작되면, L1 브리지는 미래의
2        // 인출을 위해 자금을 자체적으로 전송합니다. safeTransferFrom은 또한 컨트랙트에 코드가 있는지 확인하므로
3        // _from이 EOA 또는 address(0)인 경우 실패합니다.
4        // slither-disable-next-line reentrancy-events, reentrancy-benign
5        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
복사

1        // _l2Token.finalizeDeposit(_to, _amount)에 대한 콜데이터 구성
2        bytes memory message = abi.encodeWithSelector(
3            IL2ERC20Bridge.finalizeDeposit.selector,
4            _l1Token,
5            _l2Token,
6            _from,
7            _to,
8            _amount,
9            _data
10        );
11
12        // L2로 콜데이터 전송
13        // slither-disable-next-line reentrancy-events, reentrancy-benign
14        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
15
16        // slither-disable-next-line reentrancy-benign
17        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
모두 보기
복사

1
2        // slither-disable-next-line reentrancy-events
3        emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
4    }
5
6    /*************************
7     * 교차 체인 함수 *
8     *************************/
9
10    /**
11     * @inheritdoc IL1StandardBridge
12     */
13    function finalizeETHWithdrawal(
14        address _from,
15        address _to,
16        uint256 _amount,
17        bytes calldata _data
모두 보기
복사

1    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
복사

1        // slither-disable-next-line reentrancy-events
2        (bool success, ) = _to.call{ value: _amount }(new bytes(0));
복사

1        require(success, "TransferHelper::safeTransferETH: ETH 전송 실패");
2
3        // slither-disable-next-line reentrancy-events
4        emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
복사

1    }
2
3    /**
4     * @inheritdoc IL1ERC20Bridge
5     */
6    function finalizeERC20Withdrawal(
7        address _l1Token,
8        address _l2Token,
9        address _from,
10        address _to,
11        uint256 _amount,
12        bytes calldata _data
13    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
모두 보기
복사

1        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
복사

1
2        // L1에서 인출이 완료되면 L1 브리지는 자금을 인출자에게 전송합니다
3        // slither-disable-next-line reentrancy-events
4        IERC20(_l1Token).safeTransfer(_to, _amount);
5
6        // slither-disable-next-line reentrancy-events
7        emit ERC20WithdrawalFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
8    }
9
10
11    /*****************************
12     * 임시 - ETH 마이그레이션 *
13     *****************************/
14
15    /**
16     * @dev 계정에 ETH 잔액을 추가합니다. 이는 ETH가
17     * 이전 게이트웨이에서 새 게이트웨이로 마이그레이션될 수 있도록 하기 위한 것입니다.
18     * 참고: 이전 컨트랙트에서 마이그레이션된 ETH를 받을 수 있도록
19     * 한 번의 업그레이드에만 남겨둡니다
20     */
21    function donateETH() external payable {}
22}
모두 보기
복사

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
복사

1import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
복사

1interface IL2StandardERC20 is IERC20, IERC165 {
2    function l1Token() external returns (address);
복사

1
2    function mint(address _to, uint256 _amount) external;
3
4    function burn(address _from, uint256 _amount) external;
5
6    event Mint(address indexed _account, uint256 _amount);
7    event Burn(address indexed _account, uint256 _amount);
8}
복사

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
복사

1import "./IL2StandardERC20.sol";
2
3contract L2StandardERC20 is IL2StandardERC20, ERC20 {
4    address public l1Token;
5    address public l2Bridge;
복사

1
2    /**
3     * @param _l2Bridge L2 표준 브리지의 주소.
4     * @param _l1Token 해당하는 L1 토큰의 주소.
5     * @param _name ERC20 이름.
6     * @param _symbol ERC20 기호.
7     */
8    constructor(
9        address _l2Bridge,
10        address _l1Token,
11        string memory _name,
12        string memory _symbol
13    ) ERC20(_name, _symbol) {
14        l1Token = _l1Token;
15        l2Bridge = _l2Bridge;
16    }
모두 보기
복사

1
2    modifier onlyL2Bridge() {
3        require(msg.sender == l2Bridge, "L2 브리지만 민팅 및 소각 가능");
4        _;
5    }
6
7
8    // slither-disable-next-line external-function
9    function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
10        bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); // ERC165
11        bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^
12            IL2StandardERC20.mint.selector ^
13            IL2StandardERC20.burn.selector;
14        return _interfaceId == firstSupportedInterface || _interfaceId == secondSupportedInterface;
15    }
모두 보기
복사

1    // slither-disable-next-line external-function
2    function mint(address _to, uint256 _amount) public virtual onlyL2Bridge {
3        _mint(_to, _amount);
4
5        emit Mint(_to, _amount);
6    }
7
8    // slither-disable-next-line external-function
9    function burn(address _from, uint256 _amount) public virtual onlyL2Bridge {
10        _burn(_from, _amount);
11
12        emit Burn(_from, _amount);
13    }
14}
모두 보기
복사

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4/* 인터페이스 임포트 */
5import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
6import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
7import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
복사

1/* 라이브러리 임포트 */
2import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
3import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
4import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
5
6/* 컨트랙트 임포트 */
7import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
8
9/**
10 * @title L2StandardBridge
11 * @dev L2 표준 브리지는 L1 표준 브리지와 함께 작동하여 L1과 L2 간의 ETH 및 ERC20 전환을 가능하게 하는 컨트랙트입니다.
12 * 이 컨트랙트는 L1 표준 브리지에 예치된 내역을 들었을 때 새 토큰의 민팅자 역할을 합니다.
13 * 이 컨트랙트는 또한 인출을 목적으로 하는 토큰의 소각자 역할을 하여 L1 브리지에 L1 자금을 릴리스하도록 알립니다.
14 */
15contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
16    /********************************
17     * 외부 컨트랙트 참조 *
18     ********************************/
19
20    address public l1TokenBridge;
모두 보기
복사

1
2    /***************
3     * 생성자 *
4     ***************/
5
6    /**
7     * @param _l2CrossDomainMessenger 이 컨트랙트에서 사용하는 교차 도메인 메신저.
8     * @param _l1TokenBridge 메인 체인에 배포된 L1 브리지의 주소.
9     */
10    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
11        CrossDomainEnabled(_l2CrossDomainMessenger)
12    {
13        l1TokenBridge = _l1TokenBridge;
14    }
15
16    /***************
17     * 인출 *
18     ***************/
19
20    /**
21     * @inheritdoc IL2ERC20Bridge
22     */
23    function withdraw(
24        address _l2Token,
25        uint256 _amount,
26        uint32 _l1Gas,
27        bytes calldata _data
28    ) external virtual {
29        _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
30    }
31
32    /**
33     * @inheritdoc IL2ERC20Bridge
34     */
35    function withdrawTo(
36        address _l2Token,
37        address _to,
38        uint256 _amount,
39        uint32 _l1Gas,
40        bytes calldata _data
41    ) external virtual {
42        _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
43    }
모두 보기
복사

1
2    /**
3     * @dev 토큰을 소각하고 L1 토큰 게이트웨이에
4     *      인출을 알리는 인출 로직을 수행합니다.
5     * @param _l2Token 인출이 시작된 L2 토큰의 주소.
6     * @param _from L2에서 인출을 가져올 계정.
7     * @param _to L1에서 인출을 줄 계정.
8     * @param _amount 인출할 토큰의 금액.
9     * @param _l1Gas 사용되지 않지만 잠재적인 미래 호환성을 위해 포함됩니다.
10     * @param _data L1으로 전달할 선택적 데이터. 이 데이터는
11     *        외부 컨트랙트의 편의를 위해서만 제공됩니다. 최대
12     *        길이를 강제하는 것 외에, 이 컨트랙트는 내용에 대한 어떠한 보증도 제공하지 않습니다.
13     */
14    function _initiateWithdrawal(
15        address _l2Token,
16        address _from,
17        address _to,
18        uint256 _amount,
19        uint32 _l1Gas,
20        bytes calldata _data
21    ) internal {
22        // 인출이 시작되면 후속 L2 사용을 방지하기 위해 인출자의 자금을 소각합니다
23        // slither-disable-next-line reentrancy-events
24        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
모두 보기
복사

1
2        // l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)에 대한 콜데이터 구성
3        // slither-disable-next-line reentrancy-events
4        address l1Token = IL2StandardERC20(_l2Token).l1Token();
5        bytes memory message;
6
7        if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
복사

1            message = abi.encodeWithSelector(
2                IL1StandardBridge.finalizeETHWithdrawal.selector,
3                _from,
4                _to,
5                _amount,
6                _data
7            );
8        } else {
9            message = abi.encodeWithSelector(
10                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
11                l1Token,
12                _l2Token,
13                _from,
14                _to,
15                _amount,
16                _data
17            );
18        }
19
20        // L1 브리지로 메시지 전송
21        // slither-disable-next-line reentrancy-events
22        sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
23
24        // slither-disable-next-line reentrancy-events
25        emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);
26    }
27
28    /************************************
29     * 교차 체인 함수: 예치 *
30     ************************************/
31
32    /**
33     * @inheritdoc IL2ERC20Bridge
34     */
35    function finalizeDeposit(
36        address _l1Token,
37        address _l2Token,
38        address _from,
39        address _to,
40        uint256 _amount,
41        bytes calldata _data
모두 보기
복사

1    ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
복사

1        // 대상 토큰이 규정을 준수하는지 확인하고
2        // L1에 예치된 토큰이 여기의 L2 예치 토큰 표현과 일치하는지 확인합니다
3        if (
4            // slither-disable-next-line reentrancy-events
5            ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
6            _l1Token == IL2StandardERC20(_l2Token).l1Token()
복사

1        ) {
2            // 예치가 완료되면 L2의 계정에 동일한 양의
3            // 토큰을 입금합니다.
4            // slither-disable-next-line reentrancy-events
5            IL2StandardERC20(_l2Token).mint(_to, _amount);
6            // slither-disable-next-line reentrancy-events
7            emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
복사

1        } else {
2            // 예치되는 L2 토큰이 L1 토큰의 올바른 주소에
3            // 동의하지 않거나 올바른 인터페이스를 지원하지 않습니다.
4            // 이것은 악의적인 L2 토큰이 있거나 사용자가 어떻게든
5            // 잘못된 L2 토큰 주소를 지정하여 예치한 경우에만 발생해야 합니다.
6            // 어느 경우든 여기서 프로세스를 중지하고 인출
7            // 메시지를 구성하여 사용자가 경우에 따라 자금을 꺼낼 수 있도록 합니다.
8            // 악의적인 토큰 컨트랙트를 완전히 막을 방법은 없지만, 이는 사용자
9            // 오류를 제한하고 일부 형태의 악의적인 컨트랙트 동작을 완화합니다.
모두 보기
복사

1            bytes memory message = abi.encodeWithSelector(
2                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
3                _l1Token,
4                _l2Token,
5                _to, // 예치를 발신자에게 반송하기 위해 여기서 _to와 _from을 바꿈
6                _from,
7                _amount,
8                _data
9            );
10
11            // L1 브리지로 메시지 전송
12            // slither-disable-next-line reentrancy-events
13            sendCrossDomainMessage(l1TokenBridge, 0, message);
14            // slither-disable-next-line reentrancy-events
15            emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
16        }
17    }
18}
모두 보기
복사