StellaSwap

1// SPDX-License-Identifier: GPL-3.0
2
3pragma solidity =0.6.12;
4
5import './StellaSwapV2ERC20.sol';
6import './libraries/Math.sol';
7import './libraries/UQ112x112.sol';
8import './interfaces/IERC20.sol';
9import './interfaces/IStellaSwapV2Factory.sol';
10import './interfaces/IStellaSwapV2Callee.sol';
11
12interface IMigrator {
13    // Return the desired amount of liquidity token that the migrator wants.
14    function desiredLiquidity() external view returns (uint256);
15}
16
17contract StellaSwapV2Pair is StellaSwapV2ERC20 {
18    using SafeMathStellaSwap  for uint;
19    using UQ112x112 for uint224;
20
21    uint public constant MINIMUM_LIQUIDITY = 10**3;
22    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
23
24    address public factory;
25    address public token0;
26    address public token1;
27
28    uint112 private reserve0;           // uses single storage slot, accessible via getReserves
29    uint112 private reserve1;           // uses single storage slot, accessible via getReserves
30    uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves
31
32    uint public price0CumulativeLast;
33    uint public price1CumulativeLast;
34    uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
35
36    uint32 public swapFee = 25; // uses 0.25% default
37    uint32 public devFee = 5; // uses 0.05% default from swap fee
38
39    uint private unlocked = 1;
40    modifier lock() {
41        require(unlocked == 1, 'StellaSwapV2: LOCKED');
42        unlocked = 0;
43        _;
44        unlocked = 1;
45    }
46
47    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
48        _reserve0 = reserve0;
49        _reserve1 = reserve1;
50        _blockTimestampLast = blockTimestampLast;
51    }
52
53    function _safeTransfer(address token, address to, uint value) private {
54        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
55        require(success && (data.length == 0 || abi.decode(data, (bool))), 'StellaSwapV2: TRANSFER_FAILED');
56    }
57
58    event Mint(address indexed sender, uint amount0, uint amount1);
59    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
60    event Swap(
61        address indexed sender,
62        uint amount0In,
63        uint amount1In,
64        uint amount0Out,
65        uint amount1Out,
66        address indexed to
67    );
68    event Sync(uint112 reserve0, uint112 reserve1);
69
70    constructor() public {
71        factory = msg.sender;
72    }
73
74    // called once by the factory at time of deployment
75    function initialize(address _token0, address _token1) external {
76        require(msg.sender == factory, 'StellaSwapV2: FORBIDDEN'); // sufficient check
77        token0 = _token0;
78        token1 = _token1;
79    }
80
81    function setSwapFee(uint32 _swapFee) external {
82        require(_swapFee > 0, "StellaSwapV2: lower then 0");
83        require(msg.sender == factory, 'StellaSwapV2: FORBIDDEN');
84        require(_swapFee <= 1000, 'StellaSwapV2: FORBIDDEN_FEE');
85        swapFee = _swapFee;
86    }
87    
88    function setDevFee(uint32 _devFee) external {
89        require(_devFee > 0, "StellaSwapV2: lower then 0");
90        require(msg.sender == factory, 'StellaSwapV2: FORBIDDEN');
91        require(_devFee <= 500, 'StellaSwapV2: FORBIDDEN_FEE');
92        devFee = _devFee;
93    }
94
95    // update reserves and, on the first call per block, price accumulators
96    function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
97        require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'StellaSwapV2: OVERFLOW');
98        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
99        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
100        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
101            // * never overflows, and + overflow is desired
102            price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
103            price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
104        }
105        reserve0 = uint112(balance0);
106        reserve1 = uint112(balance1);
107        blockTimestampLast = blockTimestamp;
108        emit Sync(reserve0, reserve1);
109    }
110
111    // if fee is on, mint liquidity equivalent to 1/5th of the growth in sqrt(k)
112    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
113        address feeTo = IStellaSwapV2Factory(factory).feeTo();
114        feeOn = feeTo != address(0);
115        uint _kLast = kLast; // gas savings
116        if (feeOn) {
117            if (_kLast != 0) {
118                uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
119                uint rootKLast = Math.sqrt(_kLast);
120                if (rootK > rootKLast) {
121                    uint numerator = totalSupply.mul(rootK.sub(rootKLast));
122                    uint denominator = rootK.mul(devFee).add(rootKLast);
123                    uint liquidity = numerator / denominator;
124                    if (liquidity > 0) _mint(feeTo, liquidity);
125                }
126            }
127        } else if (_kLast != 0) {
128            kLast = 0;
129        }
130    }
131
132    // this low-level function should be called from a contract which performs important safety checks
133    function mint(address to) external lock returns (uint liquidity) {
134        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
135        uint balance0 = IERC20StellaSwap(token0).balanceOf(address(this));
136        uint balance1 = IERC20StellaSwap(token1).balanceOf(address(this));
137        uint amount0 = balance0.sub(_reserve0);
138        uint amount1 = balance1.sub(_reserve1);
139
140        bool feeOn = _mintFee(_reserve0, _reserve1);
141        uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
142        if (_totalSupply == 0) {
143            address migrator = IStellaSwapV2Factory(factory).migrator();
144            if (msg.sender == migrator) {
145                liquidity = IMigrator(migrator).desiredLiquidity();
146                require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
147            } else {
148                require(migrator == address(0), "Must not have migrator");
149                liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
150                _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
151            }
152        } else {
153            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
154        }
155        require(liquidity > 0, 'StellaSwapV2: INSUFFICIENT_LIQUIDITY_MINTED');
156        _mint(to, liquidity);
157
158        _update(balance0, balance1, _reserve0, _reserve1);
159        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
160        emit Mint(msg.sender, amount0, amount1);
161    }
162
163    // this low-level function should be called from a contract which performs important safety checks
164    function burn(address to) external lock returns (uint amount0, uint amount1) {
165        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
166        address _token0 = token0;                                // gas savings
167        address _token1 = token1;                                // gas savings
168        uint balance0 = IERC20StellaSwap(_token0).balanceOf(address(this));
169        uint balance1 = IERC20StellaSwap(_token1).balanceOf(address(this));
170        uint liquidity = balanceOf[address(this)];
171
172        bool feeOn = _mintFee(_reserve0, _reserve1);
173        uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
174        amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
175        amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
176        require(amount0 > 0 && amount1 > 0, 'StellaSwapV2: INSUFFICIENT_LIQUIDITY_BURNED');
177        _burn(address(this), liquidity);
178        _safeTransfer(_token0, to, amount0);
179        _safeTransfer(_token1, to, amount1);
180        balance0 = IERC20StellaSwap(_token0).balanceOf(address(this));
181        balance1 = IERC20StellaSwap(_token1).balanceOf(address(this));
182
183        _update(balance0, balance1, _reserve0, _reserve1);
184        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
185        emit Burn(msg.sender, amount0, amount1, to);
186    }
187
188    // this low-level function should be called from a contract which performs important safety checks
189    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
190        require(amount0Out > 0 || amount1Out > 0, 'StellaSwapV2: INSUFFICIENT_OUTPUT_AMOUNT');
191        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings