Stargate

1// SPDX-License-Identifier: BUSL-1.1
2
3pragma solidity 0.7.6;
4pragma abicoder v2;
5
6// imports
7import "@openzeppelin/contracts/access/Ownable.sol";
8import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
9import "./LPTokenERC20.sol";
10import "./interfaces/IStargateFeeLibrary.sol";
11
12// libraries
13import "@openzeppelin/contracts/math/SafeMath.sol";
14
15/// Pool contracts on other chains and managed by the Stargate protocol.
16contract Pool is LPTokenERC20, ReentrancyGuard {
17    using SafeMath for uint256;
18
19    //---------------------------------------------------------------------------
20    // CONSTANTS
21    bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
22    uint256 public constant BP_DENOMINATOR = 10000;
23
24    //---------------------------------------------------------------------------
25    // STRUCTS
26    struct ChainPath {
27        bool ready; // indicate if the counter chainPath has been created.
28        uint16 dstChainId;
29        uint256 dstPoolId;
30        uint256 weight;
31        uint256 balance;
32        uint256 lkb;
33        uint256 credits;
34        uint256 idealBalance;
35    }
36
37    struct SwapObj {
38        uint256 amount;
39        uint256 eqFee;
40        uint256 eqReward;
41        uint256 lpFee;
42        uint256 protocolFee;
43        uint256 lkbRemove;
44    }
45
46    struct CreditObj {
47        uint256 credits;
48        uint256 idealBalance;
49    }
50
51    //---------------------------------------------------------------------------
52    // VARIABLES
53
54    // chainPath
55    ChainPath[] public chainPaths; // list of connected chains with shared pools
56    mapping(uint16 => mapping(uint256 => uint256)) public chainPathIndexLookup; // lookup for chainPath by chainId => poolId =>index
57
58    // metadata
59    uint256 public immutable poolId; // shared id between chains to represent same pool
60    uint256 public sharedDecimals; // the shared decimals (lowest common decimals between chains)
61    uint256 public localDecimals; // the decimals for the token
62    uint256 public immutable convertRate; // the decimals for the token
63    address public immutable token; // the token for the pool
64    address public immutable router; // the token for the pool
65
66    bool public stopSwap; // flag to stop swapping in extreme cases
67
68    // Fee and Liquidity
69    uint256 public totalLiquidity; // the total amount of tokens added on this side of the chain (fees + deposits - withdrawals)
70    uint256 public totalWeight; // total weight for pool percentages
71    uint256 public mintFeeBP; // fee basis points for the mint/deposit
72    uint256 public protocolFeeBalance; // fee balance created from dao fee
73    uint256 public mintFeeBalance; // fee balance created from mint fee
74    uint256 public eqFeePool; // pool rewards in Shared Decimal format. indicate the total budget for reverse swap incentive
75    address public feeLibrary; // address for retrieving fee params for swaps
76
77    // Delta related
78    uint256 public deltaCredit; // credits accumulated from txn
79    bool public batched; // flag to indicate if we want batch processing.
80    bool public defaultSwapMode; // flag for the default mode for swap
81    bool public defaultLPMode; // flag for the default mode for lp
82    uint256 public swapDeltaBP; // basis points of poolCredits to activate Delta in swap
83    uint256 public lpDeltaBP; // basis points of poolCredits to activate Delta in liquidity events
84
85    //---------------------------------------------------------------------------
86    // EVENTS
87    event Mint(address to, uint256 amountLP, uint256 amountSD, uint256 mintFeeAmountSD);
88    event Burn(address from, uint256 amountLP, uint256 amountSD);
89    event RedeemLocalCallback(address _to, uint256 _amountSD, uint256 _amountToMintSD);
90    event Swap(
91        uint16 chainId,
92        uint256 dstPoolId,
93        address from,
94        uint256 amountSD,
95        uint256 eqReward,
96        uint256 eqFee,
97        uint256 protocolFee,
98        uint256 lpFee
99    );
100    event SendCredits(uint16 dstChainId, uint256 dstPoolId, uint256 credits, uint256 idealBalance);
101    event RedeemRemote(uint16 chainId, uint256 dstPoolId, address from, uint256 amountLP, uint256 amountSD);
102    event RedeemLocal(address from, uint256 amountLP, uint256 amountSD, uint16 chainId, uint256 dstPoolId, bytes to);
103    event InstantRedeemLocal(address from, uint256 amountLP, uint256 amountSD, address to);
104    event CreditChainPath(uint16 chainId, uint256 srcPoolId, uint256 amountSD, uint256 idealBalance);
105    event SwapRemote(address to, uint256 amountSD, uint256 protocolFee, uint256 dstFee);
106    event WithdrawRemote(uint16 srcChainId, uint256 srcPoolId, uint256 swapAmount, uint256 mintAmount);
107    event ChainPathUpdate(uint16 dstChainId, uint256 dstPoolId, uint256 weight);
108    event FeesUpdated(uint256 mintFeeBP);
109    event FeeLibraryUpdated(address feeLibraryAddr);
110    event StopSwapUpdated(bool swapStop);
111    event WithdrawProtocolFeeBalance(address to, uint256 amountSD);
112    event WithdrawMintFeeBalance(address to, uint256 amountSD);
113    event DeltaParamUpdated(bool batched, uint256 swapDeltaBP, uint256 lpDeltaBP, bool defaultSwapMode, bool defaultLPMode);
114
115    //---------------------------------------------------------------------------
116    // MODIFIERS
117    modifier onlyRouter() {
118        require(msg.sender == router, "Stargate: only the router can call this method");
119        _;
120    }
121
122    constructor(
123        uint256 _poolId,
124        address _router,
125        address _token,
126        uint256 _sharedDecimals,
127        uint256 _localDecimals,
128        address _feeLibrary,
129        string memory _name,
130        string memory _symbol
131    ) LPTokenERC20(_name, _symbol) {
132        require(_token != address(0x0), "Stargate: _token cannot be 0x0");
133        require(_router != address(0x0), "Stargate: _router cannot be 0x0");
134        poolId = _poolId;
135        router = _router;
136        token = _token;
137        sharedDecimals = _sharedDecimals;
138        decimals = uint8(_sharedDecimals);
139        localDecimals = _localDecimals;
140        convertRate = 10**(uint256(localDecimals).sub(sharedDecimals));
141        totalWeight = 0;
142        feeLibrary = _feeLibrary;
143
144        //delta algo related
145        batched = false;
146        defaultSwapMode = true;
147        defaultLPMode = true;
148    }
149
150    function getChainPathsLength() public view returns (uint256) {
151        return chainPaths.length;
152    }
153
154    //---------------------------------------------------------------------------
155    // LOCAL CHAIN FUNCTIONS
156
157    function mint(address _to, uint256 _amountLD) external nonReentrant onlyRouter returns (uint256) {
158        return _mintLocal(_to, _amountLD, true, true);
159    }
160
161    // Local                                    Remote
162    // -------                                  ---------
163    // swap             ->                      swapRemote
164    function swap(
165        uint16 _dstChainId,
166        uint256 _dstPoolId,
167        address _from,
168        uint256 _amountLD,
169        uint256 _minAmountLD,
170        bool newLiquidity
171    ) external nonReentrant onlyRouter returns (SwapObj memory) {
172        require(!stopSwap, "Stargate: swap func stopped");
173        ChainPath storage cp = getAndCheckCP(_dstChainId, _dstPoolId);
174        require(cp.ready == true, "Stargate: counter chainPath is not ready");
175
176        uint256 amountSD = amountLDtoSD(_amountLD);
177        uint256 minAmountSD = amountLDtoSD(_minAmountLD);
178
179        // request fee params from library
180        SwapObj memory s = IStargateFeeLibrary(feeLibrary).getFees(poolId, _dstPoolId, _dstChainId, _from, amountSD);
181
182        // equilibrium fee and reward. note eqFee/eqReward are separated from swap liquidity
183        eqFeePool = eqFeePool.sub(s.eqReward);
184        // update the new amount the user gets minus the fees
185        s.amount = amountSD.sub(s.eqFee).sub(s.protocolFee).sub(s.lpFee);
186        // users will also get the eqReward
187        require(s.amount.add(s.eqReward) >= minAmountSD, "Stargate: slippage too high");
188
189        // behaviours
190        //     - protocolFee: booked, stayed and withdrawn at remote.
191        //     - eqFee: booked, stayed and withdrawn at remote.
192        //     - lpFee: booked and stayed at remote, can be withdrawn anywhere
193
194        s.lkbRemove = amountSD.sub(s.lpFee).add(s.eqReward);
195        // check for transfer solvency.
196        require(cp.balance >= s.lkbRemove, "Stargate: dst balance too low");
197        cp.balance = cp.balance.sub(s.lkbRemove);
198
199        if (newLiquidity) {
200            deltaCredit = deltaCredit.add(amountSD).add(s.eqReward);
201        } else if (s.eqReward > 0) {
202            deltaCredit = deltaCredit.add(s.eqReward);
203        }
204
205        // distribute credits on condition.
206        if (!batched || deltaCredit >= totalLiquidity.mul(swapDeltaBP).div(BP_DENOMINATOR)) {
207            _delta(defaultSwapMode);
208        }
209
210        emit Swap(_dstChainId, _dstPoolId, _from, s.amount, s.eqReward, s.eqFee, s.protocolFee, s.lpFee);
211        return s;
212    }

JavaScript Tests