آپٹیمزم (Optimism) کے معیاری برج کنٹریکٹ کا جائزہ

1// SPDX-License-Identifier: MIT
کاپی کریں

1pragma solidity >0.5.0 <0.9.0;
کاپی کریں

1/* *
2 * @title IL1ERC20Bridge */
3interface IL1ERC20Bridge {
4    /* *********
5     * ایونٹس *
6     ********* */
7
8    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    function l2TokenBridge() external returns (address);
سب دکھائیںکاپی کریں

1    /* *
2     * @dev کالر کے L2 بیلنس میں ERC20 کی ایک رقم جمع (deposit) کریں۔
3     * @param _l1Token اس L1 ERC20 کا ایڈریس جو ہم جمع کر رہے ہیں
4     * @param _l2Token L1 کے متعلقہ L2 ERC20 کا ایڈریس
5     * @param _amount جمع کرنے کے لیے ERC20 کی رقم
6     * @param _l2Gas L2 پر ڈپازٹ مکمل کرنے کے لیے درکار گیس لمٹ (Gas limit)۔
7     * @param _data L2 کو بھیجنے کے لیے اختیاری ڈیٹا۔ یہ ڈیٹا بیرونی کنٹریکٹس کی سہولت کے لیے
8     *        فراہم کیا گیا ہے۔ زیادہ سے زیادہ لمبائی نافذ کرنے کے علاوہ، یہ کنٹریکٹس اس کے مواد کی کوئی ضمانت نہیں دیتے۔ */
9    function depositERC20(
10        address _l1Token,
11        address _l2Token,
12        uint256 _amount,
13        uint32 _l2Gas,
14        bytes calldata _data
15    ) external;
سب دکھائیںکاپی کریں

1    /* *
2     * @dev وصول کنندہ کے L2 بیلنس میں ERC20 کی ایک رقم جمع (deposit) کریں۔
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    function depositERC20To(
11        address _l1Token,
12        address _l2Token,
13        address _to,
14        uint256 _amount,
15        uint32 _l2Gas,
16        bytes calldata _data
17    ) external;
سب دکھائیںکاپی کریں

1    /* ************************
2     * کراس چین فنکشنز *
3     ************************ */
4
5    /* *
6     * @dev L2 سے L1 میں واپسی (withdrawal) مکمل کریں، اور وصول کنندہ کے L1 ERC20 ٹوکن کے بیلنس میں فنڈز جمع کریں۔
7     * یہ کال ناکام ہو جائے گی اگر L2 سے شروع کی گئی واپسی کو حتمی شکل (finalized) نہیں دی گئی ہے۔
8     *
9     * @param _l1Token L1 ٹوکن کا ایڈریس جس کے لیے finalizeWithdrawal کرنا ہے۔
10     * @param _l2Token L2 ٹوکن کا ایڈریس جہاں سے واپسی شروع کی گئی تھی۔
11     * @param _from L2 ایڈریس جو ٹرانسفر شروع کر رہا ہے۔
12     * @param _to L1 ایڈریس جس پر واپسی کی رقم جمع کرنی ہے۔
13     * @param _amount جمع کرنے کے لیے ERC20 کی رقم۔
14     * @param _data L2 پر بھیجنے والے کی طرف سے فراہم کردہ ڈیٹا۔ یہ ڈیٹا بیرونی کنٹریکٹس کی سہولت کے لیے
15     *   فراہم کیا گیا ہے۔ زیادہ سے زیادہ لمبائی نافذ کرنے کے علاوہ، یہ کنٹریکٹس اس کے مواد کی کوئی ضمانت نہیں دیتے۔ */
16    function finalizeERC20Withdrawal(
17        address _l1Token,
18        address _l2Token,
19        address _from,
20        address _to,
21        uint256 _amount,
22        bytes calldata _data
23    ) external;
24}
سب دکھائیںکاپی کریں

1// SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4import "./IL1ERC20Bridge.sol";
5
6/* *
7 * @title IL1StandardBridge */
8interface IL1StandardBridge is IL1ERC20Bridge {
9    /* *********
10     * ایونٹس *
11     ********* */
12    event ETHDepositInitiated(
13        address indexed _from,
14        address indexed _to,
15        uint256 _amount,
16        bytes _data
17    );
سب دکھائیںکاپی کریں

1    event ETHWithdrawalFinalized(
2        .
3        .
4        .
5    );
6
7    /* *******************
8     * پبلک فنکشنز *
9     ******************* */
10
11    /* *
12     * @dev کالر کے L2 بیلنس میں ETH کی ایک رقم جمع (deposit) کریں۔
13            .
14            .
15            . */
16    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
17
18    /* *
19     * @dev وصول کنندہ کے L2 بیلنس میں ETH کی ایک رقم جمع (deposit) کریں۔
20            .
21            .
22            . */
23    function depositETHTo(
24        address _to,
25        uint32 _l2Gas,
26        bytes calldata _data
27    ) external payable;
28
29    /* ************************
30     * کراس چین فنکشنز *
31     ************************ */
32
33    /* *
34     * @dev L2 سے L1 میں واپسی (withdrawal) مکمل کریں، اور وصول کنندہ کے L1 ETH ٹوکن کے بیلنس میں فنڈز جمع کریں۔ چونکہ صرف xDomainMessenger اس فنکشن کو کال کر سکتا ہے، اس لیے اسے کبھی بھی
35     * واپسی کے حتمی ہونے سے پہلے کال نہیں کیا جائے گا۔
36                .
37                .
38                . */
39    function finalizeETHWithdrawal(
40        address _from,
41        address _to,
42        uint256 _amount,
43        bytes calldata _data
44    ) external;
45}
سب دکھائیںکاپی کریں

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 * استعمال شدہ کمپائلر: وراثت میں ملنے والے (inheriting) کنٹریکٹ کے ذریعے بیان کیا گیا ہے */
6contract CrossDomainEnabled {
7    /* ************
8     * ویری ایبلز *
9     ************ */
10
11    // میسنجر کنٹریکٹ جو دوسرے ڈومین سے پیغامات بھیجنے اور وصول کرنے کے لیے استعمال ہوتا ہے۔
12    address public messenger;
13
14    /* **************
15     * کنسٹرکٹر *
16     ************** */
17
18    /* *
19     * @param _messenger موجودہ لیئر پر CrossDomainMessenger کا ایڈریس۔ */
20    constructor(address _messenger) {
21        messenger = _messenger;
22    }
سب دکھائیںکاپی کریں

1
2    /* *********************
3     * فنکشن موڈیفائرز *
4     ********************* */
5
6    /* *
7     * یہ یقینی بناتا ہے کہ موڈیفائیڈ فنکشن کو صرف ایک مخصوص کراس ڈومین اکاؤنٹ ہی کال کر سکتا ہے۔
8     * @param _sourceDomainAccount اصل ڈومین پر واحد اکاؤنٹ جو
9     *  اس فنکشن کو کال کرنے کا مجاز ہے۔ */
10    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     * اوور رائیڈ (override) کرنے کی ضرورت ہو۔
12     * @return کراس ڈومین میسنجر کنٹریکٹ کا ایڈریس جسے استعمال کیا جانا چاہیے۔ */
13    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
14        return ICrossDomainMessenger(messenger);
15    }
سب دکھائیںکاپی کریں

1
2    /* *
3     * کسی دوسرے ڈومین پر موجود اکاؤنٹ کو پیغام بھیجتا ہے
4     * @param _crossDomainTarget منزل کے ڈومین پر مطلوبہ وصول کنندہ
5     * @param _message ہدف کو بھیجا جانے والا ڈیٹا (عام طور پر `onlyFromCrossDomainAccount()` والے فنکشن کے لیے calldata)
6     * @param _gasLimit ہدف کے ڈومین پر پیغام کی وصولی کے لیے gasLimit۔ */
7    function sendCrossDomainMessage(
8        address _crossDomainTarget,
9        uint32 _gasLimit,
10        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 فنڈز اور معیاری
4 * ٹوکنز کو اسٹور کرتا ہے جو L2 پر استعمال ہو رہے ہیں۔ یہ متعلقہ L2 برج کو ہم آہنگ (synchronize) کرتا ہے، اسے ڈپازٹس کے بارے میں مطلع کرتا ہے
5 * اور نئی حتمی شکل دی گئی واپسیوں (withdrawals) کے لیے اسے سنتا ہے۔
6 * */
7contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
8    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    // 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    modifier onlyEOA() {
9        // کنٹریکٹس سے ڈپازٹس کو روکنے کے لیے استعمال کیا جاتا ہے (غلطی سے ٹوکنز کے ضائع ہونے سے بچنے کے لیے)
10        require(!Address.isContract(msg.sender), "Account not EOA");
11        _;
12    }
سب دکھائیںکاپی کریں

1    /* *
2     * @dev اس فنکشن کو بغیر کسی ڈیٹا کے کال کیا جا سکتا ہے
3     * تاکہ کالر کے L2 بیلنس میں ETH کی ایک رقم جمع کی جا سکے۔
4     * چونکہ receive فنکشن ڈیٹا نہیں لیتا، اس لیے ایک محتاط
5     * ڈیفالٹ رقم L2 کو بھیج دی جاتی ہے۔ */
6    receive() external payable onlyEOA {
7        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
8    }
کاپی کریں

1    /* *
2     * @inheritdoc IL1StandardBridge */
3    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
4        _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
5    }
6
7    /* *
8     * @inheritdoc IL1StandardBridge */
9    function depositETHTo(
10        address _to,
11        uint32 _l2Gas,
12        bytes calldata _data
13    ) external payable {
14        _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
15    }
سب دکھائیںکاپی کریں

1    /* *
2     * @dev ETH کو اسٹور کر کے اور L2 ETH گیٹ وے کو ڈپازٹ کے بارے میں مطلع کر کے ڈپازٹس کی لاجک انجام دیتا ہے۔
3     * @param _from وہ اکاؤنٹ جس سے L1 پر ڈپازٹ لیا جائے گا۔
4     * @param _to وہ اکاؤنٹ جسے L2 پر ڈپازٹ دیا جائے گا۔
5     * @param _l2Gas L2 پر ڈپازٹ مکمل کرنے کے لیے درکار گیس لمٹ۔
6     * @param _data L2 کو بھیجنے کے لیے اختیاری ڈیٹا۔ یہ ڈیٹا بیرونی کنٹریکٹس کی سہولت کے لیے
7     *        فراہم کیا گیا ہے۔ زیادہ سے زیادہ لمبائی نافذ کرنے کے علاوہ، یہ کنٹریکٹس اس کے مواد کی کوئی ضمانت نہیں دیتے۔ */
8    function _initiateETHDeposit(
9        address _from,
10        address _to,
11        uint32 _l2Gas,
12        bytes memory _data
13    ) internal {
14        // finalizeDeposit کال کے لیے calldata بنائیں
15        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        // calldata کو 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    function depositERC20(
4		.
5		.
6		.
7    ) external virtual onlyEOA {
8        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
9    }
10
11    /* *
12     * @inheritdoc IL1ERC20Bridge */
13    function depositERC20To(
14		.
15		.
16		.
17    ) external virtual {
18        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
19    }
سب دکھائیںکاپی کریں

1    /* *
2     * @dev L2 Deposited Token کنٹریکٹ کو ڈپازٹ کے بارے میں مطلع کر کے اور L1 فنڈز کو لاک کرنے کے لیے ہینڈلر کو کال کر کے (جیسے transferFrom) ڈپازٹس کی لاجک انجام دیتا ہے۔
3     *
4     * @param _l1Token اس L1 ERC20 کا ایڈریس جو ہم جمع کر رہے ہیں
5     * @param _l2Token L1 کے متعلقہ L2 ERC20 کا ایڈریس
6     * @param _from وہ اکاؤنٹ جس سے L1 پر ڈپازٹ لیا جائے گا
7     * @param _to وہ اکاؤنٹ جسے L2 پر ڈپازٹ دیا جائے گا
8     * @param _amount جمع کرنے کے لیے ERC20 کی رقم۔
9     * @param _l2Gas L2 پر ڈپازٹ مکمل کرنے کے لیے درکار گیس لمٹ۔
10     * @param _data L2 کو بھیجنے کے لیے اختیاری ڈیٹا۔ یہ ڈیٹا بیرونی کنٹریکٹس کی سہولت کے لیے
11     *        فراہم کیا گیا ہے۔ زیادہ سے زیادہ لمبائی نافذ کرنے کے علاوہ، یہ کنٹریکٹس اس کے مواد کی کوئی ضمانت نہیں دیتے۔ */
12    function _initiateERC20Deposit(
13        address _l1Token,
14        address _l2Token,
15        address _from,
16        address _to,
17        uint256 _amount,
18        uint32 _l2Gas,
19        bytes calldata _data
20    ) internal {
سب دکھائیںکاپی کریں

1        // جب L1 پر ڈپازٹ شروع کیا جاتا ہے، تو L1 برج مستقبل کی
2        // واپسیوں (withdrawals) کے لیے فنڈز اپنے پاس ٹرانسفر کر لیتا ہے۔ 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        // calldata کو 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    function finalizeETHWithdrawal(
13        address _from,
14        address _to,
15        uint256 _amount,
16        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    function finalizeERC20Withdrawal(
6        address _l1Token,
7        address _l2Token,
8        address _from,
9        address _to,
10        uint256 _amount,
11        bytes calldata _data
12    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
سب دکھائیںکاپی کریں

1        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
کاپی کریں

1
2        // جب L1 پر واپسی (withdrawal) کو حتمی شکل دی جاتی ہے، تو 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 کی منتقلی (Migrating ETH) *
13     **************************** */
14
15    /* *
16     * @dev اکاؤنٹ میں ETH بیلنس کا اضافہ کرتا ہے۔ اس کا مقصد ETH کو
17     * پرانے گیٹ وے سے نئے گیٹ وے پر منتقل کرنے کی اجازت دینا ہے۔
18     * نوٹ: اسے صرف ایک اپ گریڈ کے لیے چھوڑا گیا ہے تاکہ ہم پرانے کنٹریکٹ سے
19     * منتقل شدہ ETH وصول کر سکیں۔ */
20    function donateETH() external payable {}
21}
سب دکھائیںکاپی کریں

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 کی علامت (symbol)۔ */
7    constructor(
8        address _l2Bridge,
9        address _l1Token,
10        string memory _name,
11        string memory _symbol
12    ) ERC20(_name, _symbol) {
13        l1Token = _l1Token;
14        l2Bridge = _l2Bridge;
15    }
سب دکھائیںکاپی کریں

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 * یہ کنٹریکٹ نئے ٹوکنز کے لیے منٹر (minter) کے طور پر کام کرتا ہے جب اسے L1 اسٹینڈرڈ برج میں
14 * ڈپازٹس کے بارے میں معلوم ہوتا ہے۔
15 * یہ کنٹریکٹ واپسی (withdrawal) کے لیے مطلوبہ ٹوکنز کو برن (burn) کرنے کا کام بھی کرتا ہے، اور L1
16 * برج کو L1 فنڈز جاری کرنے کی اطلاع دیتا ہے۔ */
17contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
18    /* *******************************
19     * ایکسٹرنل کنٹریکٹ ریفرنسز *
20     ******************************* */
21
22    address public l1TokenBridge;
سب دکھائیںکاپی کریں

1
2    /* **************
3     * کنسٹرکٹر *
4     ************** */
5
6    /* *
7     * @param _l2CrossDomainMessenger اس کنٹریکٹ کے ذریعے استعمال ہونے والا کراس ڈومین میسنجر۔
8     * @param _l1TokenBridge مین چین پر تعینات (deployed) L1 برج کا ایڈریس۔ */
9    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
10        CrossDomainEnabled(_l2CrossDomainMessenger)
11    {
12        l1TokenBridge = _l1TokenBridge;
13    }
14
15    /* **************
16     * ود ڈرائنگ (Withdrawing) *
17     ************** */
18
19    /* *
20     * @inheritdoc IL2ERC20Bridge */
21    function withdraw(
22        address _l2Token,
23        uint256 _amount,
24        uint32 _l1Gas,
25        bytes calldata _data
26    ) external virtual {
27        _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
28    }
29
30    /* *
31     * @inheritdoc IL2ERC20Bridge */
32    function withdrawTo(
33        address _l2Token,
34        address _to,
35        uint256 _amount,
36        uint32 _l1Gas,
37        bytes calldata _data
38    ) external virtual {
39        _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
40    }
سب دکھائیںکاپی کریں

1
2    /* *
3     * @dev ٹوکن کو برن کر کے اور L1 ٹوکن گیٹ وے کو واپسی (withdrawal) کے بارے میں مطلع کر کے
4     *      واپسی کی لاجک انجام دیتا ہے۔
5     * @param _l2Token L2 ٹوکن کا ایڈریس جہاں سے واپسی شروع کی گئی ہے۔
6     * @param _from وہ اکاؤنٹ جس سے L2 پر واپسی لی جائے گی۔
7     * @param _to وہ اکاؤنٹ جسے L1 پر واپسی دی جائے گی۔
8     * @param _amount نکالنے کے لیے ٹوکن کی رقم۔
9     * @param _l1Gas غیر استعمال شدہ، لیکن ممکنہ مستقبل کی مطابقت (forward compatibility) کے پیش نظر شامل کیا گیا ہے۔
10     * @param _data L1 کو بھیجنے کے لیے اختیاری ڈیٹا۔ یہ ڈیٹا بیرونی کنٹریکٹس کی سہولت کے لیے
11     *        فراہم کیا گیا ہے۔ زیادہ سے زیادہ لمبائی نافذ کرنے کے علاوہ، یہ کنٹریکٹس اس کے مواد کی کوئی ضمانت نہیں دیتے۔ */
12    function _initiateWithdrawal(
13        address _l2Token,
14        address _from,
15        address _to,
16        uint256 _amount,
17        uint32 _l1Gas,
18        bytes calldata _data
19    ) internal {
20        // جب واپسی شروع کی جاتی ہے، تو ہم نکالنے والے کے فنڈز کو برن کر دیتے ہیں تاکہ بعد میں L2 پر
21        // استعمال کو روکا جا سکے
22        // slither-disable-next-line reentrancy-events
23        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    function finalizeDeposit(
35        address _l1Token,
36        address _l2Token,
37        address _from,
38        address _to,
39        uint256 _amount,
40        bytes calldata _data
سب دکھائیںکاپی کریں

1    ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
کاپی کریں

1        // چیک کریں کہ ٹارگٹ ٹوکن مطابقت رکھتا ہے (compliant) اور
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            // دونوں صورتوں میں، ہم یہاں عمل کو روک دیتے ہیں اور ایک واپسی (withdrawal) کا
7            // پیغام بناتے ہیں تاکہ صارفین کچھ صورتوں میں اپنے فنڈز نکال سکیں۔
8            // بدنیتی پر مبنی ٹوکن کنٹریکٹس کو مکمل طور پر روکنے کا کوئی طریقہ نہیں ہے، لیکن یہ
9            // صارف کی غلطی کو محدود کرتا ہے اور بدنیتی پر مبنی کنٹریکٹ کے کچھ رویوں کو کم کرتا ہے۔
سب دکھائیںکاپی کریں

1            bytes memory message = abi.encodeWithSelector(
2                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
3                _l1Token,
4                _l2Token,
5                _to, // ڈپازٹ کو بھیجنے والے کو واپس بھیجنے (bounce back) کے لیے یہاں _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}
سب دکھائیںکاپی کریں