Lido

1/**
2* @title Liquid staking pool implementation
3*
4* Lido is an Ethereum 2.0 liquid staking protocol solving the problem of frozen staked Ethers
5* until transfers become available in Ethereum 2.0.
6* Whitepaper: https://lido.fi/static/Lido:Ethereum-Liquid-Staking.pdf
7*
8* NOTE: the code below assumes moderate amount of node operators, e.g. up to 50.
9*
10* Since balances of all token holders change when the amount of total pooled Ether
11* changes, this token cannot fully implement ERC20 standard: it only emits `Transfer`
12* events upon explicit transfer between holders. In contrast, when Lido oracle reports
13* rewards, no Transfer events are generated: doing so would require emitting an event
14* for each token holder and thus running an unbounded loop.
15*/
16contract Lido is ILido, IsContract, StETH, AragonApp {
17    using SafeMath for uint256;
18    using SafeMath64 for uint64;
19    using UnstructuredStorage for bytes32;
20
21    /// ACL
22    bytes32 constant public PAUSE_ROLE = keccak256("PAUSE_ROLE");
23    bytes32 constant public MANAGE_FEE = keccak256("MANAGE_FEE");
24    bytes32 constant public MANAGE_WITHDRAWAL_KEY = keccak256("MANAGE_WITHDRAWAL_KEY");
25    bytes32 constant public SET_ORACLE = keccak256("SET_ORACLE");
26    bytes32 constant public BURN_ROLE = keccak256("BURN_ROLE");
27    bytes32 constant public SET_TREASURY = keccak256("SET_TREASURY");
28    bytes32 constant public SET_INSURANCE_FUND = keccak256("SET_INSURANCE_FUND");
29    bytes32 constant public DEPOSIT_ROLE = keccak256("DEPOSIT_ROLE");
30
31    uint256 constant public PUBKEY_LENGTH = 48;
32    uint256 constant public WITHDRAWAL_CREDENTIALS_LENGTH = 32;
33    uint256 constant public SIGNATURE_LENGTH = 96;
34
35    uint256 constant public DEPOSIT_SIZE = 32 ether;
36
37    uint256 internal constant DEPOSIT_AMOUNT_UNIT = 1000000000 wei;
38
39    /// @dev default value for maximum number of Ethereum 2.0 validators registered in a single depositBufferedEther call
40    uint256 internal constant DEFAULT_MAX_DEPOSITS_PER_CALL = 150;
41
42    bytes32 internal constant FEE_POSITION = keccak256("lido.Lido.fee");
43    bytes32 internal constant TREASURY_FEE_POSITION = keccak256("lido.Lido.treasuryFee");
44    bytes32 internal constant INSURANCE_FEE_POSITION = keccak256("lido.Lido.insuranceFee");
45    bytes32 internal constant NODE_OPERATORS_FEE_POSITION = keccak256("lido.Lido.nodeOperatorsFee");
46
47    bytes32 internal constant DEPOSIT_CONTRACT_POSITION = keccak256("lido.Lido.depositContract");
48    bytes32 internal constant ORACLE_POSITION = keccak256("lido.Lido.oracle");
49    bytes32 internal constant NODE_OPERATORS_REGISTRY_POSITION = keccak256("lido.Lido.nodeOperatorsRegistry");
50    bytes32 internal constant TREASURY_POSITION = keccak256("lido.Lido.treasury");
51    bytes32 internal constant INSURANCE_FUND_POSITION = keccak256("lido.Lido.insuranceFund");
52
53    /// @dev amount of Ether (on the current Ethereum side) buffered on this smart contract balance
54    bytes32 internal constant BUFFERED_ETHER_POSITION = keccak256("lido.Lido.bufferedEther");
55    /// @dev number of deposited validators (incrementing counter of deposit operations).
56    bytes32 internal constant DEPOSITED_VALIDATORS_POSITION = keccak256("lido.Lido.depositedValidators");
57    /// @dev total amount of Beacon-side Ether (sum of all the balances of Lido validators)
58    bytes32 internal constant BEACON_BALANCE_POSITION = keccak256("lido.Lido.beaconBalance");
59    /// @dev number of Lido's validators available in the Beacon state
60    bytes32 internal constant BEACON_VALIDATORS_POSITION = keccak256("lido.Lido.beaconValidators");
61
62    /// @dev Credentials which allows the DAO to withdraw Ether on the 2.0 side
63    bytes32 internal constant WITHDRAWAL_CREDENTIALS_POSITION = keccak256("lido.Lido.withdrawalCredentials");
64
65    /**
66    * @dev As AragonApp, Lido contract must be initialized with following variables:
67    * @param depositContract official ETH2 Deposit contract
68    * @param _oracle oracle contract
69    * @param _operators instance of Node Operators Registry
70    */
71    function initialize(
72        IDepositContract depositContract,
73        address _oracle,
74        INodeOperatorsRegistry _operators,
75        address _treasury,
76        address _insuranceFund
77    )
78        public onlyInit
79    {
80        _setDepositContract(depositContract);
81        _setOracle(_oracle);
82        _setOperators(_operators);
83        _setTreasury(_treasury);
84        _setInsuranceFund(_insuranceFund);
85
86        initialized();
87    }
88
89    /**
90    * @notice Send funds to the pool
91    * @dev Users are able to submit their funds by transacting to the fallback function.
92    * Unlike vanilla Eth2.0 Deposit contract, accepting only 32-Ether transactions, Lido
93    * accepts payments of any size. Submitted Ethers are stored in Buffer until someone calls
94    * depositBufferedEther() and pushes them to the ETH2 Deposit contract.
95    */
96    function() external payable {
97        // protection against accidental submissions by calling non-existent function
98        require(msg.data.length == 0, "NON_EMPTY_DATA");
99        _submit(0);
100    }
101
102    /**
103    * @notice Send funds to the pool with optional _referral parameter
104    * @dev This function is alternative way to submit funds. Supports optional referral address.
105    * @return Amount of StETH shares generated
106    */
107    function submit(address _referral) external payable returns (uint256) {
108        return _submit(_referral);
109    }
110
111    /**
112    * @notice Deposits buffered ethers to the official DepositContract.
113    * @dev This function is separated from submit() to reduce the cost of sending funds.
114    */
115    function depositBufferedEther() external auth(DEPOSIT_ROLE) {
116        return _depositBufferedEther(DEFAULT_MAX_DEPOSITS_PER_CALL);
117    }
118
119    /**
120      * @notice Deposits buffered ethers to the official DepositContract, making no more than `_maxDeposits` deposit calls.
121      * @dev This function is separated from submit() to reduce the cost of sending funds.
122      */
123    function depositBufferedEther(uint256 _maxDeposits) external auth(DEPOSIT_ROLE) {
124        return _depositBufferedEther(_maxDeposits);
125    }
126
127    function burnShares(address _account, uint256 _sharesAmount)
128        external
129        authP(BURN_ROLE, arr(_account, _sharesAmount))
130        returns (uint256 newTotalShares)
131    {
132        return _burnShares(_account, _sharesAmount);
133    }
134
135    /**
136      * @notice Stop pool routine operations
137      */
138    function stop() external auth(PAUSE_ROLE) {
139        _stop();
140    }
141
142    /**
143      * @notice Resume pool routine operations
144      */
145    function resume() external auth(PAUSE_ROLE) {
146        _resume();
147    }

JavaScript Tests