Saddle Finance

1pragma solidity 0.6.12;
2
3import "./SwapV1.sol";
4import "./interfaces/IFlashLoanReceiver.sol";
5
6/**
7 * @title Swap - A StableSwap implementation in solidity.
8 * @notice This contract is responsible for custody of closely pegged assets (eg. group of stablecoins)
9 * and automatic market making system. Users become an LP (Liquidity Provider) by depositing their tokens
10 * in desired ratios for an exchange of the pool token that represents their share of the pool.
11 * Users can burn pool tokens and withdraw their share of token(s).
12 *
13 * Each time a swap between the pooled tokens happens, a set fee incurs which effectively gets
14 * distributed to the LPs.
15 *
16 * In case of emergencies, admin can pause additional deposits, swaps, or single-asset withdraws - which
17 * stops the ratio of the tokens in the pool from changing.
18 * Users can always withdraw their tokens via multi-asset withdraws.
19 *
20 * @dev Most of the logic is stored as a library `SwapUtils` for the sake of reducing contract's
21 * deployment size.
22 */
23contract SwapFlashLoanV1 is SwapV1 {
24    // Total fee that is charged on all flashloans in BPS. Borrowers must repay the amount plus the flash loan fee.
25    // This fee is split between the protocol and the pool.
26    uint256 public flashLoanFeeBPS;
27    // Share of the flash loan fee that goes to the protocol in BPS. A portion of each flash loan fee is allocated
28    // to the protocol rather than the pool.
29    uint256 public protocolFeeShareBPS;
30    // Max BPS for limiting flash loan fee settings.
31    uint256 public constant MAX_BPS = 10000;
32
33    /*** EVENTS ***/
34    event FlashLoan(
35        address indexed receiver,
36        uint8 tokenIndex,
37        uint256 amount,
38        uint256 amountFee,
39        uint256 protocolFee
40    );
41
42    /**
43     * @notice Initializes this Swap contract with the given parameters.
44     * This will also clone a LPToken contract that represents users'
45     * LP positions. The owner of LPToken will be this contract - which means
46     * only this contract is allowed to mint/burn tokens.
47     *
48     * @param _pooledTokens an array of ERC20s this pool will accept
49     * @param decimals the decimals to use for each pooled token,
50     * eg 8 for WBTC. Cannot be larger than POOL_PRECISION_DECIMALS
51     * @param lpTokenName the long-form name of the token to be deployed
52     * @param lpTokenSymbol the short symbol for the token to be deployed
53     * @param _a the amplification coefficient * n * (n - 1). See the
54     * StableSwap paper for details
55     * @param _fee default swap fee to be initialized with
56     * @param _adminFee default adminFee to be initialized with
57     * @param _withdrawFee default withdrawFee to be initialized with
58     * @param lpTokenTargetAddress the address of an existing LPToken contract to use as a target
59     */
60    function initialize(
61        IERC20[] memory _pooledTokens,
62        uint8[] memory decimals,
63        string memory lpTokenName,
64        string memory lpTokenSymbol,
65        uint256 _a,
66        uint256 _fee,
67        uint256 _adminFee,
68        uint256 _withdrawFee,
69        address lpTokenTargetAddress
70    ) public virtual override initializer {
71        SwapV1.initialize(
72            _pooledTokens,
73            decimals,
74            lpTokenName,
75            lpTokenSymbol,
76            _a,
77            _fee,
78            _adminFee,
79            _withdrawFee,
80            lpTokenTargetAddress
81        );
82        flashLoanFeeBPS = 8; // 8 bps
83        protocolFeeShareBPS = 0; // 0 bps
84    }
85
86    /*** STATE MODIFYING FUNCTIONS ***/
87
88    /**
89     * @notice Borrow the specified token from this pool for this transaction only. This function will call
90     * `IFlashLoanReceiver(receiver).executeOperation` and the `receiver` must return the full amount of the token
91     * and the associated fee by the end of the callback transaction. If the conditions are not met, this call
92     * is reverted.
93     * @param receiver the address of the receiver of the token. This address must implement the IFlashLoanReceiver
94     * interface and the callback function `executeOperation`.
95     * @param token the protocol fee in bps to be applied on the total flash loan fee
96     * @param amount the total amount to borrow in this transaction
97     * @param params optional data to pass along to the callback function
98     */
99    function flashLoan(
100        address receiver,
101        IERC20 token,
102        uint256 amount,
103        bytes memory params
104    ) external nonReentrant {
105        uint8 tokenIndex = getTokenIndex(address(token));
106        uint256 availableLiquidityBefore = token.balanceOf(address(this));
107        uint256 protocolBalanceBefore = availableLiquidityBefore.sub(
108            swapStorage.balances[tokenIndex]
109        );
110        require(
111            amount > 0 && availableLiquidityBefore >= amount,
112            "invalid amount"
113        );
114
115        // Calculate the additional amount of tokens the pool should end up with
116        uint256 amountFee = amount.mul(flashLoanFeeBPS).div(10000);
117        // Calculate the portion of the fee that will go to the protocol
118        uint256 protocolFee = amountFee.mul(protocolFeeShareBPS).div(10000);
119        require(amountFee > 0, "amount is small for a flashLoan");
120
121        // Transfer the requested amount of tokens
122        token.safeTransfer(receiver, amount);
123
124        // Execute callback function on receiver
125        IFlashLoanReceiver(receiver).executeOperation(
126            address(this),
127            address(token),
128            amount,
129            amountFee,
130            params
131        );
132
133        uint256 availableLiquidityAfter = token.balanceOf(address(this));
134        require(
135            availableLiquidityAfter >= availableLiquidityBefore.add(amountFee),
136            "flashLoan fee is not met"
137        );
138
139        swapStorage.balances[tokenIndex] = availableLiquidityAfter
140            .sub(protocolBalanceBefore)
141            .sub(protocolFee);
142        emit FlashLoan(receiver, tokenIndex, amount, amountFee, protocolFee);
143    }
144
145    /*** ADMIN FUNCTIONS ***/
146
147    /**
148     * @notice Updates the flash loan fee parameters. This function can only be called by the owner.
149     * @param newFlashLoanFeeBPS the total fee in bps to be applied on future flash loans
150     * @param newProtocolFeeShareBPS the protocol fee in bps to be applied on the total flash loan fee
151     */
152    function setFlashLoanFees(
153        uint256 newFlashLoanFeeBPS,
154        uint256 newProtocolFeeShareBPS
155    ) external onlyOwner {
156        require(
157            newFlashLoanFeeBPS > 0 &&
158                newFlashLoanFeeBPS <= MAX_BPS &&
159                newProtocolFeeShareBPS <= MAX_BPS,
160            "fees are not in valid range"
161        );
162        flashLoanFeeBPS = newFlashLoanFeeBPS;
163        protocolFeeShareBPS = newProtocolFeeShareBPS;
164    }
165}