Panoramica del contratto del ponte standard di Optimism

1// SPDX-License-Identifier: MIT
Copia

1pragma solidity >0.5.0 <0.9.0;
Copia

1/* *
2 * @title IL1ERC20Bridge */
3
4
5
6interface IL1ERC20Bridge {
7    /* *********
8     * Eventi *
9     ********* */
10    
11
12
13
14    event ERC20DepositInitiated(
Mostra tuttoCopia

1        address indexed _l1Token,
2        address indexed _l2Token,
Copia

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

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

1
2    /* *******************
3     * Funzioni Pubbliche *
4     ******************* */
5    
6
7
8
9    /* *
10     * @dev ottiene l'indirizzo del contratto ponte L2 corrispondente.
11     * @return Indirizzo del contratto ponte L2 corrispondente. */
12    
13
14
15
16    function l2TokenBridge() external returns (address);
Mostra tuttoCopia

1    /* *
2     * @dev deposita un importo di ERC20 sul saldo del chiamante su L2.
3     * @param _l1Token Indirizzo dell'ERC20 L1 che stiamo depositando
4     * @param _l2Token Indirizzo del rispettivo ERC20 L2 di L1
5     * @param _amount Importo di ERC20 da depositare
6     * @param _l2Gas Limite del gas richiesto per completare il deposito su L2.
7     * @param _data Dati opzionali da inoltrare a L2. Questi dati sono forniti
8     *        esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
9     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
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;
Mostra tuttoCopia

1    /* *
2     * @dev deposita un importo di ERC20 sul saldo di un destinatario su L2.
3     * @param _l1Token Indirizzo dell'ERC20 L1 che stiamo depositando
4     * @param _l2Token Indirizzo del rispettivo ERC20 L2 di L1
5     * @param _to Indirizzo L2 a cui accreditare il prelievo.
6     * @param _amount Importo di ERC20 da depositare.
7     * @param _l2Gas Limite del gas richiesto per completare il deposito su L2.
8     * @param _data Dati opzionali da inoltrare a L2. Questi dati sono forniti
9     *        esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
10     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
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;
Mostra tuttoCopia

1    /* ************************
2     * Funzioni Cross-chain *
3     ************************ */
4    
5
6
7
8    /* *
9     * @dev Completa un prelievo da L2 a L1 e accredita i fondi sul saldo del destinatario del
10     * token ERC20 L1.
11     * Questa chiamata fallirà se il prelievo inizializzato da L2 non è stato finalizzato.
12     *
13     * @param _l1Token Indirizzo del token L1 per cui eseguire finalizeWithdrawal.
14     * @param _l2Token Indirizzo del token L2 in cui è stato avviato il prelievo.
15     * @param _from Indirizzo L2 che avvia il trasferimento.
16     * @param _to Indirizzo L1 a cui accreditare il prelievo.
17     * @param _amount Importo di ERC20 da depositare.
18     * @param _data Dati forniti dal mittente su L2. Questi dati sono forniti
19     *   esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
20     *   lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
21    
22
23
24
25
26
27
28
29
30
31
32
33
34
35    function finalizeERC20Withdrawal(
36        address _l1Token,
37        address _l2Token,
38        address _from,
39        address _to,
40        uint256 _amount,
41        bytes calldata _data
42    ) external;
43}
Mostra tuttoCopia

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     * Eventi *
14     ********* */
15    
16
17
18    event ETHDepositInitiated(
19        address indexed _from,
20        address indexed _to,
21        uint256 _amount,
22        bytes _data
23    );
Mostra tuttoCopia

1    event ETHWithdrawalFinalized(
2        .
3        .
4        .
5    );
6
7    /* *******************
8     * Funzioni Pubbliche *
9     ******************* */
10    
11
12
13
14    /* *
15     * @dev Deposita un importo di ETH sul saldo del chiamante su L2.
16            .
17            .
18            . */
19    
20
21
22
23
24
25    function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
26
27    /* *
28     * @dev Deposita un importo di ETH sul saldo di un destinatario su L2.
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     * Funzioni Cross-chain *
46     ************************ */
47    
48
49
50
51    /* *
52     * @dev Completa un prelievo da L2 a L1 e accredita i fondi sul saldo del destinatario del
53     * token ETH L1. Poiché solo xDomainMessenger può chiamare questa funzione, non verrà mai chiamata
54     * prima che il prelievo sia finalizzato.
55                .
56                .
57                . */
58    
59
60
61
62
63
64
65
66    function finalizeETHWithdrawal(
67        address _from,
68        address _to,
69        uint256 _amount,
70        bytes calldata _data
71    ) external;
72}
Mostra tuttoCopia

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

1/* *
2 * @title CrossDomainEnabled
3 * @dev Contratto di supporto per i contratti che eseguono comunicazioni cross-domain
4 *
5 * Compilatore utilizzato: definito dal contratto che eredita */
6
7
8
9
10
11
12contract CrossDomainEnabled {
13    /* ************
14     * Variabili *
15     ************ */
16    
17
18
19
20    // Contratto Messenger utilizzato per inviare e ricevere messaggi dall'altro dominio.
21    address public messenger;
22
23    /* **************
24     * Costruttore *
25     ************** */
26    
27
28
29
30    /* *
31     * @param _messenger Indirizzo del CrossDomainMessenger sul livello corrente. */
32    
33
34
35    constructor(address _messenger) {
36        messenger = _messenger;
37    }
Mostra tuttoCopia

1
2    /* *********************
3     * Modificatori di Funzione *
4     ********************* */
5    
6
7
8
9    /* *
10     * Impone che la funzione modificata sia chiamabile solo da uno specifico account cross-domain.
11     * @param _sourceDomainAccount L'unico account sul dominio di origine che è
12     *  autenticato per chiamare questa funzione. */
13    
14
15
16
17
18    modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
Mostra tuttoCopia

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

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

1
2        _;
3    }
4
5    /* *********************
6     * Funzioni Interne *
7     ********************* */
8    
9
10
11
12    /* *
13     * Ottiene il messenger, di solito dallo storage. Questa funzione è esposta nel caso in cui un contratto figlio
14     * debba sovrascriverla.
15     * @return L'indirizzo del contratto messenger cross-domain che dovrebbe essere utilizzato. */
16    
17
18
19
20
21    function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
22        return ICrossDomainMessenger(messenger);
23    }
Mostra tuttoCopia

1
2    /* *
3     * Invia un messaggio a un account su un altro dominio
4     * @param _crossDomainTarget Il destinatario previsto sul dominio di destinazione
5     * @param _message I dati da inviare al target (di solito calldata per una funzione con
6     *  `onlyFromCrossDomainAccount()`)
7     * @param _gasLimit Il limite del gas per la ricezione del messaggio sul dominio di destinazione. */
8    
9
10
11
12
13
14
15    function sendCrossDomainMessage(
16        address _crossDomainTarget,
17        uint32 _gasLimit,
18        bytes memory _message
Mostra tuttoCopia

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

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

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

1/* Importazioni di Interfacce */
2/* Interface Imports */
3import { IL1StandardBridge } from "./IL1StandardBridge.sol";
4import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
Copia

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

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

1/* Importazioni di Librerie */
2/* Library Imports */
3import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
Copia

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

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

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

1/* *
2 * @title L1StandardBridge
3 * @dev Il ponte L1 ETH e ERC20 è un contratto che memorizza i fondi L1 depositati e i token
4 * standard che sono in uso su L2. Sincronizza un ponte L2 corrispondente, informandolo dei depositi
5 * e ascoltandolo per i prelievi appena finalizzati.
6 * */
7
8
9
10
11
12
13
14contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
15    using SafeERC20 for IERC20;
Mostra tuttoCopia

1
2    /* *******************************
3     * Riferimenti a Contratti Esterni *
4     ******************************* */
5    
6
7
8
9    address public l2TokenBridge;
Mostra tuttoCopia

1
2    // Mappa il token L1 al token L2 al saldo del token L1 depositato
3    mapping(address => mapping(address => uint256)) public deposits;
Copia

1
2    /* **************
3     * Costruttore *
4     ************** */
5    
6
7
8
9    // Questo contratto vive dietro un proxy, quindi i parametri del costruttore rimarranno inutilizzati.
10    constructor() CrossDomainEnabled(address(0)) {}
Mostra tuttoCopia

1    /* *****************
2     * Inizializzazione *
3     ***************** */
4    
5
6
7
8    /* *
9     * @param _l1messenger Indirizzo del Messenger L1 utilizzato per le comunicazioni cross-chain.
10     * @param _l2TokenBridge Indirizzo del ponte standard L2. */
11    
12
13
14
15    // slither-disable-next-line external-function
Mostra tuttoCopia

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

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

1
2    /* *************
3     * Deposito *
4     ************* */
5    
6
7
8
9    /* * @dev Modificatore che richiede che il mittente sia un EOA. Questo controllo potrebbe essere aggirato da un contratto
10     *  malevolo tramite initcode, ma si occupa dell'errore dell'utente che vogliamo evitare. */
11    
12
13
14    modifier onlyEOA() {
15        // Utilizzato per fermare i depositi dai contratti (evitare token persi accidentalmente)
16        require(!Address.isContract(msg.sender), "Account not EOA");
17        _;
18    }
Mostra tuttoCopia

1    /* *
2     * @dev Questa funzione può essere chiamata senza dati
3     * per depositare un importo di ETH sul saldo del chiamante su L2.
4     * Poiché la funzione receive non accetta dati, un importo
5     * predefinito conservativo viene inoltrato a L2. */
6    
7
8
9
10
11
12    receive() external payable onlyEOA {
13        _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
14    }
Mostra tuttoCopia

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    }
Mostra tuttoCopia

1    /* *
2     * @dev Esegue la logica per i depositi memorizzando gli ETH e informando il Gateway ETH L2 del
3     * deposito.
4     * @param _from Account da cui prelevare il deposito su L1.
5     * @param _to Account a cui dare il deposito su L2.
6     * @param _l2Gas Limite del gas richiesto per completare il deposito su L2.
7     * @param _data Dati opzionali da inoltrare a L2. Questi dati sono forniti
8     *        esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
9     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
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        // Costruisce i calldata per la chiamata finalizeDeposit
27        bytes memory message = abi.encodeWithSelector(
Mostra tuttoCopia

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

1        // Invia i calldata in L2
2        // slither-disable-next-line reentrancy-events
3        sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
Copia

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

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    }
Mostra tuttoCopia

1    /* *
2     * @dev Esegue la logica per i depositi informando il contratto L2 Deposited Token
3     * del deposito e chiamando un gestore per bloccare i fondi L1. (es., transferFrom)
4     *
5     * @param _l1Token Indirizzo dell'ERC20 L1 che stiamo depositando
6     * @param _l2Token Indirizzo del rispettivo ERC20 L2 di L1
7     * @param _from Account da cui prelevare il deposito su L1
8     * @param _to Account a cui dare il deposito su L2
9     * @param _amount Importo di ERC20 da depositare.
10     * @param _l2Gas Limite del gas richiesto per completare il deposito su L2.
11     * @param _data Dati opzionali da inoltrare a L2. Questi dati sono forniti
12     *        esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
13     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
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 {
Mostra tuttoCopia

1        // Quando un deposito viene avviato su L1, il ponte L1 trasferisce i fondi a se stesso per futuri
2        // prelievi. safeTransferFrom controlla anche se il contratto ha del codice, quindi questo fallirà se
3        // _from è un EOA o address(0).
4        // slither-disable-next-line reentrancy-events, reentrancy-benign
5        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
Copia

1        // Costruisce i calldata per _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        // Invia i calldata in 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;
Mostra tuttoCopia

1
2        // slither-disable-next-line reentrancy-events
3        emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
4    }
5
6    /* ************************
7     * Funzioni Cross-chain *
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
Mostra tuttoCopia

1    ) external onlyFromCrossDomainAccount(l2TokenBridge) {
Copia

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

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

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) {
Mostra tuttoCopia

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

1
2        // Quando un prelievo viene finalizzato su L1, il ponte L1 trasferisce i fondi a chi effettua il prelievo
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     * Temporaneo - Migrazione ETH *
13     **************************** */
14    
15
16
17
18    /* *
19     * @dev Aggiunge saldo ETH all'account. Questo ha lo scopo di consentire la migrazione
20     * degli ETH da un vecchio gateway a un nuovo gateway.
21     * NOTA: Questo viene lasciato solo per un aggiornamento in modo da poter ricevere gli ETH migrati dal
22     * vecchio contratto */
23    
24
25
26
27
28
29    function donateETH() external payable {}
30}
Mostra tuttoCopia

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

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

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

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

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

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

1
2    /* *
3     * @param _l2Bridge Indirizzo del ponte standard L2.
4     * @param _l1Token Indirizzo del token L1 corrispondente.
5     * @param _name Nome dell'ERC20.
6     * @param _symbol Simbolo dell'ERC20. */
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    }
Mostra tuttoCopia

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    }
Mostra tuttoCopia

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}
Mostra tuttoCopia

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

1/* Importazioni di Librerie */
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/* Importazioni di Contratti */
8/* Contract Imports */
9import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
10
11/* *
12 * @title L2StandardBridge
13 * @dev Il ponte Standard L2 è un contratto che lavora insieme al ponte Standard L1 per
14 * abilitare le transizioni di ETH ed ERC20 tra L1 e L2.
15 * Questo contratto agisce per coniare nuovi token quando viene a conoscenza di depositi nel ponte
16 * Standard L1.
17 * Questo contratto agisce anche come bruciatore dei token destinati al prelievo, informando il ponte
18 * L1 di rilasciare i fondi L1. */
19
20
21
22
23
24
25
26
27
28contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
29    /* *******************************
30     * Riferimenti a Contratti Esterni *
31     ******************************* */
32    
33
34
35
36    address public l1TokenBridge;
Mostra tuttoCopia

1
2    /* **************
3     * Costruttore *
4     ************** */
5    
6
7
8
9    /* *
10     * @param _l2CrossDomainMessenger Messenger cross-domain utilizzato da questo contratto.
11     * @param _l1TokenBridge Indirizzo del ponte L1 distribuito sulla catena principale. */
12    
13
14
15
16    constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
17        CrossDomainEnabled(_l2CrossDomainMessenger)
18    {
19        l1TokenBridge = _l1TokenBridge;
20    }
21
22    /* **************
23     * Prelievo *
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    }
Mostra tuttoCopia

1
2    /* *
3     * @dev Esegue la logica per i prelievi bruciando il token e informando
4     *      il Gateway del token L1 del prelievo.
5     * @param _l2Token Indirizzo del token L2 in cui è stato avviato il prelievo.
6     * @param _from Account da cui prelevare il prelievo su L2.
7     * @param _to Account a cui dare il prelievo su L1.
8     * @param _amount Importo del token da prelevare.
9     * @param _l1Gas Inutilizzato, ma incluso per potenziali considerazioni di compatibilità futura.
10     * @param _data Dati opzionali da inoltrare a L1. Questi dati sono forniti
11     *        esclusivamente per comodità dei contratti esterni. A parte l'imposizione di una
12     *        lunghezza massima, questi contratti non forniscono alcuna garanzia sul loro contenuto. */
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        // Quando viene avviato un prelievo, bruciamo i fondi di chi effettua il prelievo per prevenire un successivo
34        // utilizzo su L2
35        // slither-disable-next-line reentrancy-events
36        IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
Mostra tuttoCopia

1
2        // Costruisce i calldata per 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) {
Copia

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        // Invia il messaggio al ponte 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     * Funzione Cross-chain: Deposito *
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
Mostra tuttoCopia

1    ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
Copia

1        // Controlla che il token di destinazione sia conforme e
2        // verifica che il token depositato su L1 corrisponda alla rappresentazione del token depositato su L2 qui
3        if (
4            // slither-disable-next-line reentrancy-events
5            ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
6            _l1Token == IL2StandardERC20(_l2Token).l1Token()
Copia

1        ) {
2            // Quando un deposito viene finalizzato, accreditiamo sull'account su L2 la stessa quantità di
3            // token.
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);
Copia

1        } else {
2            // O il token L2 in cui si sta depositando non concorda sull'indirizzo corretto
3            // del suo token L1, oppure non supporta l'interfaccia corretta.
4            // Questo dovrebbe accadere solo se c'è un token L2 malevolo, o se un utente in qualche modo
5            // ha specificato l'indirizzo del token L2 sbagliato in cui depositare.
6            // In entrambi i casi, interrompiamo il processo qui e costruiamo un
7            // messaggio di prelievo in modo che gli utenti possano recuperare i propri fondi in alcuni casi.
8            // Non c'è modo di prevenire del tutto i contratti di token malevoli, ma questo limita
9            // l'errore dell'utente e mitiga alcune forme di comportamento malevolo del contratto.
Mostra tuttoCopia

1            bytes memory message = abi.encodeWithSelector(
2                IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
3                _l1Token,
4                _l2Token,
5                _to, // scambiati _to e _from qui per rimbalzare il deposito al mittente
6                _from,
7                _amount,
8                _data
9            );
10
11            // Invia il messaggio al ponte 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}
Mostra tuttoCopia