Optimism நிலையான பால ஒப்பந்தத்தின் (standard bridge contract) வழிகாட்டி

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-ஐ டெபாசிட் செய்கிறது.
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    function depositERC20(
9        address _l1Token,
10        address _l2Token,
11        uint256 _amount,
12        uint32 _l2Gas,
13        bytes calldata _data
14    ) 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    function depositERC20To(
10        address _l1Token,
11        address _l2Token,
12        address _to,
13        uint256 _amount,
14        uint32 _l2Gas,
15        bytes calldata _data
16    ) external;
அனைத்தையும் காட்டு
நகலெடு

1    /* ************************
2     * கிராஸ்-செயின் செயல்பாடுகள் *
3     ************************ */
4
5    /* *
6     * @dev L2-இலிருந்து L1-க்கு திரும்பப் பெறுதலை (withdrawal) முடித்து, பெறுநரின் L1 ERC20 டோக்கன் இருப்பில் நிதியை வரவு வைக்கிறது.
7     * L2-இல் தொடங்கப்பட்ட திரும்பப் பெறுதல் இறுதி செய்யப்படாவிட்டால் இந்த அழைப்பு தோல்வியடையும்.
8     *
9     * @param _l1Token திரும்பப் பெறுதலை இறுதி செய்வதற்கான L1 டோக்கனின் முகவரி.
10     * @param _l2Token திரும்பப் பெறுதல் தொடங்கப்பட்ட L2 டோக்கனின் முகவரி.
11     * @param _from பரிமாற்றத்தைத் தொடங்கும் L2 முகவரி.
12     * @param _to திரும்பப் பெறுதலை வரவு வைக்க வேண்டிய L1 முகவரி.
13     * @param _amount டெபாசிட் செய்ய வேண்டிய ERC20-இன் அளவு.
14     * @param _data L2-இல் அனுப்புநரால் வழங்கப்பட்ட தரவு. இந்தத் தரவு வெளிப்புற ஒப்பந்தங்களின் வசதிக்காக மட்டுமே வழங்கப்படுகிறது. அதிகபட்ச நீளத்தை செயல்படுத்துவதைத் தவிர, இந்த ஒப்பந்தங்கள் அதன் உள்ளடக்கத்தைப் பற்றி எந்த உத்தரவாதத்தையும் வழங்காது. */
15    function finalizeERC20Withdrawal(
16        address _l1Token,
17        address _l2Token,
18        address _from,
19        address _to,
20        uint256 _amount,
21        bytes calldata _data
22    ) external;
23}
அனைத்தையும் காட்டு
நகலெடு

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-ஐ டெபாசிட் செய்கிறது.
13            .
14            .
15            . */
16    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
17
18    /* *
19     * @dev பெறுநரின் L2 இருப்பில் குறிப்பிட்ட அளவு ETH-ஐ டெபாசிட் செய்கிறது.
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-க்கு திரும்பப் பெறுதலை முடித்து, பெறுநரின் L1 ETH டோக்கன் இருப்பில் நிதியை வரவு வைக்கிறது. xDomainMessenger மட்டுமே இந்தச் செயல்பாட்டை அழைக்க முடியும் என்பதால், திரும்பப் பெறுதல் இறுதி செய்யப்படுவதற்கு முன்பு இது ஒருபோதும் அழைக்கப்படாது.
35                .
36                .
37                . */
38    function finalizeETHWithdrawal(
39        address _from,
40        address _to,
41        uint256 _amount,
42        bytes calldata _data
43    ) external;
44}
அனைத்தையும் காட்டு
நகலெடு

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 * பயன்படுத்தப்பட்ட கம்பைலர்: மரபுரிமையாகப் பெறும் ஒப்பந்தத்தால் வரையறுக்கப்படுகிறது */
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    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     * வழக்கமாக சேமிப்பகத்திலிருந்து மெசஞ்சரைப் பெறுகிறது. ஒரு துணை ஒப்பந்தம் மேலெழுத (override) வேண்டியிருந்தால் இந்தச் செயல்பாடு வெளிப்படுத்தப்படுகிறது.
11     * @return பயன்படுத்த வேண்டிய கிராஸ்-டொமைன் மெசஞ்சர் ஒப்பந்தத்தின் முகவரி. */
12    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
13        return ICrossDomainMessenger(messenger);
14    }
அனைத்தையும் காட்டு
நகலெடு

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 நிதிகளையும் L2-இல் பயன்பாட்டில் உள்ள நிலையான டோக்கன்களையும் சேமிக்கும் ஒரு ஒப்பந்தமாகும். இது தொடர்புடைய L2 பிரிட்ஜை ஒத்திசைக்கிறது, டெபாசிட்டுகளைப் பற்றி அதற்குத் தெரிவிக்கிறது மற்றும் புதிதாக இறுதி செய்யப்பட்ட திரும்பப் பெறுதல்களுக்காக அதைக் கண்காணிக்கிறது.
4 * */
5contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
6    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 மெசஞ்சர் முகவரி.
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 ஆக இருக்க வேண்டும் என்று கோரும் மாடிஃபையர். இந்தச் சரிபார்ப்பை initcode மூலம் ஒரு தீங்கிழைக்கும் ஒப்பந்தத்தால் தவிர்க்க முடியும், ஆனால் நாம் தவிர்க்க விரும்பும் பயனர் பிழையை இது கவனித்துக்கொள்கிறது. */
7    modifier onlyEOA() {
8        // ஒப்பந்தங்களிலிருந்து டெபாசிட்டுகளை நிறுத்தப் பயன்படுகிறது (தவறுதலாக டோக்கன்கள் இழக்கப்படுவதைத் தவிர்க்க)
9        require(!Address.isContract(msg.sender), "Account not EOA");
10        _;
11    }
அனைத்தையும் காட்டு
நகலெடு

1    /* *
2     * @dev அழைப்பாளரின் L2 இருப்பில் குறிப்பிட்ட அளவு ETH-ஐ டெபாசிட் செய்ய
3     * எந்தத் தரவும் இல்லாமல் இந்தச் செயல்பாட்டை அழைக்கலாம்.
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    function _initiateETHDeposit(
8        address _from,
9        address _to,
10        uint32 _l2Gas,
11        bytes memory _data
12    ) internal {
13        // finalizeDeposit அழைப்பிற்கான calldata-வை உருவாக்குகிறது
14        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    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 டெபாசிட் செய்யப்பட்ட டோக்கன் ஒப்பந்தத்திற்கு டெபாசிட் பற்றி தெரிவிப்பதன் மூலமும், 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    function _initiateERC20Deposit(
12        address _l1Token,
13        address _l2Token,
14        address _from,
15        address _to,
16        uint256 _amount,
17        uint32 _l2Gas,
18        bytes calldata _data
19    ) 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    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-இல் திரும்பப் பெறுதல் இறுதி செய்யப்படும்போது, 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-ஐப் பெறுவதற்காக இது ஒரு மேம்படுத்தலுக்கு (upgrade) மட்டுமே விடப்பட்டுள்ளது */
19    function donateETH() external payable {}
20}
அனைத்தையும் காட்டு
நகலெடு

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    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 மற்றும் L2-க்கு இடையே ETH மற்றும் ERC20 பரிமாற்றங்களைச் செயல்படுத்த
12 * L1 நிலையான பிரிட்ஜுடன் இணைந்து செயல்படும் ஒரு ஒப்பந்தமாகும்.
13 * L1 நிலையான பிரிட்ஜில் டெபாசிட்டுகள் செய்யப்படுவதைப் பற்றி அறியும்போது, இந்த ஒப்பந்தம் புதிய டோக்கன்களை உருவாக்குபவராக (minter) செயல்படுகிறது.
14 * திரும்பப் பெறுவதற்காக உத்தேசிக்கப்பட்ட டோக்கன்களை அழிப்பவராகவும் (burner) இந்த ஒப்பந்தம் செயல்படுகிறது, L1 நிதியை வெளியிடுமாறு L1 பிரிட்ஜுக்குத் தெரிவிக்கிறது. */
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 பிரதான செயினில் (main chain) பயன்படுத்தப்பட்ட L1 பிரிட்ஜின் முகவரி. */
9    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
10        CrossDomainEnabled(_l2CrossDomainMessenger)
11    {
12        l1TokenBridge = _l1TokenBridge;
13    }
14
15    /* **************
16     * திரும்பப் பெறுதல் *
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 டோக்கன் கேட்வேக்குத் தெரிவிப்பதன் மூலமும்
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    function _initiateWithdrawal(
12        address _l2Token,
13        address _from,
14        address _to,
15        uint256 _amount,
16        uint32 _l1Gas,
17        bytes calldata _data
18    ) internal {
19        // திரும்பப் பெறுதல் தொடங்கப்படும்போது, அடுத்தடுத்த L2
20        // பயன்பாட்டைத் தடுக்க திரும்பப் பெறுபவரின் நிதியை நாங்கள் அழிக்கிறோம் (burn)
21        // slither-disable-next-line reentrancy-events
22        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        // இலக்கு டோக்கன் இணக்கமாக உள்ளதா என்பதைச் சரிபார்த்து,
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}
அனைத்தையும் காட்டு
நகலெடு