Liquity Protocol — Stability Pool, Liquidations & Redemptions (Part 2)

In a previous article, I started explaining Liquity protocol from its smart contracts, where I went through its native tokens and its BorrowerOperations.sol among other things.

• Stability Pool
• Liquidations
• Redemptions

Stability Pool

StabilityPool.sol

• provideToSP(uint _amount, address _frontEndTag) — allows stablecoin holders to deposit _amount of LUSD to the Stability Pool.
• withdrawFromSP(uint _amount) — allows a stablecoin holder to withdraw _amount of LUSD from the Stability Pool, up to the value of their remaining Stability deposit.
• withdrawETHGainToTrove(address _hint) — sends the user's entire accumulated ETH gain to the user's active Trove, and updates their Stability deposit with its accumulated loss from debt absorptions.
• registerFrontEnd(uint _kickbackRate) — registers an address as a front end and sets their chosen kickback rate in the range [0,1].

ActivePool.sol

1function sendETH(address _account, uint _amount) external override {
2    _requireCallerIsBOorTroveMorSP();
3    ETH = ETH.sub(_amount);
4    emit ActivePoolETHBalanceUpdated(ETH);
5    emit EtherSent(_account, _amount);
6
7    (bool success, ) = _account.call{ value: _amount }("");
8    require(success, "ActivePool: sending ETH failed");
9}
10
11function increaseLUSDDebt(uint _amount) external override {
12    _requireCallerIsBOorTroveM();
13    LUSDDebt = LUSDDebt.add(_amount);
14    ActivePoolLUSDDebtUpdated(LUSDDebt);
15}
16
17function decreaseLUSDDebt(uint _amount) external override {
18    _requireCallerIsBOorTroveMorSP();
19    LUSDDebt = LUSDDebt.sub(_amount);
20    ActivePoolLUSDDebtUpdated(LUSDDebt);
21}

DefaultPool.sol

1function sendETHToActivePool(uint _amount) external override {
2    _requireCallerIsTroveManager();
3    address activePool = activePoolAddress; // cache to save an SLOAD
4    ETH = ETH.sub(_amount);
5    emit DefaultPoolETHBalanceUpdated(ETH);
6    emit EtherSent(activePool, _amount);
7
8    (bool success, ) = activePool.call{ value: _amount }("");
9    require(success, "DefaultPool: sending ETH failed");
10}

CollSurplusPool.sol

1function accountSurplus(address _account, uint _amount) external override {
2    _requireCallerIsTroveManager();
3
4    uint newAmount = balances[_account].add(_amount);
5    balances[_account] = newAmount;
6
7    emit CollBalanceUpdated(_account, newAmount);
8}
9
10function claimColl(address _account) external override {
11    _requireCallerIsBorrowerOperations();
12    uint claimableColl = balances[_account];
13    require(claimableColl > 0, "CollSurplusPool: No collateral available to claim");
14
15    balances[_account] = 0;
16    emit CollBalanceUpdated(_account, 0);
17
18    ETH = ETH.sub(claimableColl);
19    emit EtherSent(_account, claimableColl);
20
21    (bool success, ) = _account.call{ value: claimableColl }("");
22    require(success, "CollSurplusPool: sending ETH failed");
23}

GasPool.sol

Liquidations

• When a Trove falls below the minimum collateral ratio of 110%
• If the system is in Recovery Mode

Who can liquidate Troves?

Normal Mode

1function _liquidateNormalMode(
2    IActivePool _activePool,
3    IDefaultPool _defaultPool,
4    address _borrower,
5    uint _LUSDInStabPool
6) internal returns (LiquidationValues memory singleLiquidation)
7{
8    [...]
9    (singleLiquidation.entireTroveDebt,
10     singleLiquidation.entireTroveColl,
11     vars.pendingDebtReward,
12     vars.pendingCollReward) = getEntireDebtAndColl(_borrower);
13
14    _movePendingTroveRewardsToActivePool(
15        _activePool, _defaultPool,
16        vars.pendingDebtReward, vars.pendingCollReward
17    );
18    _removeStake(_borrower);
19
20    [...]
21    (singleLiquidation.debtToOffset,
22     singleLiquidation.collToSendToSP,
23     singleLiquidation.debtToRedistribute,
24     singleLiquidation.collToRedistribute) =
25        _getOffsetAndRedistributionVals(
26            singleLiquidation.entireTroveDebt,
27            collToLiquidate,
28            _LUSDInStabPool
29        );
30
31    _closeTrove(_borrower, Status.closedByLiquidation);
32
33    [...]
34}

Recovery Mode

Redemptions

What are LUSD redemptions?

TroveManager.sol — Redemption Logic

1function redeemCollateral(
2    uint _LUSDamount,
3    address _firstRedemptionHint,
4    address _upperPartialRedemptionHint,
5    address _lowerPartialRedemptionHint,
6    uint _partialRedemptionHintNICR,
7    uint _maxIterations,
8    uint _maxFeePercentage
9)
10    external
11    override
12{
13    [...]
14
15    if (_isValidFirstRedemptionHint(
16            contractsCache.sortedTroves,
17            _firstRedemptionHint,
18            totals.price))
19    {
20        currentBorrower = _firstRedemptionHint;
21    } else {
22        currentBorrower = contractsCache.sortedTroves.getLast();
23        // Find the first trove with ICR >= MCR
24        while (currentBorrower != address(0)
25            && getCurrentICR(currentBorrower, totals.price) < MCR)
26        {
27            currentBorrower = contractsCache.sortedTroves.getPrev(
28                currentBorrower
29            );
30        }
31    }
32
33    [...]
34}

Get in touch