ERC-20
Aave
Overview
Max Total Supply
2,986,290.321716945307150549 stkAAVE
Holders
20,636 ( 0.039%)
Market
Price
$251.07 @ 0.065163 ETH (-4.03%)
Onchain Market Cap
$749,767,911.07
Circulating Supply Market Cap
$3,767,244,638.00
Other Info
Token Contract (WITH 18 Decimals)
Balance
0.178789 stkAAVEValue
$44.89 ( ~0.011650884093744 Eth) [0.0000%]Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|---|---|---|---|---|
1 | Binance | AAVE-USDT | $252.56 0.0656731 Eth | $92,427,332.00 364,356.818 AAVE | 13.1069% |
2 | WhiteBIT | AAVE-USDT | $252.74 0.0657634 Eth | $41,615,624.00 164,658.549 AAVE | 5.9232% |
3 | Coinbase Exchange | AAVE-USD | $252.19 0.0655538 Eth | $27,933,606.00 110,764.129 AAVE | 3.9845% |
4 | Bitget | AAVE-USDT | $252.52 0.0656611 Eth | $23,045,172.00 90,830.941 AAVE | 3.2674% |
5 | OKX | AAVE-USDT | $252.23 0.0655633 Eth | $22,593,634.00 89,246.004 AAVE | 3.2104% |
6 | Gate.io | AAVE-USDT | $252.30 0.0656486 Eth | $18,485,746.00 72,885.055 AAVE | 2.6219% |
7 | P2B | AAVE-USDT | $250.22 0.0652063 Eth | $18,018,219.00 72,010.110 AAVE | 2.5904% |
8 | XT.COM | AAVE-USDT | $250.37 0.0653634 Eth | $14,071,225.00 55,440.960 AAVE | 1.9944% |
9 | Bybit | AAVE-USDT | $252.26 0.0655956 Eth | $13,816,442.00 54,249.157 AAVE | 1.9515% |
10 | Bitunix | AAVE-USDT | $251.44 0.0654636 Eth | $12,291,343.00 48,882.584 AAVE | 1.7584% |
11 | Upbit | AAVE-KRW | $251.16 0.0653076 Eth | $11,938,797.00 47,535.273 AAVE | 1.7100% |
12 | BTSE | AAVE-USDT | $252.30 0.0656497 Eth | $11,715,716.00 46,435.311 AAVE | 1.6704% |
13 | Binance | AAVE-ETH | $250.50 0.0653183 Eth | $11,163,535.00 44,228.026 AAVE | 1.5910% |
14 | CoinW | AAVE-USDT | $252.44 0.0656407 Eth | $10,849,923.00 42,980.641 AAVE | 1.5461% |
15 | MEXC | AAVE-USDT | $251.40 0.0655748 Eth | $9,904,046.00 39,396.246 AAVE | 1.4172% |
16 | Hotcoin | AAVE-USDT | $251.88 0.0656561 Eth | $8,590,328.00 34,105.147 AAVE | 1.2269% |
17 | KuCoin | AAVE-USDT | $252.48 0.0656691 Eth | $8,577,239.00 33,972.362 AAVE | 1.2221% |
18 | Ourbit | AAVE-USDT | $251.90 0.0656613 Eth | $8,072,607.00 31,821.305 AAVE | 1.1447% |
19 | LATOKEN | AAVE-USDT | $250.50 0.0654924 Eth | $6,399,605.00 25,546.853 AAVE | 0.9190% |
20 | BVOX | AAVE-USDT | $252.23 0.0656823 Eth | $6,362,375.00 25,057.225 AAVE | 0.9014% |
21 | FMCPAY | AAVE-USDT | $252.29 0.0656204 Eth | $6,029,895.00 23,778.873 AAVE | 0.8554% |
22 | HTX | AAVE-USDT | $252.57 0.0656754 Eth | $5,854,429.00 23,074.408 AAVE | 0.8301% |
23 | Binance | AAVE-BTC | $252.40 0.0656303 Eth | $5,326,732.00 21,371.185 AAVE | 0.7688% |
24 | LBank | AAVE-USDT | $252.01 0.0656732 Eth | $4,290,302.00 17,024.370 AAVE | 0.6124% |
25 | BYDFi | AAVE-USDT | $251.29 0.0654114 Eth | $3,746,501.00 14,908.985 AAVE | 0.5363% |
26 | Biconomy.com | AAVE-USDT | $251.81 0.0656833 Eth | $3,637,983.00 14,316.163 AAVE | 0.5150% |
27 | Binance | AAVE-USDC | $252.36 0.0656215 Eth | $3,404,080.00 13,384.400 AAVE | 0.4815% |
28 | Kraken | AAVE-USD | $252.80 0.0657531 Eth | $3,369,803.00 13,329.918 AAVE | 0.4795% |
29 | Uniswap V3 (Ethereum) | 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9-0X1F9840A85D5AF5BF1D1762F925BDADDC4201F984 | $251.05 0.0654854 Eth | $3,026,077.00 11,963.782 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9 | 0.4304% |
30 | Bithumb | AAVE-KRW | $250.66 0.0653393 Eth | $2,860,328.00 11,411.086 AAVE | 0.4105% |
31 | Trubit | AAVE-USDT | $251.33 0.0655634 Eth | $2,829,768.00 11,182.169 AAVE | 0.4023% |
32 | XT.COM | AAVE-ETH | $252.44 0.0656860 Eth | $2,490,390.00 9,831.171 AAVE | 0.3537% |
33 | Coinstore | AAVE-USDT | $253.15 0.0658699 Eth | $2,483,029.00 9,772.684 AAVE | 0.3516% |
34 | BigONE | AAVE-USDT | $253.05 0.0659442 Eth | $2,347,559.00 9,277.080 AAVE | 0.3337% |
35 | Dex-Trade | AAVE-USDT | $251.69 0.0654275 Eth | $2,343,326.00 9,310.438 AAVE | 0.3349% |
36 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X7CEB23FD6BC0ADD59E62AC25578270CFF1B9F619 | $251.64 0.0655882 Eth | $2,319,267.00 9,157.159 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.3294% |
37 | Uniswap V3 (Arbitrum One) | 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196-0X82AF49447D8A07E3BD95BD0D56F35241523FBAB1 | $253.49 0.0659133 Eth | $1,997,914.00 7,882.124 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196 | 0.2835% |
38 | Binance | AAVE-FDUSD | $252.84 0.0657460 Eth | $1,925,568.00 7,601.032 AAVE | 0.2734% |
39 | Coinbase Exchange | AAVE-EUR | $252.43 0.0656385 Eth | $1,796,408.00 7,116.486 AAVE | 0.2560% |
40 | Phemex | AAVE-USDT | $251.70 0.0656327 Eth | $1,621,980.00 6,444.155 AAVE | 0.2318% |
41 | Binance | AAVE-TRY | $253.45 0.0659032 Eth | $1,584,958.00 6,219.446 AAVE | 0.2237% |
42 | Coinbase Exchange | AAVE-BTC | $252.34 0.0655926 Eth | $1,506,339.00 5,969.504 AAVE | 0.2147% |
43 | WEEX | AAVE-USDT | $251.73 0.0656170 Eth | $1,502,493.00 5,968.725 AAVE | 0.2147% |
44 | WhiteBIT | AAVE-BTC | $251.98 0.0655650 Eth | $1,501,383.00 5,958.426 AAVE | 0.2143% |
45 | Icrypex | AAVE-USDT | $252.34 0.0657110 Eth | $1,411,014.00 5,591.814 AAVE | 0.2012% |
46 | BitMart | AAVE-USDT | $251.72 0.0654975 Eth | $1,260,736.00 5,008.543 AAVE | 0.1802% |
47 | PointPay | AAVE-USDT | $250.46 0.0653351 Eth | $1,000,184.00 3,945.250 AAVE | 0.1419% |
48 | FMCPAY | AAVE-BTC | $251.70 0.0656094 Eth | $899,034.00 3,608.839 AAVE | 0.1298% |
49 | Kraken | AAVE-EUR | $251.62 0.0654473 Eth | $846,891.00 3,365.696 AAVE | 0.1211% |
50 | Bitvavo | AAVE-EUR | $249.97 0.0652135 Eth | $846,593.00 3,386.742 AAVE | 0.1218% |
51 | Uniswap V3 (Polygon) | 0X3C499C542CEF5E3811E1192CE70D8CC03D5C3359-0XD6DF932A45C0F255F85145F286EA0B292B21C90B | $251.64 0.0655882 Eth | $840,991.00 850,760.398 0X3C499C542CEF5E3811E1192CE70D8CC03D5C3359 | 30.6043% |
52 | Bitso | AAVE-USD | $250.03 0.0652571 Eth | $752,125.00 3,008.127 AAVE | 0.1082% |
53 | Uniswap V3 (BSC) | 0XFB6115445BFF7B52FEB98650C87F44907E58F802-0XBB4CDB9CBD36B01BD1CBAEBF2DE08D9173BC095C | $251.89 0.0656429 Eth | $686,770.00 2,732.746 0XFB6115445BFF7B52FEB98650C87F44907E58F802 | 0.0983% |
54 | FMCPAY | AAVE-ETH | $251.26 0.0654942 Eth | $613,661.00 2,441.640 AAVE | 0.0878% |
55 | CoinEx | AAVE-USDT | $251.52 0.0656061 Eth | $589,510.00 2,328.310 AAVE | 0.0838% |
56 | WEEX | AAVE-USDC | $250.04 0.0652828 Eth | $503,065.00 2,011.968 AAVE | 0.0724% |
57 | tanX | AAVE-USDC | $251.37 0.0655682 Eth | $471,555.00 1,859.808 AAVE | 0.0669% |
58 | WhiteBIT | AAVE-TRY | $253.33 0.0659176 Eth | $449,961.00 1,776.176 AAVE | 0.0639% |
59 | PointPay | AAVE-BTC | $251.41 0.0654158 Eth | $434,929.00 1,750.666 AAVE | 0.0630% |
60 | Nonkyc.io | AAVE-USDT | $252.46 0.0657906 Eth | $389,928.00 1,536.382 AAVE | 0.0553% |
61 | AscendEX (BitMax) | AAVE-USDT | $251.81 0.0655210 Eth | $379,183.00 1,505.847 AAVE | 0.0542% |
62 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X0D500B1D8E8EF31E21C99D1DB9A6444D3ADF1270 | $251.64 0.0655882 Eth | $378,589.00 1,506.995 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0542% |
63 | Coinbase Exchange | AAVE-GBP | $252.35 0.0655967 Eth | $339,171.00 1,344.024 AAVE | 0.0483% |
64 | OKX | AAVE-USDC | $252.58 0.0656564 Eth | $320,079.00 1,258.739 AAVE | 0.0453% |
65 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0XC2132D05D31C914A87C6611C10748AEB04B58E8F | $251.99 0.0656806 Eth | $318,734.00 1,256.274 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0452% |
66 | BitDelta | AAVE-USDT | $250.59 0.0653711 Eth | $312,776.00 1,230.349 AAVE | 0.0443% |
67 | Bitazza | AAVE-USDT | $250.60 0.0654393 Eth | $284,275.00 1,119.396 AAVE | 0.0403% |
68 | Dex-Trade | AAVE-ETH | $251.42 0.0655599 Eth | $271,774.00 1,080.961 AAVE | 0.0389% |
69 | Kraken | AAVE-XBT | $250.18 0.0650720 Eth | $269,891.00 1,078.782 AAVE | 0.0388% |
70 | Bitcointry | AAVE-USDT | $252.62 0.0656648 Eth | $229,633.00 905.419 AAVE | 0.0326% |
71 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X2791BCA1F2DE4661ED88A30C99A7A9449AA84174 | $252.06 0.0656971 Eth | $215,585.00 847.593 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0305% |
72 | Gemini | AAVE-USD | $252.40 0.0656318 Eth | $202,768.00 803.351 AAVE | 0.0289% |
73 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X7CEB23FD6BC0ADD59E62AC25578270CFF1B9F619 | $251.58 0.0655144 Eth | $188,997.00 747.536 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0269% |
74 | Uniswap V3 (Ethereum) | 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9-0X1F9840A85D5AF5BF1D1762F925BDADDC4201F984 | $250.26 0.0652174 Eth | $188,337.00 742.453 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9 | 0.0267% |
75 | Quickswap (v3) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X7CEB23FD6BC0ADD59E62AC25578270CFF1B9F619 | $251.78 0.0656733 Eth | $168,845.00 668.190 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0240% |
76 | Uniswap V3 (Optimism) | 0X76FB31FB4AF56892A25E32CFC43DE717950C9278-0X4200000000000000000000000000000000000006 | $248.57 0.0646360 Eth | $158,679.00 634.793 0X76FB31FB4AF56892A25E32CFC43DE717950C9278 | 0.0228% |
77 | KuCoin | AAVE-BTC | $252.37 0.0656401 Eth | $132,444.00 524.810 AAVE | 0.0189% |
78 | Bitkub | AAVE-THB | $250.64 0.0652561 Eth | $98,383.00 392.530 AAVE | 0.0141% |
79 | Uniswap V3 (Arbitrum One) | 0XAF88D065E77C8CC2239327C5EDB3A432268E5831-0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196 | $253.49 0.0659133 Eth | $92,311.00 92,818.476 0XAF88D065E77C8CC2239327C5EDB3A432268E5831 | 3.3389% |
80 | PancakeSwap V3 (BSC) | 0XFB6115445BFF7B52FEB98650C87F44907E58F802-0XBB4CDB9CBD36B01BD1CBAEBF2DE08D9173BC095C | $247.68 0.0646048 Eth | $88,144.00 352.557 0XFB6115445BFF7B52FEB98650C87F44907E58F802 | 0.0127% |
81 | Binance US | AAVE-USDT | $251.14 0.0654866 Eth | $85,820.00 341.724 AAVE | 0.0123% |
82 | DeGate | 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48 | $252.45 0.0657714 Eth | $85,452.00 334.938 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9 | 0.0120% |
83 | Nonkyc.io | AAVE-ETH | $251.71 0.0657654 Eth | $80,302.00 319.438 AAVE | 0.0115% |
84 | Uniswap V3 (Arbitrum One) | 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196-0X82AF49447D8A07E3BD95BD0D56F35241523FBAB1 | $252.47 0.0658541 Eth | $76,431.00 306.894 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196 | 0.0110% |
85 | LFJ | 0X63A72806098BD3D9520CC43356DD78AFE5D386D9-0XB31F66AA3C1E785363F0875A1B74E27B85FD66C7 | $249.09 0.0649235 Eth | $73,632.00 297.062 0X63A72806098BD3D9520CC43356DD78AFE5D386D9 | 0.0107% |
86 | Mercado Bitcoin | AAVE-BRL | $252.87 0.0657978 Eth | $58,929.00 233.039 AAVE | 0.0084% |
87 | EXMO | AAVE-USDT | $253.12 0.0658355 Eth | $39,993.00 158.004 AAVE | 0.0057% |
88 | Kraken | AAVE-GBP | $250.07 0.0650435 Eth | $39,826.00 159.257 AAVE | 0.0057% |
89 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X1BFD67037B42CF73ACF2047067BD4F2C47D9BFD6 | $252.10 0.0656496 Eth | $32,269.00 129.073 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0046% |
90 | Uniswap V3 (Optimism) | 0X76FB31FB4AF56892A25E32CFC43DE717950C9278-0X4200000000000000000000000000000000000006 | $246.09 0.0639907 Eth | $32,143.00 128.693 0X76FB31FB4AF56892A25E32CFC43DE717950C9278 | 0.0046% |
91 | Uniswap V3 (Polygon) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X0D500B1D8E8EF31E21C99D1DB9A6444D3ADF1270 | $250.19 0.0650950 Eth | $29,884.00 119.796 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0043% |
92 | Uniswap V2 (Ethereum) | 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9-0XC02AAA39B223FE8D0A0E5C4F27EAD9083C756CC2 | $247.20 0.0644191 Eth | $29,511.00 119.609 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9 | 0.0043% |
93 | Sushiswap (Polygon POS) | 0XD6DF932A45C0F255F85145F286EA0B292B21C90B-0X7CEB23FD6BC0ADD59E62AC25578270CFF1B9F619 | $252.14 0.0655824 Eth | $27,217.00 107.604 0XD6DF932A45C0F255F85145F286EA0B292B21C90B | 0.0039% |
94 | HashKey Exchange | AAVE-USD | $252.52 0.0657590 Eth | $26,818.00 103.214 AAVE | 0.0037% |
95 | NovaDAX | AAVE-BRL | $251.86 0.0658037 Eth | $23,172.00 92.005 AAVE | 0.0033% |
96 | Bitexen | AAVE-TRY | $249.21 0.0648385 Eth | $21,277.00 85.378 AAVE | 0.0031% |
97 | Globe | AAVE-USDT | $250.00 0.0652547 Eth | $21,125.00 83.014 AAVE | 0.0030% |
98 | Uniswap V3 (Ethereum) | 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48 | $252.05 0.0655577 Eth | $20,666.00 80.309 0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9 | 0.0029% |
99 | Uniswap V3 (Arbitrum One) | 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196-0XFD086BC7CD5C481DCC9C85EBE478A1C0B69FCBB9 | $253.77 0.0661310 Eth | $15,543.45 61.753 0XBA5DDD1F9D7F570DC94A51479A000E3BCE967196 | 0.0022% |
100 | Gate.io | AAVE-ETH | $251.48 0.0654355 Eth | $6,429.60 25.520 AAVE | 0.0009% |
Contract Name:
InitializableAdminUpgradeabilityProxy
Compiler Version
v0.6.12+commit.27d51765
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './BaseAdminUpgradeabilityProxy.sol'; import './InitializableUpgradeabilityProxy.sol'; /** * @title InitializableAdminUpgradeabilityProxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * Extends from BaseAdminUpgradeabilityProxy with an initializer for * initializing the implementation, admin, and init data. */ contract InitializableAdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, InitializableUpgradeabilityProxy { /** * Contract initializer. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize( address _logic, address _admin, bytes memory _data ) public payable { require(_implementation() == address(0)); InitializableUpgradeabilityProxy.initialize(_logic, _data); assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } /** * @dev Only fall back when the sender is not the admin. */ function _willFallback() internal override(BaseAdminUpgradeabilityProxy, Proxy) { BaseAdminUpgradeabilityProxy._willFallback(); } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {DistributionTypes} from '../lib/DistributionTypes.sol'; interface IAaveDistributionManager { function configureAssets(DistributionTypes.AssetConfigInput[] calldata assetsConfigInput) external; }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; library DistributionTypes { struct AssetConfigInput { uint128 emissionPerSecond; uint256 totalStaked; address underlyingAsset; } struct UserStakeInput { address underlyingAsset; uint256 stakedByUser; uint256 totalStaked; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; interface IAaveIncentivesController { function handleAction( address asset, uint256 userBalance, uint256 totalSupply ) external; function getRewardsBalance(address[] calldata assets, address user) external view returns (uint256); function claimRewards( address[] calldata assets, uint256 amount, address to, bool stake ) external returns (uint256); }
pragma solidity ^0.6.12; interface IAToken { function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev Interface of the ERC20 standard as defined in the EIP. * From https://github.com/OpenZeppelin/openzeppelin-contracts */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import {IERC20} from './IERC20.sol'; /** * @dev Interface for ERC20 including metadata **/ interface IERC20Detailed is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; interface IStakedAave { function stake(address to, uint256 amount) external; function redeem(address to, uint256 amount) external; function cooldown() external; function claimRewards(address to, uint256 amount) external; }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; interface ITransferHook { function onTransfer(address from, address to, uint256 amount) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev Collection of functions related to the address type * From https://github.com/OpenZeppelin/openzeppelin-contracts */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, 'Address: insufficient balance'); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{value: amount}(''); require(success, 'Address: unable to send value, recipient may have reverted'); } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './UpgradeabilityProxy.sol'; /** * @title BaseAdminUpgradeabilityProxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * This contract combines an upgradeability proxy with an authorization * mechanism for administrative tasks. * All external functions in this contract must be guarded by the * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity * feature proposal that would enable this to be done automatically. */ contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Emitted when the administration has been transferred. * @param previousAdmin Address of the previous admin. * @param newAdmin Address of the new admin. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Modifier to check whether the `msg.sender` is the admin. * If it is, it will run the function. Otherwise, it will delegate the call * to the implementation. */ modifier ifAdmin() { if (msg.sender == _admin()) { _; } else { _fallback(); } } /** * @return The address of the proxy admin. */ function admin() external ifAdmin returns (address) { return _admin(); } /** * @return The address of the implementation. */ function implementation() external ifAdmin returns (address) { return _implementation(); } /** * @dev Changes the admin of the proxy. * Only the current admin can call this function. * @param newAdmin Address to transfer proxy administration to. */ function changeAdmin(address newAdmin) external ifAdmin { require(newAdmin != address(0), 'Cannot change the admin of a proxy to the zero address'); emit AdminChanged(_admin(), newAdmin); _setAdmin(newAdmin); } /** * @dev Upgrade the backing implementation of the proxy. * Only the admin can call this function. * @param newImplementation Address of the new implementation. */ function upgradeTo(address newImplementation) external ifAdmin { _upgradeTo(newImplementation); } /** * @dev Upgrade the backing implementation of the proxy and call a function * on the new implementation. * This is useful to initialize the proxied contract. * @param newImplementation Address of the new implementation. * @param data Data to send as msg.data in the low level call. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. */ function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin { _upgradeTo(newImplementation); (bool success, ) = newImplementation.delegatecall(data); require(success); } /** * @return adm The admin slot. */ function _admin() internal view returns (address adm) { bytes32 slot = ADMIN_SLOT; assembly { adm := sload(slot) } } /** * @dev Sets the address of the proxy admin. * @param newAdmin Address of the new proxy admin. */ function _setAdmin(address newAdmin) internal { bytes32 slot = ADMIN_SLOT; assembly { sstore(slot, newAdmin) } } /** * @dev Only fall back when the sender is not the admin. */ function _willFallback() internal virtual override { require(msg.sender != _admin(), 'Cannot call fallback function from the proxy admin'); super._willFallback(); } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import './BaseUpgradeabilityProxy.sol'; /** * @title UpgradeabilityProxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * Extends BaseUpgradeabilityProxy with a constructor for initializing * implementation and init data. */ contract UpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract constructor. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, bytes memory _data) public payable { assert( IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1) ); _setImplementation(_logic); if (_data.length > 0) { (bool success, ) = _logic.delegatecall(_data); require(success); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './Proxy.sol'; import './Address.sol'; /** * @title BaseUpgradeabilityProxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * This contract implements a proxy that allows to change the * implementation address to which it will delegate. * Such a change is called an implementation upgrade. */ contract BaseUpgradeabilityProxy is Proxy { /** * @dev Emitted when the implementation is upgraded. * @param implementation Address of the new implementation. */ event Upgraded(address indexed implementation); /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Returns the current implementation. * @return impl Address of the current implementation */ function _implementation() internal override view returns (address impl) { bytes32 slot = IMPLEMENTATION_SLOT; assembly { impl := sload(slot) } } /** * @dev Upgrades the proxy to a new implementation. * @param newImplementation Address of the new implementation. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Sets the implementation address of the proxy. * @param newImplementation Address of the new implementation. */ function _setImplementation(address newImplementation) internal { require( Address.isContract(newImplementation), 'Cannot set a proxy implementation to a non-contract address' ); bytes32 slot = IMPLEMENTATION_SLOT; assembly { sstore(slot, newImplementation) } } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @title Proxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * Implements delegation of calls to other contracts, with proper * forwarding of return values and bubbling of failures. * It defines a fallback function that delegates all calls to the address * returned by the abstract _implementation() internal function. */ abstract contract Proxy { /** * @dev Fallback function. * Implemented entirely in `_fallback`. */ fallback() external payable { _fallback(); } /** * @return The Address of the implementation. */ function _implementation() internal virtual view returns (address); /** * @dev Delegates execution to an implementation contract. * This is a low level function that doesn't return to its internal call site. * It will return to the external caller whatever the implementation returns. * @param implementation Address to delegate. */ function _delegate(address implementation) internal { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @dev Function that is run as the first thing in the fallback function. * Can be redefined in derived contracts to add functionality. * Redefinitions must call super._willFallback(). */ function _willFallback() internal virtual {} /** * @dev fallback implementation. * Extracted to enable manual triggering. */ function _fallback() internal { _willFallback(); _delegate(_implementation()); } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev From https://github.com/OpenZeppelin/openzeppelin-contracts * Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal virtual view returns (address payable) { return msg.sender; } function _msgData() internal virtual view returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import {Context} from './Context.sol'; import {IERC20} from '../interfaces/IERC20.sol'; import {IERC20Detailed} from '../interfaces/IERC20Detailed.sol'; import {SafeMath} from './SafeMath.sol'; /** * @title ERC20 * @notice Basic ERC20 implementation * @author Aave **/ contract ERC20 is Context, IERC20, IERC20Detailed { using SafeMath for uint256; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor( string memory name, string memory symbol, uint8 decimals ) public { _name = name; _symbol = symbol; _decimals = decimals; } /** * @return the name of the token **/ function name() public override view returns (string memory) { return _name; } /** * @return the symbol of the token **/ function symbol() public override view returns (string memory) { return _symbol; } /** * @return the decimals of the token **/ function decimals() public override view returns (uint8) { return _decimals; } /** * @return the total supply of the token **/ function totalSupply() public override view returns (uint256) { return _totalSupply; } /** * @return the balance of the token **/ function balanceOf(address account) public override view returns (uint256) { return _balances[account]; } /** * @dev executes a transfer of tokens from msg.sender to recipient * @param recipient the recipient of the tokens * @param amount the amount of tokens being transferred * @return true if the transfer succeeds, false otherwise **/ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev returns the allowance of spender on the tokens owned by owner * @param owner the owner of the tokens * @param spender the user allowed to spend the owner's tokens * @return the amount of owner's tokens spender is allowed to spend **/ function allowance(address owner, address spender) public virtual override view returns (uint256) { return _allowances[owner][spender]; } /** * @dev allows spender to spend the tokens owned by msg.sender * @param spender the user allowed to spend msg.sender tokens * @return true **/ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev executes a transfer of token from sender to recipient, if msg.sender is allowed to do so * @param sender the owner of the tokens * @param recipient the recipient of the tokens * @param amount the amount of tokens being transferred * @return true if the transfer succeeds, false otherwise **/ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve( sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, 'ERC20: transfer amount exceeds allowance') ); return true; } /** * @dev increases the allowance of spender to spend msg.sender tokens * @param spender the user allowed to spend on behalf of msg.sender * @param addedValue the amount being added to the allowance * @return true **/ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev decreases the allowance of spender to spend msg.sender tokens * @param spender the user allowed to spend on behalf of msg.sender * @param subtractedValue the amount being subtracted to the allowance * @return true **/ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender].sub( subtractedValue, 'ERC20: decreased allowance below zero' ) ); return true; } function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), 'ERC20: transfer from the zero address'); require(recipient != address(0), 'ERC20: transfer to the zero address'); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, 'ERC20: transfer amount exceeds balance'); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), 'ERC20: mint to the zero address'); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), 'ERC20: burn from the zero address'); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, 'ERC20: burn amount exceeds balance'); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), 'ERC20: approve from the zero address'); require(spender != address(0), 'ERC20: approve to the zero address'); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _setName(string memory newName) internal { _name = newName; } function _setSymbol(string memory newSymbol) internal { _symbol = newSymbol; } function _setDecimals(uint8 newDecimals) internal { _decimals = newDecimals; } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; /** * @dev From https://github.com/OpenZeppelin/openzeppelin-contracts * Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, 'SafeMath: addition overflow'); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, 'SafeMath: subtraction overflow'); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, 'SafeMath: multiplication overflow'); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, 'SafeMath: division by zero'); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, 'SafeMath: modulo by zero'); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import {ERC20} from '../lib/ERC20.sol'; import {ITransferHook} from '../interfaces/ITransferHook.sol'; /** * @title ERC20WithSnapshot * @notice ERC20 including snapshots of balances on transfer-related actions * @author Aave **/ contract ERC20WithSnapshot is ERC20 { /// @dev snapshot of a value on a specific block, used for balances struct Snapshot { uint128 blockNumber; uint128 value; } mapping (address => mapping (uint256 => Snapshot)) public _snapshots; mapping (address => uint256) public _countsSnapshots; /// @dev reference to the Aave governance contract to call (if initialized) on _beforeTokenTransfer /// !!! IMPORTANT The Aave governance is considered a trustable contract, being its responsibility /// to control all potential reentrancies by calling back the this contract ITransferHook public _aaveGovernance; event SnapshotDone(address owner, uint128 oldValue, uint128 newValue); constructor(string memory name, string memory symbol, uint8 decimals) public ERC20(name, symbol, decimals) {} function _setAaveGovernance(ITransferHook aaveGovernance) internal virtual { _aaveGovernance = aaveGovernance; } /** * @dev Writes a snapshot for an owner of tokens * @param owner The owner of the tokens * @param oldValue The value before the operation that is gonna be executed after the snapshot * @param newValue The value after the operation */ function _writeSnapshot(address owner, uint128 oldValue, uint128 newValue) internal virtual { uint128 currentBlock = uint128(block.number); uint256 ownerCountOfSnapshots = _countsSnapshots[owner]; mapping (uint256 => Snapshot) storage snapshotsOwner = _snapshots[owner]; // Doing multiple operations in the same block if (ownerCountOfSnapshots != 0 && snapshotsOwner[ownerCountOfSnapshots.sub(1)].blockNumber == currentBlock) { snapshotsOwner[ownerCountOfSnapshots.sub(1)].value = newValue; } else { snapshotsOwner[ownerCountOfSnapshots] = Snapshot(currentBlock, newValue); _countsSnapshots[owner] = ownerCountOfSnapshots.add(1); } emit SnapshotDone(owner, oldValue, newValue); } /** * @dev Writes a snapshot before any operation involving transfer of value: _transfer, _mint and _burn * - On _transfer, it writes snapshots for both "from" and "to" * - On _mint, only for _to * - On _burn, only for _from * @param from the from address * @param to the to address * @param amount the amount to transfer */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal override { if (from == to) { return; } if (from != address(0)) { uint256 fromBalance = balanceOf(from); _writeSnapshot(from, uint128(fromBalance), uint128(fromBalance.sub(amount))); } if (to != address(0)) { uint256 toBalance = balanceOf(to); _writeSnapshot(to, uint128(toBalance), uint128(toBalance.add(amount))); } // caching the aave governance address to avoid multiple state loads ITransferHook aaveGovernance = _aaveGovernance; if (aaveGovernance != ITransferHook(0)) { aaveGovernance.onTransfer(from, to, amount); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './BaseUpgradeabilityProxy.sol'; /** * @title InitializableUpgradeabilityProxy * @dev From https://github.com/OpenZeppelin/openzeppelin-sdk/tree/solc-0.6/packages/lib/contracts/upgradeability * Extends BaseUpgradeabilityProxy with an initializer for initializing * implementation and init data. */ contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract initializer. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize(address _logic, bytes memory _data) public payable { require(_implementation() == address(0)); assert( IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1) ); _setImplementation(_logic); if (_data.length > 0) { (bool success, ) = _logic.delegatecall(_data); require(success); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import {IERC20} from "../interfaces/IERC20.sol"; import {SafeMath} from "./SafeMath.sol"; import {Address} from "./Address.sol"; /** * @title SafeERC20 * @dev From https://github.com/OpenZeppelin/openzeppelin-contracts * Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {IAaveIncentivesController} from '../interfaces/IAaveIncentivesController.sol'; import {DistributionTypes} from '../lib/DistributionTypes.sol'; import {IAToken} from '../interfaces/IAToken.sol'; contract ATokenMock is IAToken { IAaveIncentivesController public _aic; uint256 internal _userBalance; uint256 internal _totalSupply; // hack to be able to test event from EI properly event RewardsAccrued(address indexed user, uint256 amount); // hack to be able to test event from Distribution manager properly event AssetConfigUpdated(address indexed asset, uint256 emission); event AssetIndexUpdated(address indexed asset, uint256 index); event UserIndexUpdated(address indexed user, address indexed asset, uint256 index); constructor(IAaveIncentivesController aic) public { _aic = aic; } function handleActionOnAic( address user, uint256 userBalance, uint256 totalSupply ) external { _aic.handleAction(user, userBalance, totalSupply); } function setUserBalanceAndSupply(uint256 userBalance, uint256 totalSupply) public { _userBalance = userBalance; _totalSupply = totalSupply; } function getScaledUserBalanceAndSupply(address user) external override view returns (uint256, uint256) { return (_userBalance, _totalSupply); } function cleanUserState() external { _userBalance = 0; _totalSupply = 0; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import {ITransferHook} from "../interfaces/ITransferHook.sol"; contract MockTransferHook is ITransferHook { event MockHookEvent(); function onTransfer(address from, address to, uint256 amount) external override { emit MockHookEvent(); } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {SafeMath} from '../lib/SafeMath.sol'; import {DistributionTypes} from '../lib/DistributionTypes.sol'; import {IAaveDistributionManager} from '../interfaces/IAaveDistributionManager.sol'; /** * @title AaveDistributionManager * @notice Accounting contract to manage multiple staking distributions * @author Aave **/ contract AaveDistributionManager is IAaveDistributionManager { using SafeMath for uint256; struct AssetData { uint128 emissionPerSecond; uint128 lastUpdateTimestamp; uint256 index; mapping(address => uint256) users; } uint256 public immutable DISTRIBUTION_END; address public immutable EMISSION_MANAGER; uint8 public constant PRECISION = 18; mapping(address => AssetData) public assets; event AssetConfigUpdated(address indexed asset, uint256 emission); event AssetIndexUpdated(address indexed asset, uint256 index); event UserIndexUpdated(address indexed user, address indexed asset, uint256 index); constructor(address emissionManager, uint256 distributionDuration) public { DISTRIBUTION_END = block.timestamp.add(distributionDuration); EMISSION_MANAGER = emissionManager; } /** * @dev Configures the distribution of rewards for a list of assets * @param assetsConfigInput The list of configurations to apply **/ function configureAssets(DistributionTypes.AssetConfigInput[] calldata assetsConfigInput) external override { require(msg.sender == EMISSION_MANAGER, 'ONLY_EMISSION_MANAGER'); for (uint256 i = 0; i < assetsConfigInput.length; i++) { AssetData storage assetConfig = assets[assetsConfigInput[i].underlyingAsset]; _updateAssetStateInternal( assetsConfigInput[i].underlyingAsset, assetConfig, assetsConfigInput[i].totalStaked ); assetConfig.emissionPerSecond = assetsConfigInput[i].emissionPerSecond; emit AssetConfigUpdated( assetsConfigInput[i].underlyingAsset, assetsConfigInput[i].emissionPerSecond ); } } /** * @dev Updates the state of one distribution, mainly rewards index and timestamp * @param underlyingAsset The address used as key in the distribution, for example sAAVE or the aTokens addresses on Aave * @param assetConfig Storage pointer to the distribution's config * @param totalStaked Current total of staked assets for this distribution * @return The new distribution index **/ function _updateAssetStateInternal( address underlyingAsset, AssetData storage assetConfig, uint256 totalStaked ) internal returns (uint256) { uint256 oldIndex = assetConfig.index; uint128 lastUpdateTimestamp = assetConfig.lastUpdateTimestamp; if (block.timestamp == lastUpdateTimestamp) { return oldIndex; } uint256 newIndex = _getAssetIndex( oldIndex, assetConfig.emissionPerSecond, lastUpdateTimestamp, totalStaked ); if (newIndex != oldIndex) { assetConfig.index = newIndex; emit AssetIndexUpdated(underlyingAsset, newIndex); } assetConfig.lastUpdateTimestamp = uint128(block.timestamp); return newIndex; } /** * @dev Updates the state of an user in a distribution * @param user The user's address * @param asset The address of the reference asset of the distribution * @param stakedByUser Amount of tokens staked by the user in the distribution at the moment * @param totalStaked Total tokens staked in the distribution * @return The accrued rewards for the user until the moment **/ function _updateUserAssetInternal( address user, address asset, uint256 stakedByUser, uint256 totalStaked ) internal returns (uint256) { AssetData storage assetData = assets[asset]; uint256 userIndex = assetData.users[user]; uint256 accruedRewards = 0; uint256 newIndex = _updateAssetStateInternal(asset, assetData, totalStaked); if (userIndex != newIndex) { if (stakedByUser != 0) { accruedRewards = _getRewards(stakedByUser, newIndex, userIndex); } assetData.users[user] = newIndex; emit UserIndexUpdated(user, asset, newIndex); } return accruedRewards; } /** * @dev Used by "frontend" stake contracts to update the data of an user when claiming rewards from there * @param user The address of the user * @param stakes List of structs of the user data related with his stake * @return The accrued rewards for the user until the moment **/ function _claimRewards(address user, DistributionTypes.UserStakeInput[] memory stakes) internal returns (uint256) { uint256 accruedRewards = 0; for (uint256 i = 0; i < stakes.length; i++) { accruedRewards = accruedRewards.add( _updateUserAssetInternal( user, stakes[i].underlyingAsset, stakes[i].stakedByUser, stakes[i].totalStaked ) ); } return accruedRewards; } /** * @dev Return the accrued rewards for an user over a list of distribution * @param user The address of the user * @param stakes List of structs of the user data related with his stake * @return The accrued rewards for the user until the moment **/ function _getUnclaimedRewards(address user, DistributionTypes.UserStakeInput[] memory stakes) internal view returns (uint256) { uint256 accruedRewards = 0; for (uint256 i = 0; i < stakes.length; i++) { AssetData storage assetConfig = assets[stakes[i].underlyingAsset]; uint256 assetIndex = _getAssetIndex( assetConfig.index, assetConfig.emissionPerSecond, assetConfig.lastUpdateTimestamp, stakes[i].totalStaked ); accruedRewards = accruedRewards.add( _getRewards(stakes[i].stakedByUser, assetIndex, assetConfig.users[user]) ); } return accruedRewards; } /** * @dev Internal function for the calculation of user's rewards on a distribution * @param principalUserBalance Amount staked by the user on a distribution * @param reserveIndex Current index of the distribution * @param userIndex Index stored for the user, representation his staking moment * @return The rewards **/ function _getRewards( uint256 principalUserBalance, uint256 reserveIndex, uint256 userIndex ) internal pure returns (uint256) { return principalUserBalance.mul(reserveIndex.sub(userIndex)).div(10**uint256(PRECISION)); } /** * @dev Calculates the next value of an specific distribution index, with validations * @param currentIndex Current index of the distribution * @param emissionPerSecond Representing the total rewards distributed per second per asset unit, on the distribution * @param lastUpdateTimestamp Last moment this distribution was updated * @param totalBalance of tokens considered for the distribution * @return The new index. **/ function _getAssetIndex( uint256 currentIndex, uint256 emissionPerSecond, uint128 lastUpdateTimestamp, uint256 totalBalance ) internal view returns (uint256) { if ( emissionPerSecond == 0 || totalBalance == 0 || lastUpdateTimestamp == block.timestamp || lastUpdateTimestamp >= DISTRIBUTION_END ) { return currentIndex; } uint256 currentTimestamp = block.timestamp > DISTRIBUTION_END ? DISTRIBUTION_END : block.timestamp; uint256 timeDelta = currentTimestamp.sub(lastUpdateTimestamp); return emissionPerSecond.mul(timeDelta).mul(10**uint256(PRECISION)).div(totalBalance).add( currentIndex ); } /** * @dev Returns the data of an user on a distribution * @param user Address of the user * @param asset The address of the reference asset of the distribution * @return The new index **/ function getUserAssetData(address user, address asset) public view returns (uint256) { return assets[asset].users[user]; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {DistributionTypes} from '../lib/DistributionTypes.sol'; import {IERC20} from '../interfaces/IERC20.sol'; import {IAToken} from '../interfaces/IAToken.sol'; import {IAaveIncentivesController} from '../interfaces/IAaveIncentivesController.sol'; import {IStakedAave} from '../interfaces/IStakedAave.sol'; import {VersionedInitializable} from '../utils/VersionedInitializable.sol'; import {AaveDistributionManager} from './AaveDistributionManager.sol'; /** * @title AaveIncentivesController * @notice Distributor contract for rewards to the Aave protocol * @author Aave **/ contract AaveIncentivesController is IAaveIncentivesController, VersionedInitializable, AaveDistributionManager { uint256 public constant REVISION = 1; IStakedAave public immutable PSM; IERC20 public immutable REWARD_TOKEN; address public immutable REWARDS_VAULT; uint256 public immutable EXTRA_PSM_REWARD; mapping(address => uint256) internal _usersUnclaimedRewards; event RewardsAccrued(address indexed user, uint256 amount); event RewardsClaimed(address indexed user, address indexed to, uint256 amount); constructor( IERC20 rewardToken, address rewardsVault, IStakedAave psm, uint256 extraPsmReward, address emissionManager, uint128 distributionDuration ) public AaveDistributionManager(emissionManager, distributionDuration) { REWARD_TOKEN = rewardToken; REWARDS_VAULT = rewardsVault; PSM = psm; EXTRA_PSM_REWARD = extraPsmReward; } /** * @dev Called by the proxy contract. Not used at the moment, but for the future **/ function initialize() external initializer { // to unlock possibility to stake on behalf of the user REWARD_TOKEN.approve(address(PSM), type(uint256).max); } /** * @dev Called by the corresponding asset on any update that affects the rewards distribution * @param user The address of the user * @param userBalance The balance of the user of the asset in the lending pool * @param totalSupply The total supply of the asset in the lending pool **/ function handleAction( address user, uint256 userBalance, uint256 totalSupply ) external override { uint256 accruedRewards = _updateUserAssetInternal(user, msg.sender, userBalance, totalSupply); if (accruedRewards != 0) { _usersUnclaimedRewards[user] = _usersUnclaimedRewards[user].add(accruedRewards); emit RewardsAccrued(user, accruedRewards); } } /** * @dev Returns the total of rewards of an user, already accrued + not yet accrued * @param user The address of the user * @return The rewards **/ function getRewardsBalance(address[] calldata assets, address user) external override view returns (uint256) { uint256 unclaimedRewards = _usersUnclaimedRewards[user]; DistributionTypes.UserStakeInput[] memory userState = new DistributionTypes.UserStakeInput[]( assets.length ); for (uint256 i = 0; i < assets.length; i++) { userState[i].underlyingAsset = assets[i]; (userState[i].stakedByUser, userState[i].totalStaked) = IAToken(assets[i]) .getScaledUserBalanceAndSupply(user); } unclaimedRewards = unclaimedRewards.add(_getUnclaimedRewards(user, userState)); return unclaimedRewards; } /** * @dev Claims reward for an user, on all the assets of the lending pool, accumulating the pending rewards * @param amount Amount of rewards to claim * @param to Address that will be receiving the rewards * @param stake Boolean flag to determined if the claimed rewards should be staked in the Safety Module or not * @return Rewards claimed **/ function claimRewards( address[] calldata assets, uint256 amount, address to, bool stake ) external override returns (uint256) { if (amount == 0) { return 0; } address user = msg.sender; uint256 unclaimedRewards = _usersUnclaimedRewards[user]; DistributionTypes.UserStakeInput[] memory userState = new DistributionTypes.UserStakeInput[]( assets.length ); for (uint256 i = 0; i < assets.length; i++) { userState[i].underlyingAsset = assets[i]; (userState[i].stakedByUser, userState[i].totalStaked) = IAToken(assets[i]) .getScaledUserBalanceAndSupply(user); } uint256 accruedRewards = _claimRewards(user, userState); if (accruedRewards != 0) { unclaimedRewards = unclaimedRewards.add(accruedRewards); emit RewardsAccrued(user, accruedRewards); } if (unclaimedRewards == 0) { return 0; } uint256 amountToClaim = amount > unclaimedRewards ? unclaimedRewards : amount; _usersUnclaimedRewards[user] = unclaimedRewards - amountToClaim; // Safe due to the previous line if (stake) { amountToClaim = amountToClaim.add(amountToClaim.mul(EXTRA_PSM_REWARD).div(100)); REWARD_TOKEN.transferFrom(REWARDS_VAULT, address(this), amountToClaim); PSM.stake(to, amountToClaim); } else { REWARD_TOKEN.transferFrom(REWARDS_VAULT, to, amountToClaim); } emit RewardsClaimed(msg.sender, to, amountToClaim); return amountToClaim; } /** * @dev returns the unclaimed rewards of the user * @param _user the address of the user * @return the unclaimed user rewards */ function getUserUnclaimedRewards(address _user) external view returns (uint256) { return _usersUnclaimedRewards[_user]; } /** * @dev returns the revision of the implementation contract */ function getRevision() internal override pure returns (uint256) { return REVISION; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; /** * @title VersionedInitializable * * @dev Helper contract to support initializer functions. To use it, replace * the constructor with a function that has the `initializer` modifier. * WARNING: Unlike constructors, initializer functions must be manually * invoked. This applies both to deploying an Initializable contract, as well * as extending an Initializable contract via inheritance. * WARNING: When used with inheritance, manual care must be taken to not invoke * a parent initializer twice, or ensure that all initializers are idempotent, * because this is not dealt with automatically as with constructors. * * @author Aave, inspired by the OpenZeppelin Initializable contract */ abstract contract VersionedInitializable { /** * @dev Indicates that the contract has been initialized. */ uint256 internal lastInitializedRevision = 0; /** * @dev Modifier to use in the initializer function of a contract. */ modifier initializer() { uint256 revision = getRevision(); require( revision > lastInitializedRevision, 'Contract instance has already been initialized' ); lastInitializedRevision = revision; _; } /// @dev returns the revision number of the contract. /// Needs to be defined in the inherited class as a constant. function getRevision() internal virtual pure returns (uint256); // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap; }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {IERC20} from '../interfaces/IERC20.sol'; import {StakedToken} from './StakedToken.sol'; /** * @title StakedAave * @notice StakedToken with AAVE token as staked token * @author Aave **/ contract StakedAave is StakedToken { string internal constant NAME = 'Staked Aave'; string internal constant SYMBOL = 'stkAAVE'; uint8 internal constant DECIMALS = 18; constructor( IERC20 stakedToken, IERC20 rewardToken, uint256 cooldownSeconds, uint256 unstakeWindow, address rewardsVault, address emissionManager, uint128 distributionDuration ) public StakedToken( stakedToken, rewardToken, cooldownSeconds, unstakeWindow, rewardsVault, emissionManager, distributionDuration, NAME, SYMBOL, DECIMALS) {} }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import {IERC20} from '../interfaces/IERC20.sol'; import {IStakedAave} from '../interfaces/IStakedAave.sol'; import {ITransferHook} from '../interfaces/ITransferHook.sol'; import {ERC20WithSnapshot} from '../lib/ERC20WithSnapshot.sol'; import {SafeERC20} from '../lib/SafeERC20.sol'; import {VersionedInitializable} from '../utils/VersionedInitializable.sol'; import {DistributionTypes} from '../lib/DistributionTypes.sol'; import {AaveDistributionManager} from './AaveDistributionManager.sol'; /** * @title StakedToken * @notice Contract to stake Aave token, tokenize the position and get rewards, inheriting from a distribution manager contract * @author Aave **/ contract StakedToken is IStakedAave, ERC20WithSnapshot, VersionedInitializable, AaveDistributionManager { using SafeERC20 for IERC20; uint256 public constant REVISION = 1; IERC20 public immutable STAKED_TOKEN; IERC20 public immutable REWARD_TOKEN; uint256 public immutable COOLDOWN_SECONDS; /// @notice Seconds available to redeem once the cooldown period is fullfilled uint256 public immutable UNSTAKE_WINDOW; /// @notice Address to pull from the rewards, needs to have approved this contract address public immutable REWARDS_VAULT; mapping(address => uint256) public stakerRewardsToClaim; mapping(address => uint256) public stakersCooldowns; event Staked(address indexed from, address indexed onBehalfOf, uint256 amount); event Redeem(address indexed from, address indexed to, uint256 amount); event RewardsAccrued(address user, uint256 amount); event RewardsClaimed(address indexed from, address indexed to, uint256 amount); event Cooldown(address indexed user); constructor( IERC20 stakedToken, IERC20 rewardToken, uint256 cooldownSeconds, uint256 unstakeWindow, address rewardsVault, address emissionManager, uint128 distributionDuration, string memory name, string memory symbol, uint8 decimals ) public ERC20WithSnapshot(name, symbol, decimals) AaveDistributionManager(emissionManager, distributionDuration) { STAKED_TOKEN = stakedToken; REWARD_TOKEN = rewardToken; COOLDOWN_SECONDS = cooldownSeconds; UNSTAKE_WINDOW = unstakeWindow; REWARDS_VAULT = rewardsVault; } /** * @dev Called by the proxy contract **/ function initialize(ITransferHook aaveGovernance, string calldata name, string calldata symbol, uint8 decimals) external initializer { _setName(name); _setSymbol(symbol); _setDecimals(decimals); _setAaveGovernance(aaveGovernance); } function stake(address onBehalfOf, uint256 amount) external override { require(amount != 0, 'INVALID_ZERO_AMOUNT'); uint256 balanceOfUser = balanceOf(onBehalfOf); uint256 accruedRewards = _updateUserAssetInternal( onBehalfOf, address(this), balanceOfUser, totalSupply() ); if (accruedRewards != 0) { emit RewardsAccrued(onBehalfOf, accruedRewards); stakerRewardsToClaim[onBehalfOf] = stakerRewardsToClaim[onBehalfOf].add(accruedRewards); } stakersCooldowns[onBehalfOf] = getNextCooldownTimestamp(0, amount, onBehalfOf, balanceOfUser); _mint(onBehalfOf, amount); IERC20(STAKED_TOKEN).safeTransferFrom(msg.sender, address(this), amount); emit Staked(msg.sender, onBehalfOf, amount); } /** * @dev Redeems staked tokens, and stop earning rewards * @param to Address to redeem to * @param amount Amount to redeem **/ function redeem(address to, uint256 amount) external override { require(amount != 0, 'INVALID_ZERO_AMOUNT'); //solium-disable-next-line uint256 cooldownStartTimestamp = stakersCooldowns[msg.sender]; require( block.timestamp > cooldownStartTimestamp.add(COOLDOWN_SECONDS), 'INSUFFICIENT_COOLDOWN' ); require( block.timestamp.sub(cooldownStartTimestamp.add(COOLDOWN_SECONDS)) <= UNSTAKE_WINDOW, 'UNSTAKE_WINDOW_FINISHED' ); uint256 balanceOfMessageSender = balanceOf(msg.sender); uint256 amountToRedeem = (amount > balanceOfMessageSender) ? balanceOfMessageSender : amount; _updateCurrentUnclaimedRewards(msg.sender, balanceOfMessageSender, true); _burn(msg.sender, amountToRedeem); if (balanceOfMessageSender.sub(amountToRedeem) == 0) { stakersCooldowns[msg.sender] = 0; } IERC20(STAKED_TOKEN).safeTransfer(to, amountToRedeem); emit Redeem(msg.sender, to, amountToRedeem); } /** * @dev Activates the cooldown period to unstake * - It can't be called if the user is not staking **/ function cooldown() external override { require(balanceOf(msg.sender) != 0, "INVALID_BALANCE_ON_COOLDOWN"); //solium-disable-next-line stakersCooldowns[msg.sender] = block.timestamp; emit Cooldown(msg.sender); } /** * @dev Claims an `amount` of `REWARD_TOKEN` to the address `to` * @param to Address to stake for * @param amount Amount to stake **/ function claimRewards(address to, uint256 amount) external override { uint256 newTotalRewards = _updateCurrentUnclaimedRewards( msg.sender, balanceOf(msg.sender), false ); uint256 amountToClaim = (amount == type(uint256).max) ? newTotalRewards : amount; stakerRewardsToClaim[msg.sender] = newTotalRewards.sub(amountToClaim, "INVALID_AMOUNT"); REWARD_TOKEN.safeTransferFrom(REWARDS_VAULT, to, amountToClaim); emit RewardsClaimed(msg.sender, to, amountToClaim); } /** * @dev Internal ERC20 _transfer of the tokenized staked tokens * @param from Address to transfer from * @param to Address to transfer to * @param amount Amount to transfer **/ function _transfer( address from, address to, uint256 amount ) internal override { uint256 balanceOfFrom = balanceOf(from); // Sender _updateCurrentUnclaimedRewards(from, balanceOfFrom, true); // Recipient if (from != to) { uint256 balanceOfTo = balanceOf(to); _updateCurrentUnclaimedRewards(to, balanceOfTo, true); uint256 previousSenderCooldown = stakersCooldowns[from]; stakersCooldowns[to] = getNextCooldownTimestamp(previousSenderCooldown, amount, to, balanceOfTo); // if cooldown was set and whole balance of sender was transferred - clear cooldown if (balanceOfFrom == amount && previousSenderCooldown != 0) { stakersCooldowns[from] = 0; } } super._transfer(from, to, amount); } /** * @dev Updates the user state related with his accrued rewards * @param user Address of the user * @param userBalance The current balance of the user * @param updateStorage Boolean flag used to update or not the stakerRewardsToClaim of the user * @return The unclaimed rewards that were added to the total accrued **/ function _updateCurrentUnclaimedRewards( address user, uint256 userBalance, bool updateStorage ) internal returns (uint256) { uint256 accruedRewards = _updateUserAssetInternal( user, address(this), userBalance, totalSupply() ); uint256 unclaimedRewards = stakerRewardsToClaim[user].add(accruedRewards); if (accruedRewards != 0) { if (updateStorage) { stakerRewardsToClaim[user] = unclaimedRewards; } emit RewardsAccrued(user, accruedRewards); } return unclaimedRewards; } /** * @dev Calculates the how is gonna be a new cooldown timestamp depending on the sender/receiver situation * - If the timestamp of the sender is "better" or the timestamp of the recipient is 0, we take the one of the recipient * - Weighted average of from/to cooldown timestamps if: * # The sender doesn't have the cooldown activated (timestamp 0). * # The sender timestamp is expired * # The sender has a "worse" timestamp * - If the receiver's cooldown timestamp expired (too old), the next is 0 * @param fromCooldownTimestamp Cooldown timestamp of the sender * @param amountToReceive Amount * @param toAddress Address of the recipient * @param toBalance Current balance of the receiver * @return The new cooldown timestamp **/ function getNextCooldownTimestamp( uint256 fromCooldownTimestamp, uint256 amountToReceive, address toAddress, uint256 toBalance ) public returns (uint256) { uint256 toCooldownTimestamp = stakersCooldowns[toAddress]; if (toCooldownTimestamp == 0) { return 0; } uint256 minimalValidCooldownTimestamp = block.timestamp.sub(COOLDOWN_SECONDS).sub( UNSTAKE_WINDOW ); if (minimalValidCooldownTimestamp > toCooldownTimestamp) { toCooldownTimestamp = 0; } else { uint256 fromCooldownTimestamp = (minimalValidCooldownTimestamp > fromCooldownTimestamp) ? block.timestamp : fromCooldownTimestamp; if (fromCooldownTimestamp < toCooldownTimestamp) { return toCooldownTimestamp; } else { toCooldownTimestamp = ( amountToReceive.mul(fromCooldownTimestamp).add(toBalance.mul(toCooldownTimestamp)) ) .div(amountToReceive.add(toBalance)); } } stakersCooldowns[toAddress] = toCooldownTimestamp; return toCooldownTimestamp; } /** * @dev Return the total rewards pending to claim by an staker * @param staker The staker address * @return The rewards */ function getTotalRewardsBalance(address staker) external view returns (uint256) { DistributionTypes.UserStakeInput[] memory userStakeInputs = new DistributionTypes.UserStakeInput[](1); userStakeInputs[0] = DistributionTypes.UserStakeInput({ underlyingAsset: address(this), stakedByUser: balanceOf(staker), totalStaked: totalSupply() }); return stakerRewardsToClaim[staker].add(_getUnclaimedRewards(staker, userStakeInputs)); } /** * @dev returns the revision of the implementation contract * @return The revision */ function getRevision() internal override pure returns (uint256) { return REVISION; } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; import '../lib/ERC20.sol'; /** * @title ERC20Mintable * @dev ERC20 minting logic */ contract MintableErc20 is ERC20 { constructor( string memory name, string memory symbol, uint8 decimals ) public ERC20(name, symbol, decimals) {} /** * @dev Function to mint tokens * @param value The amount of tokens to mint. * @return A boolean that indicates if the operation was successful. */ function mint(uint256 value) public returns (bool) { _mint(msg.sender, value); return true; } }
{ "metadata": { "useLiteralContent": false }, "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "evmVersion": "istanbul", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.