Walkthrough des Optimism-Standardvertrags für kettenübergreifende Brücken

1// SPDX-License-Identifier: MIT
Kopieren

1pragma solidity >0.5.0 <0.9.0;
Kopieren

1/* *
2 * @title IL1ERC20Bridge */
3
4
5
6interface IL1ERC20Bridge {
7    /* *********
8     * Ereignisse *
9     ********* */
10    
11
12
13
14    event ERC20DepositInitiated(
Alle anzeigen
Kopieren

1        address indexed _l1Token,
2        address indexed _l2Token,
Kopieren

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

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    );
Kopieren

1
2    /* *******************
3     * Öffentliche Funktionen *
4     ******************* */
5    
6
7
8
9    /* *
10     * @dev Ruft die Adresse des entsprechenden L2-Vertrags für die kettenübergreifende Brücke ab.
11     * @return Adresse des entsprechenden L2-Vertrags für die kettenübergreifende Brücke. */
12    
13
14
15
16    function l2TokenBridge() external returns (address);
Alle anzeigen
Kopieren

1    /* *
2     * @dev Zahlt einen Betrag des ERC20 auf das Guthaben des Aufrufers auf L2 ein.
3     * @param _l1Token Adresse des L1-ERC20, den wir einzahlen
4     * @param _l2Token Adresse des entsprechenden L2-ERC20 zum L1
5     * @param _amount Betrag des einzuzahlenden ERC20
6     * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
7     * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
8     *        ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
9     *        Länge geben diese Verträge keine Garantien über deren Inhalt. */
10    
11
12
13
14
15
16
17
18
19
20    function depositERC20(
21        address _l1Token,
22        address _l2Token,
23        uint256 _amount,
24        uint32 _l2Gas,
25        bytes calldata _data
26    ) external;
Alle anzeigen
Kopieren

1    /* *
2     * @dev Zahlt einen Betrag von ERC20 auf das Guthaben eines Empfängers auf L2 ein.
3     * @param _l1Token Adresse des L1-ERC20, den wir einzahlen
4     * @param _l2Token Adresse des entsprechenden L2-ERC20 zum L1
5     * @param _to L2-Adresse, der die Abhebung gutgeschrieben werden soll.
6     * @param _amount Betrag des einzuzahlenden ERC20.
7     * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
8     * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
9     *        ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
10     *        Länge geben diese Verträge keine Garantien über deren Inhalt. */
11    
12
13
14
15
16
17
18
19
20
21
22    function depositERC20To(
23        address _l1Token,
24        address _l2Token,
25        address _to,
26        uint256 _amount,
27        uint32 _l2Gas,
28        bytes calldata _data
29    ) external;
Alle anzeigen
Kopieren

1    /* ************************
2     * Kettenübergreifende Funktionen *
3     ************************ */
4    
5
6
7
8    /* *
9     * @dev Schließt eine Abhebung von L2 nach L1 ab und schreibt das Guthaben dem L1-ERC20-Token-Guthaben des Empfängers gut.
10     * Dieser Aufruf schlägt fehl, wenn die initiierte Abhebung von L2 nicht abgeschlossen wurde.
11     *
12     * @param _l1Token Adresse des L1-Tokens, für den finalizeWithdrawal ausgeführt wird.
13     * @param _l2Token Adresse des L2-Tokens, bei dem die Abhebung initiiert wurde.
14     * @param _from L2-Adresse, die den Transfer initiiert.
15     * @param _to L1-Adresse, der die Abhebung gutgeschrieben werden soll.
16     * @param _amount Betrag des einzuzahlenden ERC20.
17     * @param _data Daten, die vom Sender auf L2 bereitgestellt werden. Diese Daten werden
18     *   ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
19     *   Länge geben diese Verträge keine Garantien über deren Inhalt. */
20    
21
22
23
24
25
26
27
28
29
30
31
32
33
34    function finalizeERC20Withdrawal(
35        address _l1Token,
36        address _l2Token,
37        address _from,
38        address _to,
39        uint256 _amount,
40        bytes calldata _data
41    ) external;
42}
Alle anzeigen
Kopieren

1// SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4import "./IL1ERC20Bridge.sol";
5
6/* *
7 * @title IL1StandardBridge */
8
9
10
11interface IL1StandardBridge is IL1ERC20Bridge {
12    /* *********
13     * Ereignisse *
14     ********* */
15    
16
17
18    event ETHDepositInitiated(
19        address indexed _from,
20        address indexed _to,
21        uint256 _amount,
22        bytes _data
23    );
Alle anzeigen
Kopieren

1    event ETHWithdrawalFinalized(
2        .
3        .
4        .
5    );
6
7    /* *******************
8     * Öffentliche Funktionen *
9     ******************* */
10    
11
12
13
14    /* *
15     * @dev Zahlt einen Betrag an ETH auf das Guthaben des Aufrufers auf L2 ein.
16            .
17            .
18            . */
19    
20
21
22
23
24
25    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
26
27    /* *
28     * @dev Zahlt einen Betrag an ETH auf das Guthaben eines Empfängers auf L2 ein.
29            .
30            .
31            . */
32    
33
34
35
36
37
38    function depositETHTo(
39        address _to,
40        uint32 _l2Gas,
41        bytes calldata _data
42    ) external payable;
43
44    /* ************************
45     * Kettenübergreifende Funktionen *
46     ************************ */
47    
48
49
50
51    /* *
52     * @dev Schließt eine Abhebung von L2 nach L1 ab und schreibt das Guthaben dem L1-ETH-Token-Guthaben des Empfängers gut. Da nur der xDomainMessenger diese Funktion aufrufen kann, wird sie niemals aufgerufen,
53     * bevor die Abhebung abgeschlossen ist.
54                .
55                .
56                . */
57    
58
59
60
61
62
63
64
65    function finalizeETHWithdrawal(
66        address _from,
67        address _to,
68        uint256 _amount,
69        bytes calldata _data
70    ) external;
71}
Alle anzeigen
Kopieren

1// SPDX-License-Identifier: MIT
2pragma solidity >0.5.0 <0.9.0;
3
4/* Schnittstellen-Importe */
5/* Interface Imports */
6import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
Kopieren

1/* *
2 * @title CrossDomainEnabled
3 * @dev Hilfsvertrag für Verträge, die domänenübergreifende Kommunikation durchführen
4 *
5 * Verwendeter Compiler: definiert durch den erbenden Vertrag */
6
7
8
9
10
11
12contract CrossDomainEnabled {
13    /* ************
14     * Variablen *
15     ************ */
16    
17
18
19
20    // Messenger-Vertrag, der zum Senden und Empfangen von Nachrichten aus der anderen Domäne verwendet wird.
21    address public messenger;
22
23    /* **************
24     * Konstruktor *
25     ************** */
26    
27
28
29
30    /* *
31     * @param _messenger Adresse des CrossDomainMessenger auf der aktuellen Ebene. */
32    
33
34
35    constructor(address _messenger) {
36        messenger = _messenger;
37    }
Alle anzeigen
Kopieren

1
2    /* *********************
3     * Funktionsmodifikatoren *
4     ********************* */
5    
6
7
8
9    /* *
10     * Erzwingt, dass die modifizierte Funktion nur von einem bestimmten domänenübergreifenden Konto aufgerufen werden kann.
11     * @param _sourceDomainAccount Das einzige Konto in der Ursprungsdomäne, das
12     *  authentifiziert ist, diese Funktion aufzurufen. */
13    
14
15
16
17
18    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
Alle anzeigen
Kopieren

1        require(
2            msg.sender == address(getCrossDomainMessenger()),
3            "OVM_XCHAIN: messenger contract unauthenticated"
4        );
Kopieren

1
2        require(
3            getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
4            "OVM_XCHAIN: wrong sender of cross-domain message"
5        );
Kopieren

1
2        _;
3    }
4
5    /* *********************
6     * Interne Funktionen *
7     ********************* */
8    
9
10
11
12    /* *
13     * Ruft den Messenger ab, normalerweise aus dem Speicher. Diese Funktion wird offengelegt, falls ein untergeordneter Vertrag
14     * sie überschreiben muss.
15     * @return Die Adresse des domänenübergreifenden Messenger-Vertrags, der verwendet werden soll. */
16    
17
18
19
20
21    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
22        return ICrossDomainMessenger(messenger);
23    }
Alle anzeigen
Kopieren

1
2    /* *
3     * Sendet eine Nachricht an ein Konto in einer anderen Domäne
4     * @param _crossDomainTarget Der beabsichtigte Empfänger in der Zieldomäne
5     * @param _message Die an das Ziel zu sendenden Daten (normalerweise Calldata für eine Funktion mit
6     *  `onlyFromCrossDomainAccount()`)
7     * @param _gasLimit Das Gaslimit für den Empfang der Nachricht in der Zieldomäne. */
8    
9
10
11
12
13
14
15    function sendCrossDomainMessage(
16        address _crossDomainTarget,
17        uint32 _gasLimit,
18        bytes memory _message
Alle anzeigen
Kopieren

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

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

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

1/* Schnittstellen-Importe */
2/* Interface Imports */
3import { IL1StandardBridge } from "./IL1StandardBridge.sol";
4import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
Kopieren

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

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

1/* Bibliotheks-Importe */
2/* Library Imports */
3import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
Kopieren

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

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

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

1/* *
2 * @title L1StandardBridge
3 * @dev Die L1-ETH- und ERC20-kettenübergreifende Brücke ist ein Vertrag, der eingezahlte L1-Guthaben und Standard-Token speichert,
4 * die auf L2 verwendet werden. Er synchronisiert eine entsprechende L2-kettenübergreifende Brücke, informiert sie über Einzahlungen
5 * und lauscht auf neu abgeschlossene Abhebungen.
6 * */
7
8
9
10
11
12
13
14contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
15    using SafeERC20 for IERC20;
Alle anzeigen
Kopieren

1
2    /* *******************************
3     * Externe Vertragsreferenzen *
4     ******************************* */
5    
6
7
8
9    address public l2TokenBridge;
Alle anzeigen
Kopieren

1
2    // Ordnet L1-Token dem L2-Token und dem Guthaben des eingezahlten L1-Tokens zu
3    mapping(address => mapping(address => uint256)) public deposits;
Kopieren

1
2    /* **************
3     * Konstruktor *
4     ************** */
5    
6
7
8
9    // Dieser Vertrag befindet sich hinter einem Proxy, daher bleiben die Konstruktorparameter ungenutzt.
10    constructor() CrossDomainEnabled(address(0)) {}
Alle anzeigen
Kopieren

1    /* *****************
2     * Initialisierung *
3     ***************** */
4    
5
6
7
8    /* *
9     * @param _l1messenger L1-Messenger-Adresse, die für kettenübergreifende Kommunikation verwendet wird.
10     * @param _l2TokenBridge Adresse der L2-Standard-kettenübergreifenden Brücke. */
11    
12
13
14
15    // slither-disable-next-line external-function
Alle anzeigen
Kopieren

1    function initialize(address _l1messenger, address _l2TokenBridge) public {
2        require(messenger == address(0), "Contract has already been initialized.");
Kopieren

1        messenger = _l1messenger;
2        l2TokenBridge = _l2TokenBridge;
3    }
Kopieren

1
2    /* *************
3     * Einzahlen *
4     ************* */
5    
6
7
8
9    /* * @dev Modifikator, der erfordert, dass der Sender ein EOA ist. Diese Prüfung könnte von einem bösartigen
10     *  Vertrag über Initcode umgangen werden, aber sie kümmert sich um den Benutzerfehler, den wir vermeiden wollen. */
11    
12
13
14    modifier onlyEOA() {
15        // Wird verwendet, um Einzahlungen von Verträgen zu stoppen (vermeidet versehentlich verlorene Token)
16        require(!Address.isContract(msg.sender), "Account not EOA");
17        _;
18    }
Alle anzeigen
Kopieren

1    /* *
2     * @dev Diese Funktion kann ohne Daten aufgerufen werden,
3     * um einen Betrag an ETH auf das Guthaben des Aufrufers auf L2 einzuzahlen.
4     * Da die Receive-Funktion keine Daten annimmt, wird ein konservativer
5     * Standardbetrag an L2 weitergeleitet. */
6    
7
8
9
10
11
12    receive() external payable onlyEOA {
13        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
14    }
Alle anzeigen
Kopieren

1    /* *
2     * @inheritdoc IL1StandardBridge */
3    
4
5
6    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
7        _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
8    }
9
10    /* *
11     * @inheritdoc IL1StandardBridge */
12    
13
14
15    function depositETHTo(
16        address _to,
17        uint32 _l2Gas,
18        bytes calldata _data
19    ) external payable {
20        _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
21    }
Alle anzeigen
Kopieren

1    /* *
2     * @dev Führt die Logik für Einzahlungen aus, indem die ETH gespeichert und das L2-ETH-Gateway über
3     * die Einzahlung informiert wird.
4     * @param _from Konto, von dem die Einzahlung auf L1 eingezogen wird.
5     * @param _to Konto, dem die Einzahlung auf L2 gutgeschrieben wird.
6     * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
7     * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
8     *        ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
9     *        Länge geben diese Verträge keine Garantien über deren Inhalt. */
10    
11
12
13
14
15
16
17
18
19
20    function _initiateETHDeposit(
21        address _from,
22        address _to,
23        uint32 _l2Gas,
24        bytes memory _data
25    ) internal {
26        // Erstellt Calldata für den finalizeDeposit-Aufruf
27        bytes memory message = abi.encodeWithSelector(
Alle anzeigen
Kopieren

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

1        // Sendet Calldata an L2
2        // slither-disable-next-line reentrancy-events
3        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
Kopieren

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

1    /* *
2     * @inheritdoc IL1ERC20Bridge */
3    
4
5
6    function depositERC20(
7		.
8		.
9		.
10    ) external virtual onlyEOA {
11        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
12    }
13
14    /* *
15     * @inheritdoc IL1ERC20Bridge */
16    
17
18
19    function depositERC20To(
20		.
21		.
22		.
23    ) external virtual {
24        _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
25    }
Alle anzeigen
Kopieren

1    /* *
2     * @dev Führt die Logik für Einzahlungen aus, indem der L2-Deposited-Token-Vertrag
3     * über die Einzahlung informiert wird und ein Handler aufgerufen wird, um die L1-Guthaben zu sperren. (z. B. transferFrom)
4     *
5     * @param _l1Token Adresse des L1-ERC20, den wir einzahlen
6     * @param _l2Token Adresse des entsprechenden L2-ERC20 zum L1
7     * @param _from Konto, von dem die Einzahlung auf L1 eingezogen wird
8     * @param _to Konto, dem die Einzahlung auf L2 gutgeschrieben wird
9     * @param _amount Betrag des einzuzahlenden ERC20.
10     * @param _l2Gas Gaslimit, das erforderlich ist, um die Einzahlung auf L2 abzuschließen.
11     * @param _data Optionale Daten zur Weiterleitung an L2. Diese Daten werden
12     *        ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
13     *        Länge geben diese Verträge keine Garantien über deren Inhalt. */
14    
15
16
17
18
19
20
21
22
23
24
25
26
27
28    function _initiateERC20Deposit(
29        address _l1Token,
30        address _l2Token,
31        address _from,
32        address _to,
33        uint256 _amount,
34        uint32 _l2Gas,
35        bytes calldata _data
36    ) internal {
Alle anzeigen
Kopieren

1        // Wenn eine Einzahlung auf L1 initiiert wird, überträgt die L1-kettenübergreifende Brücke die Guthaben an sich selbst für zukünftige
2        // Abhebungen. safeTransferFrom prüft auch, ob der Vertrag Code hat, daher schlägt dies fehl, wenn
3        // _from ein EOA oder address(0) ist.
4        // slither-disable-next-line reentrancy-events, reentrancy-benign
5        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
Kopieren

1        // Erstellt Calldata für _l2Token.finalizeDeposit(_to, _amount)
2        bytes memory message = abi.encodeWithSelector(
3            IL2ERC20Bridge.finalizeDeposit.selector,
4            _l1Token,
5            _l2Token,
6            _from,
7            _to,
8            _amount,
9            _data
10        );
11
12        // Sendet Calldata an 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;
Alle anzeigen
Kopieren

1
2        // slither-disable-next-line reentrancy-events
3        emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
4    }
5
6    /* ************************
7     * Kettenübergreifende Funktionen *
8     ************************ */
9    
10
11
12
13    /* *
14     * @inheritdoc IL1StandardBridge */
15    
16
17
18    function finalizeETHWithdrawal(
19        address _from,
20        address _to,
21        uint256 _amount,
22        bytes calldata _data
Alle anzeigen
Kopieren

1    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
Kopieren

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

1        require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
2
3        // slither-disable-next-line reentrancy-events
4        emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
Kopieren

1    }
2
3    /* *
4     * @inheritdoc IL1ERC20Bridge */
5    
6
7
8    function finalizeERC20Withdrawal(
9        address _l1Token,
10        address _l2Token,
11        address _from,
12        address _to,
13        uint256 _amount,
14        bytes calldata _data
15    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
Alle anzeigen
Kopieren

1        deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
Kopieren

1
2        // Wenn eine Abhebung auf L1 abgeschlossen ist, überträgt die L1-kettenübergreifende Brücke die Guthaben an den Abhebenden
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     * Temporär - ETH migrieren *
13     **************************** */
14    
15
16
17
18    /* *
19     * @dev Fügt dem Konto ETH-Guthaben hinzu. Dies soll ermöglichen, dass ETH
20     * von einem alten Gateway zu einem neuen Gateway migriert werden.
21     * HINWEIS: Dies wird nur für ein Upgrade belassen, damit wir die migrierten ETH aus dem
22     * alten Vertrag empfangen können */
23    
24
25
26
27
28
29    function donateETH() external payable {}
30}
Alle anzeigen
Kopieren

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

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

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

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}
Kopieren

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

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

1
2    /* *
3     * @param _l2Bridge Adresse der L2-Standard-kettenübergreifenden Brücke.
4     * @param _l1Token Adresse des entsprechenden L1-Tokens.
5     * @param _name ERC20-Name.
6     * @param _symbol ERC20-Symbol. */
7    
8
9
10
11
12
13    constructor(
14        address _l2Bridge,
15        address _l1Token,
16        string memory _name,
17        string memory _symbol
18    ) ERC20(_name, _symbol) {
19        l1Token = _l1Token;
20        l2Bridge = _l2Bridge;
21    }
Alle anzeigen
Kopieren

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    }
Alle anzeigen
Kopieren

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}
Alle anzeigen
Kopieren

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.9;
3
4/* Schnittstellen-Importe */
5/* Interface Imports */
6import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
7import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
8import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
Kopieren

1/* Bibliotheks-Importe */
2/* Library Imports */
3import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
4import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
5import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
6
7/* Vertrags-Importe */
8/* Contract Imports */
9import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
10
11/* *
12 * @title L2StandardBridge
13 * @dev Die L2-Standard-kettenübergreifende Brücke ist ein Vertrag, der mit der L1-Standard-kettenübergreifenden Brücke zusammenarbeitet, um
14 * ETH- und ERC20-Übergänge zwischen L1 und L2 zu ermöglichen.
15 * Dieser Vertrag fungiert als Präger für neue Token, wenn er von Einzahlungen in die L1-Standard-kettenübergreifende
16 * Brücke erfährt.
17 * Dieser Vertrag fungiert auch als Verbrenner der für die Abhebung vorgesehenen Token und informiert die L1-kettenübergreifende
18 * Brücke, L1-Guthaben freizugeben. */
19
20
21
22
23
24
25
26
27
28contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
29    /* *******************************
30     * Externe Vertragsreferenzen *
31     ******************************* */
32    
33
34
35
36    address public l1TokenBridge;
Alle anzeigen
Kopieren

1
2    /* **************
3     * Konstruktor *
4     ************** */
5    
6
7
8
9    /* *
10     * @param _l2CrossDomainMessenger Domänenübergreifender Messenger, der von diesem Vertrag verwendet wird.
11     * @param _l1TokenBridge Adresse der L1-kettenübergreifenden Brücke, die auf der Hauptchain bereitgestellt ist. */
12    
13
14
15
16    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
17        CrossDomainEnabled(_l2CrossDomainMessenger)
18    {
19        l1TokenBridge = _l1TokenBridge;
20    }
21
22    /* **************
23     * Abheben *
24     ************** */
25    
26
27
28
29    /* *
30     * @inheritdoc IL2ERC20Bridge */
31    
32
33
34    function withdraw(
35        address _l2Token,
36        uint256 _amount,
37        uint32 _l1Gas,
38        bytes calldata _data
39    ) external virtual {
40        _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
41    }
42
43    /* *
44     * @inheritdoc IL2ERC20Bridge */
45    
46
47
48    function withdrawTo(
49        address _l2Token,
50        address _to,
51        uint256 _amount,
52        uint32 _l1Gas,
53        bytes calldata _data
54    ) external virtual {
55        _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
56    }
Alle anzeigen
Kopieren

1
2    /* *
3     * @dev Führt die Logik für Abhebungen aus, indem der Token verbrannt und
4     *      das L1-Token-Gateway über die Abhebung informiert wird.
5     * @param _l2Token Adresse des L2-Tokens, bei dem die Abhebung initiiert wird.
6     * @param _from Konto, von dem die Abhebung auf L2 eingezogen wird.
7     * @param _to Konto, dem die Abhebung auf L1 gutgeschrieben wird.
8     * @param _amount Betrag des abzuhebenden Tokens.
9     * @param _l1Gas Unbenutzt, aber für mögliche zukünftige Kompatibilitätsüberlegungen enthalten.
10     * @param _data Optionale Daten zur Weiterleitung an L1. Diese Daten werden
11     *        ausschließlich als Annehmlichkeit für externe Verträge bereitgestellt. Abgesehen von der Durchsetzung einer maximalen
12     *        Länge geben diese Verträge keine Garantien über deren Inhalt. */
13    
14
15
16
17
18
19
20
21
22
23
24
25    function _initiateWithdrawal(
26        address _l2Token,
27        address _from,
28        address _to,
29        uint256 _amount,
30        uint32 _l1Gas,
31        bytes calldata _data
32    ) internal {
33        // Wenn eine Abhebung initiiert wird, verbrennen wir die Guthaben des Abhebenden, um eine spätere L2-
34        // Nutzung zu verhindern
35        // slither-disable-next-line reentrancy-events
36        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
Alle anzeigen
Kopieren

1
2        // Erstellt Calldata für l1TokenBridge.finalizeERC20Withdrawal(_to, _amount)
3        // slither-disable-next-line reentrancy-events
4        address l1Token = IL2StandardERC20(_l2Token).l1Token();
5        bytes memory message;
6
7        if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
Kopieren

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        // Sendet Nachricht hoch zur L1-kettenübergreifenden Brücke
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     * Kettenübergreifende Funktion: Einzahlen *
30     *********************************** */
31    
32
33
34
35    /* *
36     * @inheritdoc IL2ERC20Bridge */
37    
38
39
40    function finalizeDeposit(
41        address _l1Token,
42        address _l2Token,
43        address _from,
44        address _to,
45        uint256 _amount,
46        bytes calldata _data
Alle anzeigen
Kopieren

1    ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
Kopieren

1        // Prüft, ob der Ziel-Token konform ist und
2        // verifiziert, dass der eingezahlte Token auf L1 mit der hier eingezahlten L2-Token-Repräsentation übereinstimmt
3        if (
4            // slither-disable-next-line reentrancy-events
5            ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
6            _l1Token == IL2StandardERC20(_l2Token).l1Token()
Kopieren

1        ) {
2            // Wenn eine Einzahlung abgeschlossen ist, schreiben wir dem Konto auf L2 den gleichen Betrag an
3            // Token gut.
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);
Kopieren

1        } else {
2            // Entweder ist der L2-Token, in den eingezahlt wird, nicht mit der korrekten Adresse
3            // seines L1-Tokens einverstanden, oder er unterstützt nicht die korrekte Schnittstelle.
4            // Dies sollte nur passieren, wenn es einen bösartigen L2-Token gibt oder wenn ein Benutzer irgendwie
5            // die falsche L2-Token-Adresse für die Einzahlung angegeben hat.
6            // In beiden Fällen stoppen wir den Prozess hier und erstellen eine Abhebungs-
7            // Nachricht, damit Benutzer in einigen Fällen ihre Guthaben herausbekommen können.
8            // Es gibt keine Möglichkeit, bösartige Token-Verträge vollständig zu verhindern, aber dies begrenzt
9            // Benutzerfehler und mildert einige Formen von bösartigem Vertragsverhalten ab.
Alle anzeigen
Kopieren

1            bytes memory message = abi.encodeWithSelector(
2                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
3                _l1Token,
4                _l2Token,
5                _to, // hat hier _to und _from vertauscht, um die Einzahlung an den Sender zurückzusenden
6                _from,
7                _amount,
8                _data
9            );
10
11            // Sendet Nachricht hoch zur L1-kettenübergreifenden Brücke
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}
Alle anzeigen
Kopieren