Optimism standart köprü sözleşmesi incelemesi

/**
 * @title IL1ERC20Bridge
 */
interface IL1ERC20Bridge {
    /**********
     * Olaylar *
     **********/

    event ERC20DepositInitiated(

    /********************
     * Genel Fonksiyonlar *
     ********************/

    /**
     * @dev ilgili l2 köprü Sözleşmesinin Adresini getirir.
     * @return İlgili l2 köprü Sözleşmesinin Adresi.
     */
    function l2TokenBridge() external returns (address);

    /**
     * @dev l2 üzerindeki çağırıcının bakiyesine bir miktar ERC-20 yatırır.
     * @param _l1Token Yatırmakta olduğumuz l1 ERC-20 Adresi
     * @param _l2Token l1'in ilgili l2 ERC-20 Adresi
     * @param _amount Yatırılacak ERC-20 miktarı
     * @param _l2Gas l2 üzerinde yatırma işlemini tamamlamak için gereken Gaz limiti.
     * @param _data l2'ye iletilecek isteğe bağlı veri. Bu veri yalnızca
     *        harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *        uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    function depositERC20(
        address _l1Token,
        address _l2Token,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /**
     * @dev l2 üzerindeki bir alıcının bakiyesine bir miktar ERC-20 yatırır.
     * @param _l1Token Yatırmakta olduğumuz l1 ERC-20 Adresi
     * @param _l2Token l1'in ilgili l2 ERC-20 Adresi
     * @param _to Çekim işleminin alacaklandırılacağı l2 Adresi.
     * @param _amount Yatırılacak ERC-20 miktarı.
     * @param _l2Gas l2 üzerinde yatırma işlemini tamamlamak için gereken Gaz limiti.
     * @param _data l2'ye iletilecek isteğe bağlı veri. Bu veri yalnızca
     *        harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *        uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    function depositERC20To(
        address _l1Token,
        address _l2Token,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) external;

    /*************************
     * Zincirler Arası Fonksiyonlar *
     *************************/

    /**
     * @dev l2'den l1'e bir çekim işlemini tamamlar ve fonları alıcının
     * l1 ERC-20 Token bakiyesine alacak kaydeder.
     * l2'den başlatılan çekim işlemi sonuçlandırılmamışsa bu çağrı başarısız olur.
     *
     * @param _l1Token finalizeWithdrawal yapılacak l1 Token Adresi.
     * @param _l2Token Çekim işleminin başlatıldığı l2 Token Adresi.
     * @param _from Transferi başlatan l2 Adresi.
     * @param _to Çekim işleminin alacaklandırılacağı l1 Adresi.
     * @param _amount Yatırılacak ERC-20 miktarı.
     * @param _data l2 üzerinde gönderici tarafından sağlanan veri. Bu veri yalnızca
     *   harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *   uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    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 {
    /**********
     * Olaylar *
     **********/
    event ETHDepositInitiated(
        address indexed _from,
        address indexed _to,
        uint256 _amount,
        bytes _data
    );

    event ETHWithdrawalFinalized(
        .
        .
        .
    );

    /********************
     * Genel Fonksiyonlar *
     ********************/

    /**
     * @dev l2 üzerindeki çağırıcının bakiyesine bir miktar ETH yatırır.
            .
            .
            .
     */
    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;

    /**
     * @dev l2 üzerindeki bir alıcının bakiyesine bir miktar ETH yatırır.
            .
            .
            .
     */
    function depositETHTo(
        address _to,
        uint32 _l2Gas,
        bytes calldata _data
    ) external payable;

    /*************************
     * Zincirler Arası Fonksiyonlar *
     *************************/

    /**
     * @dev l2'den l1'e bir çekim işlemini tamamlar ve fonları alıcının
     * l1 ETH Token bakiyesine alacak kaydeder. Bu fonksiyonu yalnızca xDomainMessenger çağırabildiğinden, çekim işlemi sonuçlandırılmadan
     * önce asla çağrılmayacaktır.
                .
                .
                .
     */
    function finalizeETHWithdrawal(
        address _from,
        address _to,
        uint256 _amount,
        bytes calldata _data
    ) external;
}

/**
 * @title CrossDomainEnabled
 * @dev Etki alanları arası iletişim gerçekleştiren Sözleşmeler için yardımcı Sözleşme
 *
 * Kullanılan derleyici: devralan Sözleşme tarafından tanımlanır
 */
contract CrossDomainEnabled {
    /*************
     * Değişkenler *
     *************/

    // Diğer etki alanından mesaj göndermek ve almak için kullanılan haberci Sözleşme.
    address public messenger;

    /***************
     * Kurucu *
     ***************/

    /**
     * @param _messenger Mevcut katmandaki CrossDomainMessenger Adresi.
     */
    constructor(address _messenger) {
        messenger = _messenger;
    }

    /**********************
     * Fonksiyon Değiştiricileri *
     **********************/

    /**
     * Değiştirilen fonksiyonun yalnızca belirli bir etki alanları arası hesap tarafından çağrılabilmesini zorunlu kılar.
     * @param _sourceDomainAccount Kaynak etki alanında bu fonksiyonu çağırmak için
     *  kimliği doğrulanmış tek hesap.
     */
    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {

        _;
    }

    /**********************
     * Dahili Fonksiyonlar *
     **********************/

    /**
     * Genellikle depolamadan haberciyi alır. Bu fonksiyon, bir alt Sözleşmenin
     * geçersiz kılması (override) gerekebileceği durumu için dışa aktarılmıştır.
     * @return Kullanılması gereken etki alanları arası haberci Sözleşme Adresi.
     */
    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
        return ICrossDomainMessenger(messenger);
    }

    /**
     * Başka bir etki alanındaki bir hesaba mesaj gönderir
     * @param _crossDomainTarget Hedef etki alanındaki amaçlanan alıcı
     * @param _message Hedefe gönderilecek veri (genellikle `onlyFromCrossDomainAccount()` içeren
     *  bir fonksiyona çağrı verisi)
     * @param _gasLimit Hedef etki alanında mesajın alınması için Gaz limiti.
     */
    function sendCrossDomainMessage(
        address _crossDomainTarget,
        uint32 _gasLimit,
        bytes memory _message

/**
 * @title L1StandardBridge
 * @dev l1 ETH ve ERC-20 köprüsü, yatırılan l1 fonlarını ve l2 üzerinde kullanımda olan standart
 * Token'ları depolayan bir Sözleşmedir. İlgili bir l2 köprüsünü senkronize eder, onu yatırma işlemleri hakkında bilgilendirir
 * ve yeni sonuçlandırılan çekim işlemleri için onu dinler.
 *
 */
contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
    using SafeERC20 for IERC20;

    /******************
     * Başlatma *
     ******************/

    /**
     * @param _l1messenger Zincirler arası iletişim için kullanılan l1 Haberci Adresi.
     * @param _l2TokenBridge l2 standart köprü Adresi.
     */
    // slither-disable-next-line external-function

    /**************
     * Yatırma *
     **************/

    /** @dev Göndericinin EOA olmasını require eden değiştirici. Bu kontrol kötü niyetli bir
     *  Sözleşme tarafından initcode aracılığıyla atlanabilir, ancak kaçınmak istediğimiz kullanıcı hatasını halleder.
     */
    modifier onlyEOA() {
        // Sözleşmelerden gelen yatırma işlemlerini durdurmak için kullanılır (yanlışlıkla kaybolan Token'ları önlemek için)
        require(!Address.isContract(msg.sender), "Account not EOA");
        _;
    }

    /**
     * @dev Bu fonksiyon, l2 üzerindeki çağırıcının bakiyesine bir miktar ETH yatırmak için
     * veri olmadan çağrılabilir.
     * receive fonksiyonu veri almadığından, l2'ye muhafazakar bir
     * varsayılan miktar iletilir.
     */
    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'yi depolayarak ve l2 ETH Ağ Geçidini yatırma işlemi hakkında bilgilendirerek
     * yatırma işlemleri için mantığı gerçekleştirir.
     * @param _from l1 üzerinde yatırma işleminin çekileceği hesap.
     * @param _to l2 üzerinde yatırma işleminin verileceği hesap.
     * @param _l2Gas l2 üzerinde yatırma işlemini tamamlamak için gereken Gaz limiti.
     * @param _data l2'ye iletilecek isteğe bağlı veri. Bu veri yalnızca
     *        harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *        uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    function _initiateETHDeposit(
        address _from,
        address _to,
        uint32 _l2Gas,
        bytes memory _data
    ) internal {
        // finalizeDeposit çağrısı için çağrı verisi oluştur
        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 Yatırılan Token Sözleşmesini yatırma işlemi hakkında bilgilendirerek
     * ve l1 fonlarını kilitlemek için bir işleyici çağırarak (örn. transferFrom) yatırma işlemleri için mantığı gerçekleştirir.
     *
     * @param _l1Token Yatırmakta olduğumuz l1 ERC-20 Adresi
     * @param _l2Token l1'in ilgili l2 ERC-20 Adresi
     * @param _from l1 üzerinde yatırma işleminin çekileceği hesap
     * @param _to l2 üzerinde yatırma işleminin verileceği hesap
     * @param _amount Yatırılacak ERC-20 miktarı.
     * @param _l2Gas l2 üzerinde yatırma işlemini tamamlamak için gereken Gaz limiti.
     * @param _data l2'ye iletilecek isteğe bağlı veri. Bu veri yalnızca
     *        harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *        uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    function _initiateERC20Deposit(
        address _l1Token,
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l2Gas,
        bytes calldata _data
    ) internal {

        // _l2Token.finalizeDeposit(_to, _amount) için çağrı verisi oluştur
        bytes memory message = abi.encodeWithSelector(
            IL2ERC20Bridge.finalizeDeposit.selector,
            _l1Token,
            _l2Token,
            _from,
            _to,
            _amount,
            _data
        );

        // çağrı verisini l2'ye gönder
        // 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);
    }

    /*************************
     * Zincirler Arası Fonksiyonlar *
     *************************/

    /**
     * @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 üzerinde bir çekim işlemi sonuçlandırıldığında, l1 köprüsü fonları çeken kişiye transfer eder
        // 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);
    }


    /*****************************
     * Geçici - ETH Taşıma *
     *****************************/

    /**
     * @dev Hesaba ETH bakiyesi ekler. Bu, ETH'nin eski bir ağ geçidinden
     * yeni bir ağ geçidine taşınmasına izin vermek içindir.
     * NOT: Bu yalnızca bir yükseltme için bırakılmıştır, böylece taşınan ETH'yi eski
     * Sözleşmeden alabiliriz
     */
    function donateETH() external payable {}
}

    /**
     * @param _l2Bridge l2 standart köprü Adresi.
     * @param _l1Token İlgili l1 Token Adresi.
     * @param _name ERC-20 adı.
     * @param _symbol ERC-20 sembolü.
     */
    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);
    }
}

/* Kütüphane İçe Aktarımları */
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";

/* Sözleşme İçe Aktarımları */
import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";

/**
 * @title L2StandardBridge
 * @dev l2 Standart köprü, l1 ve l2 arasında ETH ve ERC-20 geçişlerini sağlamak için
 * l1 Standart köprü ile birlikte çalışan bir Sözleşmedir.
 * Bu Sözleşme, l1 Standart köprüsüne yapılan yatırma işlemlerini duyduğunda yeni Token'ları basmak için görev yapar.
 * Bu Sözleşme ayrıca çekim işlemi için amaçlanan Token'ların yakımını gerçekleştirerek l1
 * köprüsünü l1 fonlarını serbest bırakması için bilgilendirir.
 */
contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
    /********************************
     * Harici Sözleşme Referansları *
     ********************************/

    address public l1TokenBridge;

    /***************
     * Kurucu *
     ***************/

    /**
     * @param _l2CrossDomainMessenger Bu Sözleşme tarafından kullanılan etki alanları arası haberci.
     * @param _l1TokenBridge Ana zincire dağıtılan l1 köprü Adresi.
     */
    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
        CrossDomainEnabled(_l2CrossDomainMessenger)
    {
        l1TokenBridge = _l1TokenBridge;
    }

    /***************
     * Çekim İşlemi *
     ***************/

    /**
     * @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 Token yakımı yaparak ve l1 Token Ağ Geçidini çekim işlemi hakkında bilgilendirerek
     *      çekim işlemleri için mantığı gerçekleştirir.
     * @param _l2Token Çekim işleminin başlatıldığı l2 Token Adresi.
     * @param _from l2 üzerinde çekim işleminin çekileceği hesap.
     * @param _to l1 üzerinde çekim işleminin verileceği hesap.
     * @param _amount Çekilecek Token miktarı.
     * @param _l1Gas Kullanılmaz, ancak olası ileriye dönük uyumluluk hususları için dahil edilmiştir.
     * @param _data l1'e iletilecek isteğe bağlı veri. Bu veri yalnızca
     *        harici Sözleşmeler için bir kolaylık olarak sağlanır. Maksimum bir
     *        uzunluğu zorunlu kılmak dışında, bu Sözleşmeler içeriği hakkında hiçbir garanti vermez.
     */
    function _initiateWithdrawal(
        address _l2Token,
        address _from,
        address _to,
        uint256 _amount,
        uint32 _l1Gas,
        bytes calldata _data
    ) internal {
        // Bir çekim işlemi başlatıldığında, sonraki l2
        // kullanımını önlemek için çeken kişinin fonlarının yakımını gerçekleştiririz
        // 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 köprüsüne mesaj gönder
        // 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);
    }

    /************************************
     * Zincirler Arası Fonksiyon: Yatırma *
     ************************************/

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

        } else {
            // Ya yatırma işlemi yapılan l2 Token'ı, l1 Token'ının doğru Adresi
            // konusunda uyuşmuyor ya da doğru arayüzü desteklemiyor.
            // Bu yalnızca kötü niyetli bir l2 Token'ı varsa veya bir kullanıcı bir şekilde
            // yatırma işlemi yapmak için yanlış l2 Token Adresini belirtmişse gerçekleşmelidir.
            // Her iki durumda da, işlemi burada durdururuz ve bir çekim işlemi
            // mesajı oluştururuz, böylece kullanıcılar bazı durumlarda fonlarını geri alabilirler.
            // Kötü niyetli Token Sözleşmelerini tamamen önlemenin bir yolu yoktur, ancak bu
            // kullanıcı hatasını sınırlar ve bazı kötü niyetli Sözleşme davranış biçimlerini hafifletir.

            bytes memory message = abi.encodeWithSelector(
                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
                _l1Token,
                _l2Token,
                _to, // yatırılan miktarı göndericiye geri döndürmek için burada _to ve _from değiştirildi
                _from,
                _amount,
                _data
            );

            // l1 köprüsüne mesaj gönder
            // slither-disable-next-line reentrancy-events
            sendCrossDomainMessage(l1TokenBridge, 0, message);
            // slither-disable-next-line reentrancy-events
            emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
        }
    }
}