Stability Pool One Way Swap Feature/Compounding vault

[HOVOH]

Overview: Add the ability for an external actor to one-way swap DebtToken (wUSD) -> Collateral (WFTM/sFTM/etc) based on oracle prices (no slippage) so we can recycle the same funds for the liquidations.

Motivation:

In the current implementation, you put DebtToken in the Stability Pool(SP) and when a liquidation occurs they will be used to buy the collateral at a discount (liquidation penalty). So stability depositor are buying Collateral at 90% market price for example. Then the FTM sits in the stability pool until it is withdrawn by the depositor. So the user ends up being exposed to FTM which he might not like, 2x long FTM if he minted the wUSD instead of buying it.

If DebtToken in the SP are depleted, the secondary liquidation mechanism is used and redistribute the debt and collateral to the existing vault. Slightly lowering the LTV of all accounts, but it is considered a non-UX friendly feature.

By allowing the swap of collateral back to debt token in the stability pool, external actors can swap the collateral from liquidations back to debt token and automatically compound their liquidations gains back to the debt token thus limiting their exposition to the collateral token. Most importantly it, improves liquidity in the stability pool by recycling deposits back to debt tokens.

Technical specification

To avoid touching the SP and break the audit track, we will use a vault approach with a strategy that will deposit into the SP. This will give the ability to users to either chose the compounding or not. It will also be possible to contribute this feature back to Gravita :)

Yearn team has done something similar for Liquity, but Gravita's Stability Pool has been rewritten completely. Here is the strategy for reference: https://etherscan.io/address/0xFf72f7C5f64ec2fd79B57d1A69C3311C1bB3EEF1#code

If you're more familiar with Yearn's architecture, go for it, otherwise Beefy's single strat vault is simple and pretty much all we need.

User Stories External actors want to swap debt token to collateral tokens SP depositor want to compound their gains in collateral back to debt tokens Administrators want to configure the price feed used to get swap rate

Swap behaviour

The swap behaviour will be based on a pro-rata using oracle prices from the PriceFeed contract.

A swap fee will be taken from the amount in from the swapper.

The debt token is always estimated at 1$.

If there is not enough liquidity, the function should revert. I.e: amount out > collateral balance

Example: Collateral PriceFeed result = 0.5$ Swap feed = 0.2% (0.002) Amount in (debt token)= 100 (100$)

fee amount = swap fee * amount in swap in = amount in - (fee amount) = 100 - (0.002 * 100) = 99.8 amount out = swap in / collateral price = 99.8/ 0.5 = 199,6

transfer fee amount of debt token to the treasury address transfer amount out of collateral token to the swapper

Withdraw behaviour

Users can only deposit the debt token, but if noone has traded in the pool after a liquidation, there will be some collateral. The withdraw function should handle this case and redistribute the collateral based on a pro-rata of the redeemed shares.

Task list

• [x] Import the Beefy's Vault https://github.com/beefyfinance/beefy-contracts/blob/master/contracts/BIFI/vaults/BeefyVaultV7.sol to the contracts/vault/ folder where we will push all SC related to this feature
• [x] Create a strategy that will deploy deposited funds from the vault to the Stability Pool
• [x] Add a swap(address token, uint amount) function to the strategy
• [x] Add a getAmountOut fn which will return the estimated amount of token received
• [x] Add a setTreasury fn to define the address to receive the swap fee
• [x] Add a setFee function to define the fee
• [ ] Complete test suite

[HOVOH]

Test suite requirements:

BaseStrategy: This contract is a template strategy, it implements RBAC.

Create a mock contract implementing the BaseStrategy contract with emtpty functions. You can make the deployer account the vault or not to test for permissions more easily.

tests: By external address I mean an address that is not supposed to be able to call it.

• [x] the vault() function returns the vault address
• [x] the want() functinor returns the input token address
• [x] beforeDeposit() reverts when called by an external address
• [x] beforeDeposit() does not revert when called by the vault address
• [x] deposit() reverts when called by an external address
• [x] deposit() should revert when the strategy is paused
• [x] deposit() does not revert when called by the vault address
• [x] withdraw() reverts when called by an external address
• [x] withdraw() does not revert when called by the vault address
• [x] the panic() function function should revert when called by an address
• [x] The panic() function should pause the strategy when called by an address member of the Circuit Breaker group
• [x] The retireStrat() fn should pause the strategy
• [x] retireStrat() should only be called by an admin address
• [x] pause() should revert when called by an external address
• [x] pause() should pause the contract when called by an admin
• [x] unpause() should revert when called by an external address
• [x] unpause() should unpause the strategy when called by an admin
• [x] paused() should return if the strategy is paused or not
• [x] addAdmin() should only be callable by and admin and add an admin
• [x] addAdmin() should revert when called by an external address
• [x] removeAdmin() should only be callable by and admin and remove an admin
• [x] removeAdmin() should revert when called by and external address
• [x] addCircuitBreaker() should only be callable by an admin and give the CircuitBreaker role
• [x] addCircuitBreaker() should revert when called by an external address
• [x] removeCircuitBreaker() should only be callable by an admin and remove the CircuitBreaker role
• [x] removeCircuitBreaker() should revert when called by an external address

SPVault:

• [ ] Just get the tests from Beefy

SPStrategy: There is a mock contract called StabilityPoolTester which can help you test the strategy tests:

• [ ] deposit() should deposit the fund sitting in the strategy into the SP contract
• [ ] balanceOfWant() should return the amount of tokens sitting in the strategy
• [ ] balanceOfPool() should return the amount of tokens deposited in the pool
• [ ] debtBalance() should return the amount of tokens sitting in the strategy + the amount deposited in the pool
• [ ] balanceOf() should return the debtBalance() + value of the collateral withdrawn to the strategy and still in the Stability Pool
• [ ] valueOfCollaterals() should return the value of all collateral tokens in the strategy and in the SP
• [ ] harvest() function should move the collateral in the stability pool to the strategy contract
• [ ] withdraw(amount, to) function should send debt token to if value of collateral is less than 1%
• [ ] withdraw(amount, to) function should send debt token and collateral tokens if value of collateral is gt 1% Ex 1: 1000 debt tokens in SP withdraw(500, MY_ADDRESS) -> MY_ADDRESS received 500 tokens Ex 2: 900 debt token in SP 200 collateral token at 0.5$ each total value: 1000$ 100$/ 1000$ = 10% => 10%>1% withdraw(500, MY_ADDRESS) => MY_ADDRESS receives 450 debt token and 100 collateral token 500 / 1000 = 50% 900 debtToken 0.5 (50%) = 450 200 collatToken 0.5 = 100
• retireStrat() should withdraw funds from everything to the vault
• panic() should withdraw everything to the vault
• setClaimCollaterals() should revert when called by an external address
• setClaimCollaterals() should set the array of collaterals claimed by the harvest fn
• setPriceFeed() should revert when called by and external address
• setPriceFeed() should set the address of the price feed used