ऑप्टिमिज्म स्टैंडर्ड ब्रिज कॉन्ट्रैक्ट वॉकथ्रू

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 L2 पर कॉलर की शेष राशि में ERC20 की राशि जमा करें।
3     * @param _l1Token हम जिस L1 ERC20 को जमा कर रहे हैं उसका पता
4     * @param _l2Token L1 संबंधित 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 L2 पर प्राप्तकर्ता की शेष राशि में ERC20 की राशि जमा करें।
3     * @param _l1Token हम जिस L1 ERC20 को जमा कर रहे हैं उसका पता
4     * @param _l2Token L1 संबंधित 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 L1 टोकन का पता जिसके लिए finalizeWithdrawal करना है।
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 L2 पर प्राप्तकर्ता की शेष राशि में ETH की राशि जमा करें।
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: messenger contract unauthenticated"
4        );
कॉपी करें

1
2        require(
3            getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
4            "OVM_XCHAIN: wrong sender of cross-domain message"
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 लक्ष्य को भेजने के लिए डेटा (आमतौर पर `onlyFromCrossDomainAccount()` के साथ एक फ़ंक्शन के लिए calldata)
6     * @param _gasLimit लक्ष्य डोमेन पर संदेश की रसीद के लिए gasLimit।
7     */
8    function sendCrossDomainMessage(
9        address _crossDomainTarget,
10        uint32 _gasLimit,
11        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 ब्रिज एक अनुबंध है जो जमा किए गए L1 फंड और L2 पर उपयोग में आने वाले स्टैंडर्ड टोकन को संग्रहीत करता है।
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 टोकन की शेष राशि के लिए L1 टोकन को L2 टोकन से मैप करता है
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 Messenger पता जिसका उपयोग क्रॉस-चेन संचार के लिए किया जा रहा है।
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), "Contract has already been initialized.");
कॉपी करें

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), "Account not EOA");
12        _;
13    }
सभी दिखाएँ
कॉपी करें

1    /**
2     * @dev इस फ़ंक्शन को बिना किसी डेटा के कॉल किया जा सकता है
3     * L2 पर कॉलर की शेष राशि में ETH की राशि जमा करने के लिए।
4     * चूंकि प्राप्त फ़ंक्शन डेटा नहीं लेता है, एक रूढ़िवादी
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 कॉल के लिए calldata का निर्माण करें
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 में calldata भेजें
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 L1 संबंधित 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) के लिए calldata का निर्माण करें
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 में calldata भेजें
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 transfer failed");
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, "Only L2 Bridge can mint and burn");
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 स्टैंडर्ड ब्रिज के साथ मिलकर काम करता है
12 * L1 और L2 के बीच ETH और ERC20 संक्रमण को सक्षम करने के लिए।
13 * यह अनुबंध नए टोकन के लिए एक मिंटर के रूप में कार्य करता है जब यह L1 स्टैंडर्ड में जमा के बारे में सुनता है
14 * ब्रिज।
15 * यह अनुबंध निकासी के लिए इच्छित टोकन के बर्नर के रूप में भी कार्य करता है, L1 को सूचित करता है
16 * L1 फंड जारी करने के लिए ब्रिज।
17 */
18contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
19    /********************************
20     * बाहरी अनुबंध संदर्भ *
21     ********************************/
22
23    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 टोकन को बर्न करके और सूचित करके निकासी के लिए तर्क करता है
4     *      निकासी के L1 टोकन गेटवे।
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        // उपयोग
24        // slither-disable-next-line reentrancy-events
25        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
सभी दिखाएँ
कॉपी करें

1
2        // l1TokenBridge.finalizeERC20Withdrawal(_to, _amount) के लिए calldata का निर्माण करें
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}
सभी दिखाएँ
कॉपी करें