Olympus Finance

1contract OlympusStaking is Ownable {
2​
3    using SafeMath for uint256;
4    using SafeERC20 for IERC20;
5​
6    address public immutable OHM;
7    address public immutable sOHM;
8​
9    struct Epoch {
10        uint length;
11        uint number;
12        uint endBlock;
13        uint distribute;
14    }
15    Epoch public epoch;
16​
17    address public distributor;
18    
19    address public locker;
20    uint public totalBonus;
21    
22    address public warmupContract;
23    uint public warmupPeriod;
24    
25    constructor ( 
26        address _OHM, 
27        address _sOHM, 
28        uint _epochLength,
29        uint _firstEpochNumber,
30        uint _firstEpochBlock
31    ) {
32        require( _OHM != address(0) );
33        OHM = _OHM;
34        require( _sOHM != address(0) );
35        sOHM = _sOHM;
36        
37        epoch = Epoch({
38            length: _epochLength,
39            number: _firstEpochNumber,
40            endBlock: _firstEpochBlock,
41            distribute: 0
42        });
43    }
44​
45    struct Claim {
46        uint deposit;
47        uint gons;
48        uint expiry;
49        bool lock; // prevents malicious delays
50    }
51    mapping( address => Claim ) public warmupInfo;
52​
53    /**
54        @notice stake OHM to enter warmup
55        @param _amount uint
56        @return bool
57     */
58    function stake( uint _amount, address _recipient ) external returns ( bool ) {
59        rebase();
60        
61        IERC20( OHM ).safeTransferFrom( msg.sender, address(this), _amount );
62​
63        Claim memory info = warmupInfo[ _recipient ];
64        require( !info.lock, "Deposits for account are locked" );
65​
66        warmupInfo[ _recipient ] = Claim ({
67            deposit: info.deposit.add( _amount ),
68            gons: info.gons.add( IsOHM( sOHM ).gonsForBalance( _amount ) ),
69            expiry: epoch.number.add( warmupPeriod ),
70            lock: false
71        });
72        
73        IERC20( sOHM ).safeTransfer( warmupContract, _amount );
74        return true;
75    }
76​
77    /**
78        @notice retrieve sOHM from warmup
79        @param _recipient address
80     */
81    function claim ( address _recipient ) public {
82        Claim memory info = warmupInfo[ _recipient ];
83        if ( epoch.number >= info.expiry && info.expiry != 0 ) {
84            delete warmupInfo[ _recipient ];
85            IWarmup( warmupContract ).retrieve( _recipient, IsOHM( sOHM ).balanceForGons( info.gons ) );
86        }
87    }
88​
89    /**
90        @notice forfeit sOHM in warmup and retrieve OHM
91     */
92    function forfeit() external {
93        Claim memory info = warmupInfo[ msg.sender ];
94        delete warmupInfo[ msg.sender ];
95​
96        IWarmup( warmupContract ).retrieve( address(this), IsOHM( sOHM ).balanceForGons( info.gons ) );
97        IERC20( OHM ).safeTransfer( msg.sender, info.deposit );
98    }
99​
100    /**
101        @notice prevent new deposits to address (protection from malicious activity)
102     */
103    function toggleDepositLock() external {
104        warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
105    }
106​
107    /**
108        @notice redeem sOHM for OHM
109        @param _amount uint
110        @param _trigger bool
111     */
112    function unstake( uint _amount, bool _trigger ) external {
113        if ( _trigger ) {
114            rebase();
115        }
116        IERC20( sOHM ).safeTransferFrom( msg.sender, address(this), _amount );
117        IERC20( OHM ).safeTransfer( msg.sender, _amount );
118    }
119​
120    /**
121        @notice returns the sOHM index, which tracks rebase growth
122        @return uint
123     */
124    function index() public view returns ( uint ) {
125        return IsOHM( sOHM ).index();
126    }
127​
128    /**
129        @notice trigger rebase if epoch over
130     */
131    function rebase() public {
132        if( epoch.endBlock <= block.number ) {
133​
134            IsOHM( sOHM ).rebase( epoch.distribute, epoch.number );
135​
136            epoch.endBlock = epoch.endBlock.add( epoch.length );
137            epoch.number++;
138            
139            if ( distributor != address(0) ) {
140                IDistributor( distributor ).distribute();
141            }
142​
143            uint balance = contractBalance();
144            uint staked = IsOHM( sOHM ).circulatingSupply();
145​
146            if( balance <= staked ) {
147                epoch.distribute = 0;
148            } else {
149                epoch.distribute = balance.sub( staked );
150            }
151        }
152    }
153​
154    /**
155        @notice returns contract OHM holdings, including bonuses provided
156        @return uint
157     */
158    function contractBalance() public view returns ( uint ) {
159        return IERC20( OHM ).balanceOf( address(this) ).add( totalBonus );
160    }
161​
162    /*
163        @notice provide bonus to locked staking contract
164        @param _amount uint
165     */
166    function giveLockBonus( uint _amount ) external {
167        require( msg.sender == locker );
168        totalBonus = totalBonus.add( _amount );
169        IERC20( sOHM ).safeTransfer( locker, _amount );
170    }
171​
172    /*
173        @notice reclaim bonus from locked staking contract
174        @param _amount uint
175     */

Solidity Contracts

JavaScript Tests