mirror of
https://github.com/Instadapp/fluid-contracts-public.git
synced 2024-07-29 21:57:37 +00:00
1081 lines
56 KiB
Solidity
1081 lines
56 KiB
Solidity
//SPDX-License-Identifier: MIT
|
|
pragma solidity 0.8.21;
|
|
|
|
import { Structs as AdminModuleStructs } from "../../../../contracts/liquidity/adminModule/structs.sol";
|
|
import { AuthModule, FluidLiquidityAdminModule } from "../../../../contracts/liquidity/adminModule/main.sol";
|
|
import { Structs as ResolverStructs } from "../../../../contracts/periphery/resolvers/liquidity/structs.sol";
|
|
import { ErrorTypes } from "../../../../contracts/liquidity/errorTypes.sol";
|
|
import { Error } from "../../../../contracts/liquidity/error.sol";
|
|
import { LiquidityUserModuleBaseTest } from "./liquidityUserModuleBaseTest.t.sol";
|
|
import { BigMathMinified } from "../../../../contracts/libraries/bigMathMinified.sol";
|
|
|
|
import "forge-std/console2.sol";
|
|
|
|
contract LiquidityUserModuleYieldTests is LiquidityUserModuleBaseTest {
|
|
function setUp() public virtual override {
|
|
super.setUp();
|
|
}
|
|
|
|
function test_operate_ExchangePriceSupplyWithInterestOnly() public {
|
|
// alice supplies liquidity
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 4); // supply rate = 1% of borrow rate
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// at 1% utilization, for default values of 4% at 0% utilization and 10% at 80% utilization.
|
|
// so over the range of 80%, the rate grows 6% linearly.
|
|
// 80 = 6, 1 = x => x = 6 / 80 * 1 = 0,075
|
|
// so 4% + 0.075% = 4.075%
|
|
// but borrow rate precision in Liquidity is only 0.01% so it becomes 4.07%.
|
|
// with supplyExchangePrice increasing 1% of that because only 1% of supply is borrowed out
|
|
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
uint256 expectedSupplyExchangePrice = 1000407000000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceSupplyInterestFreeOnly() public {
|
|
// alice supplies liquidity
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 0); // supply rate = 0 because no borrowers with interest
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
// with supplyExchangePrice staying the same as no suppliers that earn any interest
|
|
uint256 expectedSupplyExchangePrice = 1e12;
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceNumberUpOnlyWhenNoStorageUpdate() public {
|
|
// alice supplies liquidity
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// set storage update threshold to 5%
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
fee: 0, // no fee for simplicity
|
|
threshold: DEFAULT_STORAGE_UPDATE_THRESHOLD * 5, // 5%
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME / 1000);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
// just divided by 1000 to be below forced storage update if time diff > 1 day
|
|
// 407000000 / 1000 = 407000
|
|
uint256 expectedSupplyExchangePrice = 1000000407000; // increased 1% of borrow exchange price (because 1% of supply is borrowed out)
|
|
uint256 expectedBorrowExchangePrice = 1000040700000;
|
|
|
|
uint256 exchangePricesAndConfigBefore = resolver.getExchangePricesAndConfig(address(USDC));
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
|
|
// no storage update happening but that must not cause any issue with supplyExchangePrice
|
|
|
|
// assert exchangePricesAndConfig had no storage update
|
|
assertEq(exchangePricesAndConfigBefore, resolver.getExchangePricesAndConfig(address(USDC)));
|
|
|
|
vm.prank(alice);
|
|
(uint256 supplyExchangePrice2, uint256 borrowExchangePrice2) = mockProtocolWithInterest.operate(
|
|
address(USDC),
|
|
int256(DEFAULT_SUPPLY_AMOUNT),
|
|
0,
|
|
address(0),
|
|
address(0),
|
|
abi.encode(alice)
|
|
);
|
|
|
|
assertGe(supplyExchangePrice2, expectedSupplyExchangePrice);
|
|
assertGe(borrowExchangePrice2, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenSupplyWithInterestBigger() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 80) / 100);
|
|
|
|
// alice supplies liquidity interest free
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 20) / 100);
|
|
|
|
// total supply 1 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 18750); // 187.5%
|
|
|
|
// simulate passing time 1 / 10 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME / 10);
|
|
|
|
// at 100% utilization, borrow rate is 150%.
|
|
// just here we only warp 1/10 of the year so 15% increase.
|
|
uint256 expectedBorrowExchangePrice = 1150000000000;
|
|
// total earnings for suppliers are 100% of borrow increase. But only 80% of suppliers earn that.
|
|
// so exchange price must grow 25% more to account for that: 150000000000 * 1.25 = 187500000000
|
|
uint256 expectedSupplyExchangePrice = 1187500000000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenSupplyInterestFreeBigger() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 20);
|
|
|
|
// alice supplies liquidity interest free
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 80);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 20);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase (0,0407%). But only 20% of suppliers earn that.
|
|
// so exchange price must grow 5x more to account for that: 407000000 * 5 = 2035000000
|
|
uint256 expectedSupplyExchangePrice = 1002035000000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenSupplyWithInterestExactlySupplyInterestFree() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 50);
|
|
|
|
// alice supplies liquidity interest free
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 50);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 8);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase (0,0407%). But only 50% of suppliers earn that.
|
|
// so exchange price must grow 2x more to account for that: 407000000 * 2 = 814000000
|
|
uint256 expectedSupplyExchangePrice = 1000814000000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenSupplyWithInterestBiggerWithRevenueFee() public {
|
|
// set revenue fee to 10%
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
fee: 10 * DEFAULT_PERCENT_PRECISION,
|
|
threshold: 0,
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs);
|
|
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 80);
|
|
|
|
// alice supplies liquidity interest free
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 20);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 4);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase MINUS the revenue fee.
|
|
// so 40700000000 * 1% - 10% = 366300000. But only 80% of suppliers earn that.
|
|
// so exchange price must grow 25% more to account for that: 366300000 * 1.25 = 457875000
|
|
uint256 expectedSupplyExchangePrice = 1000457875000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenSupplyInterestFreeBiggerWithRevenueFee() public {
|
|
// set revenue fee to 10%
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
fee: 10 * DEFAULT_PERCENT_PRECISION,
|
|
threshold: 0,
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs);
|
|
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 20);
|
|
|
|
// alice supplies liquidity interest free
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 80);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 18);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase MINUS the revenue fee.
|
|
// so 40700000000 * 1% - 10% = 366300000. But only 20% of suppliers earn that.
|
|
// so exchange price must grow 5x more to account for that: 366300000 * 5 = 1831500000
|
|
uint256 expectedSupplyExchangePrice = 1001831500000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceSequences() public {
|
|
// alice supplies liquidity
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 10);
|
|
|
|
// total supply 10 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 47); // 10% of borrow rate
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for exchange price calculation.
|
|
// 10% utilization borrow rate => x = 6 / 80 * 10 = 0,75. 4 + 0.75 => 4.75%
|
|
// with 10% of supply earning yield
|
|
uint256 expectedBorrowExchangePrice = 1047500000000;
|
|
uint256 expectedSupplyExchangePrice = 1004750000000;
|
|
|
|
// deposits DEFAULT_BORROW_AMOUNT
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
|
|
// utilization here increased to:
|
|
// total borrow = DEFAULT_BORROW_AMOUNT * 1047500000000 / 1e12 = 0,52375
|
|
// total supply = 10 * DEFAULT_BORROW_AMOUNT * 1004750000000 / 1e12 + DEFAULT_BORROW_AMOUNT
|
|
// = 5,02375 ether + 0,5 ether = 5,52375
|
|
// utilization = 0,52375 / 5,52375 = 9,4817%; cut off precision to 0.01%-> 9,48%.
|
|
// so borrow rate:
|
|
// at 9,48% utilization x = 6 / 80 * 9,48% = 0.711
|
|
// so 4% + 0.711% = 4.711% but cut off precision to 0.01%-> 4,71%.
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 44); // 9,48% of borrow rate
|
|
|
|
// simulate passing time 1 year for yield again
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
expectedBorrowExchangePrice = (1047500000000 * (1e4 + 471)) / 1e4;
|
|
// same multiplicator here for supple exchange price as no revenue fee and only with interest suppliers.
|
|
// only 9.48% of supply is borrowed out though so
|
|
// increase in supplyExchangePrice = ((1004750000000 * 471 * 948) / 1e4 / 1e4) = 4486289130
|
|
expectedSupplyExchangePrice = 1004750000000 + 4486289130; // = 1009236289130
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
// function test_operate_ExchangePriceBorrowWithInterestOnly() public {
|
|
// already covered by tests for supply exchange prices as they use borrow with interest only
|
|
// }
|
|
|
|
function test_operate_ExchangePriceBorrowInterestFreeOnly() public {
|
|
// alice supplies liquidity
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// both exchange prices should be initial value as there is no yield.
|
|
uint256 expectedSupplyExchangePrice = 1e12;
|
|
uint256 expectedBorrowExchangePrice = 1e12;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenBorrowWithInterestBigger() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity with interest
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 8) / 10);
|
|
|
|
// alice borrows liquidity interest free
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 2) / 10);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 3);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase (1% is lent out).
|
|
// But only 80% of the borrowers pay the yield.
|
|
// so exchange price must grow 20% less to account for that:
|
|
// supplyRate = 4,07% * 0,8 = 3,256%. so supplyIncrease = 325600000
|
|
uint256 expectedSupplyExchangePrice = 1000325600000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenBorrowInterestFreeBigger() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity with interest
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 2) / 10);
|
|
|
|
// alice borrows liquidity interest free
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 8) / 10);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 0); // 0.008%
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase (1% is lent out).
|
|
// But only 20% of the borrowers pay the yield.
|
|
// so exchange price must grow 80% less to account for that: 407000000 * 0.2 = 81400000
|
|
uint256 expectedSupplyExchangePrice = 1000081400000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenBorrowWithInterestExacltyBorrowInterestFree() public {
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity with interest
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT / 2);
|
|
|
|
// alice borrows liquidity interest free
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, DEFAULT_BORROW_AMOUNT / 2);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 2);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for borrow exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// total earnings for suppliers are 1% of borrow increase. But only 50% of borrowers pay that.
|
|
// so exchange price must grow half to account for that: 407000000 / 2 = 203500000
|
|
uint256 expectedSupplyExchangePrice = 1000203500000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenBorrowWithInterestBiggerWithRevenueFee() public {
|
|
// set revenue fee to 10%
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
fee: 10 * DEFAULT_PERCENT_PRECISION,
|
|
threshold: 0,
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs);
|
|
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity with interest
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 8) / 10);
|
|
|
|
// alice borrows liquidity interest free
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 2) / 10);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 2);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// 10% of total earnings go to revenue so 4,07% * 0,9 = 3,663%
|
|
// and only 1% total is lent out so 3,663% *0,01 = 0,03663%
|
|
// But only 80% of the borrowers pay the yield. so rate must grow 20% less: 0,03663% *0,8 = 0,029304%
|
|
// so supplyRate 0,029304%. so supplyIncrease = 293040000
|
|
uint256 expectedSupplyExchangePrice = 1000293040000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
function test_operate_ExchangePriceWhenBorrowInterestFreeBiggerWithRevenueFee() public {
|
|
// set revenue fee to 10%
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
fee: 10 * DEFAULT_PERCENT_PRECISION,
|
|
threshold: 0,
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs);
|
|
|
|
// alice supplies liquidity with interest
|
|
_supply(mockProtocolWithInterest, address(USDC), alice, DEFAULT_BORROW_AMOUNT * 100);
|
|
|
|
// total supply 100 * DEFAULT_BORROW_AMOUNT.
|
|
|
|
// alice borrows liquidity with interest
|
|
_borrow(mockProtocolWithInterest, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 2) / 10);
|
|
|
|
// alice borrows liquidity interest free
|
|
_borrow(mockProtocolInterestFree, address(USDC), alice, (DEFAULT_BORROW_AMOUNT * 8) / 10);
|
|
|
|
// cross-check resolver supply rate. see calc exchange price below
|
|
ResolverStructs.OverallTokenData memory overallTokenData = resolver.getOverallTokenData(address(USDC));
|
|
assertEq(overallTokenData.supplyRate, 0);
|
|
|
|
// simulate passing time 1 year for yield
|
|
vm.warp(block.timestamp + PASS_1YEAR_TIME);
|
|
|
|
// see test_operate_ExchangePriceSupplyWithInterestOnly for exchange price calculation.
|
|
uint256 expectedBorrowExchangePrice = 1040700000000;
|
|
// 10% of total earnings go to revenue so 40700000000 * 0.9 = 36630000000 = 3,663%
|
|
// total earnings for suppliers are 1% of borrow increase (1% is lent out). so 366300000 = 0,03663%
|
|
// But only 20% of the borrowers pay the yield.
|
|
// so exchange price must grow 80% less to account for that: 366300000 * 0.2 = 73260000 = supplyRate: 0,07326%
|
|
uint256 expectedSupplyExchangePrice = 1000073260000;
|
|
|
|
_assertExchangePrices(expectedSupplyExchangePrice, expectedBorrowExchangePrice);
|
|
}
|
|
|
|
// todo: test supply with interest only but only borrow interest free -> no yield
|
|
// todo: supply with interest free only, with borrow with interest -> all goes to revenue
|
|
|
|
function _assertExchangePrices(uint256 expectedSupplyExchangePrice, uint256 expectedBorrowExchangePrice) internal {
|
|
vm.prank(alice);
|
|
(uint256 supplyExchangePrice, uint256 borrowExchangePrice) = mockProtocolWithInterest.operate(
|
|
address(USDC),
|
|
int256(DEFAULT_BORROW_AMOUNT),
|
|
0,
|
|
address(0),
|
|
address(0),
|
|
abi.encode(alice)
|
|
);
|
|
|
|
assertEq(supplyExchangePrice, expectedSupplyExchangePrice, "supply exchange price off");
|
|
assertEq(borrowExchangePrice, expectedBorrowExchangePrice, "borrow exchange price off");
|
|
}
|
|
}
|
|
|
|
abstract contract LiquidityUserModuleYieldCombinationBaseTest is LiquidityUserModuleBaseTest {
|
|
uint256 constant baseLimit = 5 ether;
|
|
|
|
uint256 immutable baseLimitAfterBigMath;
|
|
|
|
constructor() {
|
|
baseLimitAfterBigMath = BigMathMinified.fromBigNumber(
|
|
BigMathMinified.toBigNumber(
|
|
baseLimit,
|
|
SMALL_COEFFICIENT_SIZE,
|
|
DEFAULT_EXPONENT_SIZE,
|
|
BigMathMinified.ROUND_DOWN
|
|
),
|
|
DEFAULT_EXPONENT_SIZE,
|
|
DEFAULT_EXPONENT_MASK
|
|
);
|
|
}
|
|
|
|
function setUp() public virtual override {
|
|
super.setUp();
|
|
|
|
AdminModuleStructs.TokenConfig[] memory tokenConfigs_ = new AdminModuleStructs.TokenConfig[](1);
|
|
tokenConfigs_[0] = AdminModuleStructs.TokenConfig({
|
|
token: address(USDC),
|
|
// set threshold and fee to 0 so it doesn't affect tests that don't specifically target testing this
|
|
fee: DEFAULT_TOKEN_FEE, // 5%
|
|
threshold: 0,
|
|
maxUtilization: 1e4 // 100%
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateTokenConfigs(tokenConfigs_);
|
|
|
|
// Set withdraw config with actual limits
|
|
AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_ = new AdminModuleStructs.UserSupplyConfig[](1);
|
|
userSupplyConfigs_[0] = AdminModuleStructs.UserSupplyConfig({
|
|
user: address(mockProtocol),
|
|
token: address(USDC),
|
|
mode: 1,
|
|
expandPercent: DEFAULT_EXPAND_WITHDRAWAL_LIMIT_PERCENT, // 20%
|
|
expandDuration: DEFAULT_EXPAND_WITHDRAWAL_LIMIT_DURATION, // 2 days;
|
|
baseWithdrawalLimit: baseLimit
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateUserSupplyConfigs(userSupplyConfigs_);
|
|
|
|
// Set borrow config with actual limits
|
|
AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_ = new AdminModuleStructs.UserBorrowConfig[](1);
|
|
userBorrowConfigs_[0] = AdminModuleStructs.UserBorrowConfig({
|
|
user: address(mockProtocol),
|
|
token: address(USDC),
|
|
mode: 1,
|
|
expandPercent: DEFAULT_EXPAND_DEBT_CEILING_PERCENT, // 20%
|
|
expandDuration: DEFAULT_EXPAND_DEBT_CEILING_DURATION, // 2 days;
|
|
baseDebtCeiling: baseLimit,
|
|
maxDebtCeiling: 20 ether
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateUserBorrowConfigs(userBorrowConfigs_);
|
|
}
|
|
|
|
// test uses default values from liquidityTestHelpers.sol:
|
|
// uint256 constant DEFAULT_TOKEN_FEE = 5 * DEFAULT_PERCENT_PRECISION; // 5%
|
|
|
|
// uint256 constant DEFAULT_KINK = 80 * DEFAULT_PERCENT_PRECISION; // 80%
|
|
// uint256 constant DEFAULT_RATE_AT_ZERO = 4 * DEFAULT_PERCENT_PRECISION; // 4%
|
|
// uint256 constant DEFAULT_RATE_AT_KINK = 10 * DEFAULT_PERCENT_PRECISION; // 10%
|
|
// uint256 constant DEFAULT_RATE_AT_MAX = 150 * DEFAULT_PERCENT_PRECISION; // 150%
|
|
// // for rate data v2:
|
|
// uint256 constant DEFAULT_KINK2 = 90 * DEFAULT_PERCENT_PRECISION; // 90%
|
|
// uint256 constant DEFAULT_RATE_AT_KINK2 = 80 * DEFAULT_PERCENT_PRECISION; // 10% + half way to 150% = 80% for data compatibility with v1
|
|
|
|
function test_operate_YieldCombinationTest() public {
|
|
// supply liquidity with interest
|
|
_supply(mockProtocol, address(USDC), alice, 4 ether);
|
|
|
|
// 1. test yield at ~zero: borrow very little amount
|
|
_borrow(mockProtocol, address(USDC), alice, 1e15);
|
|
|
|
_assertState(
|
|
400, // expected borrow rate
|
|
0, // expected supply rate. only very tiny amount of borrowers are paying yield
|
|
1e12, // expected supply exchange price.
|
|
1e12, // expected borrow exchange price.
|
|
0, // expected revenue
|
|
4 ether, // expected supply raw interest
|
|
0 ether, // expected supply interest free
|
|
1e15, // expected borrow raw interest
|
|
0 ether, // expected borrow interest free
|
|
0, // expected withdrawal limit
|
|
baseLimitAfterBigMath // expected borrow limit
|
|
);
|
|
|
|
// warp & assert everything
|
|
// 1e15 paying 4% for half a year -> 2% yield. 5% of that is revenue.
|
|
// supply rate = 4% - 5% revenue fee -> 3.8%. only 0.025% utilization -> 0.095%.
|
|
// only earned for half a year so 0.0475%.
|
|
// BUT: precision for utilization is actually cut off at 0.02% so we get 0.076%. / 2 = 0.038%.
|
|
// Revenue should be 1e12 but precision cut off in utilization leads to supply exchange price difference.
|
|
// the precision loss is counted towards revenue. total supply ends up being 4 ether * 1000003800000 / 1e12 instead of
|
|
// 4 ether * 10000047500000 / 1e12, leading to a total diff of 3.8e12
|
|
vm.warp(block.timestamp + 365 days / 2); // earn half a year yield
|
|
uint256 expectedSupplyExchangePrice = 1000003800000;
|
|
uint256 expectedBorrowExchangePrice = 1020000000000; // increased by 2%
|
|
uint256 expectedRevenue = 48e11; // 4.8e12
|
|
_assertState(
|
|
400, // expected borrow rate
|
|
0, // expected supply rate. supply rate precision is cut off to 0
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
4 ether, // expected supply raw interest
|
|
0 ether, // expected supply interest free
|
|
1e15, // expected borrow raw interest
|
|
0 ether, // expected borrow interest free
|
|
0, // expected withdrawal limit
|
|
(baseLimitAfterBigMath * expectedBorrowExchangePrice) / 1e12 // expected borrow limit
|
|
);
|
|
|
|
// 2. test yield at below kink 1
|
|
_supply(mockProtocol, address(USDC), alice, 6 ether - 4000015200000000000); // bring total supply to 6 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 1.2 ether - 1020000000000000); // bring utilization to 20%
|
|
|
|
// warp & assert everything
|
|
// borrow rate = 4% + 1/4 of slope 6% (10% -4%) -> 5.5%.
|
|
// 1.2 ether paying 5.5% for 10% of a year -> 0.55% yield. 5% of that is revenue.
|
|
// supply rate = 5.5% - 5% revenue fee -> 5.225%. only 20% utilization -> 1.045%.
|
|
// only earned for 10% of a year so 0.1045%.
|
|
// 0.55% of 1.2 ether is 0.0066 ether in yield. 5% goes to revenue -> 0,00033
|
|
vm.warp(block.timestamp + 365 days / 10); // earn 10% of a year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 1001045) / 1000000; // increased by 0.1045%.
|
|
assertEq(expectedSupplyExchangePrice, 1001048803971);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 1005500) / 1000000; // increased by 0.55%
|
|
assertEq(expectedBorrowExchangePrice, 1025610000000);
|
|
expectedRevenue += 0.00033 ether;
|
|
// expected withdrawal limit:
|
|
// 20% of total supply expanded (5999977200086639488 * 0.8 = 4799981760069311590)
|
|
uint256 expectedWithdrawalLimit = (4799981760069311590 * expectedSupplyExchangePrice) / 1e12;
|
|
_assertState(
|
|
550, // expected borrow rate
|
|
104, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
5999977200086639488, // expected supply raw interest. total supply 6006269999999999817
|
|
0 ether, // expected supply interest free
|
|
1176470588235294144, // expected borrow raw interest. total borrow 1206600000000000027
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit. fully expanded 20%
|
|
(baseLimitAfterBigMath * expectedBorrowExchangePrice) / 1e12 // expected borrow limit
|
|
);
|
|
|
|
// 3. test yield at kink 1
|
|
_supply(mockProtocol, address(USDC), alice, 6.2 ether - 6006269999999999817); // bring total supply to 6.2 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 4.96 ether - 1206600000000000027); // bring utilization to 80%
|
|
|
|
// warp & assert everything
|
|
// borrow rate at kink1 = 10%
|
|
// 4.96 ether paying 10% for a year -> 10% yield. 5% of that is revenue.
|
|
// supply rate = 10% - 5% revenue fee -> 9.5%. only 80% utilization -> 7.6%.
|
|
// 0.496 ether in yield. 5% goes to revenue -> 0,0248
|
|
vm.warp(block.timestamp + 365 days); // earn a year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 1076000) / 1000000; // increased by 7.6%.
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 1100000) / 1000000; // increased by 10%
|
|
expectedRevenue += 0.0248 ether + 4930649; // tolerate some inaccuracy 4930649, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 5336959999996055776; // user total supply 20% expanded
|
|
_assertState(
|
|
1000, // expected borrow rate
|
|
760, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
6193504228171088640, // expected supply raw interest. total supply 6671199999995069720
|
|
0 ether, // expected supply interest free
|
|
4836146293425376256, // expected borrow raw interest. total borrow 5456000000000000156
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit. fully expanded 20%
|
|
6547200000000000187 // expected borrow limit. user total borrow fully expanded 20%
|
|
);
|
|
|
|
// 4. test yield above kink 1
|
|
_supply(mockProtocol, address(USDC), alice, 7.5 ether - 6671199999995069720); // bring total supply to 7.5 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 6.375 ether - 5456000000000000156); // bring utilization to 85%
|
|
|
|
// warp & assert everything
|
|
// borrow rate = 10% + 1/4 of slope 140% (150% -10%) -> 45%.
|
|
// 6.375 ether paying 45% for a 1/3 year -> 15% yield. 5% of that is revenue.
|
|
// supply rate = 45% - 5% revenue fee -> 42.75%. only 85% utilization -> 36.3375%.
|
|
// 0.95625 ether in yield. 5% goes to revenue -> 0,0478125
|
|
vm.warp(block.timestamp + 365 days / 3); // earn a 1/3 year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 1121125) / 1000000; // increased by 12,1125% (rate for 1/3 year)
|
|
assertEq(expectedSupplyExchangePrice, 1207595704217);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 1150000) / 1000000; // increased by 15% (rate for 1/3 year)
|
|
assertEq(expectedBorrowExchangePrice, 1297396650000);
|
|
expectedRevenue += 0.0478125 ether + 5891211; // tolerate some inaccuracy 5891211, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 6726749999995287266; // user total supply 20% expanded
|
|
_assertState(
|
|
4500, // expected borrow rate
|
|
3633, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
6962957445634592384, // expected supply raw interest. total supply 8408437499994109082
|
|
0 ether, // expected supply interest free
|
|
5650739116676461440, // expected borrow raw interest. total borrow 7331250000000000206
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit. fully expanded 20%
|
|
8797500000000000247 // expected borrow limit. user total borrow fully expanded 20%
|
|
);
|
|
|
|
// 5. test yield at kink 2 (same values without another kink for v1)
|
|
_supply(mockProtocol, address(USDC), alice, 8.5 ether - 8408437499994109082); // bring total supply to 8.5 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 7.65 ether - 7331250000000000206); // bring utilization to 90%
|
|
|
|
// warp & assert everything
|
|
// borrow rate at kink2 = 80%
|
|
// 7.65 ether paying 80% for 5% of a year -> 4% yield. 5% of that is revenue.
|
|
// supply rate = 80% - 5% revenue fee -> 76%. only 90% utilization -> 68.4%.
|
|
// 0.306 ether in yield. 5% goes to revenue -> 0,0153
|
|
vm.warp(block.timestamp + 365 days / 20); // earn 5% of a year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 1034200) / 1000000; // increased by 3.42%. (rate for 1/20 year)
|
|
assertEq(expectedSupplyExchangePrice, 1248895477301);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 1040000) / 1000000; // increased by 4% (rate for 1/20 year)
|
|
assertEq(expectedBorrowExchangePrice, 1349292516000);
|
|
expectedRevenue += 0.0153 ether + 1559103; // tolerate some inaccuracy 1559103, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 7032559999998753095; // user total supply 20% expanded
|
|
_assertState(
|
|
8000, // expected borrow rate
|
|
6840, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
7038779593466146176, // expected supply raw interest. total supply 8790699999998441369
|
|
0 ether, // expected supply interest free
|
|
5896423426097177216, // expected borrow raw interest. total borrow 7956000000000000306
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit. fully expanded 20%
|
|
9547200000000000367 // expected borrow limit. user total borrow fully expanded 20%
|
|
);
|
|
|
|
// 6. test yield above kink 2 (same values without another kink for v1)
|
|
_supply(mockProtocol, address(USDC), alice, 8.8 ether - 8790699999998441369); // bring total supply to 8.8 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 8.096 ether - 7956000000000000306); // bring utilization to 92%
|
|
|
|
// warp & assert everything
|
|
// borrow rate = 80% + 1/5 of slope 70% (150% -80%) -> 94%.
|
|
// 8.096 ether paying 94% for a 1/365 year -> 0.25753424657534246% yield. 5% of that is revenue.
|
|
// supply rate = 94% - 5% revenue fee -> 89.3%. only 92% utilization -> 82.156%.
|
|
// 0.020849972602739726 ether in yield. 5% goes to revenue -> 0,001042498630136986
|
|
vm.warp(block.timestamp + 1 days); // earn a 1 day yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 10022508493150684) / 10000000000000000; // increased by 0.22508493150684931% (rate for 1/365 year)
|
|
assertEq(expectedSupplyExchangePrice, 1251706552830);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 10025753424657534) / 10000000000000000; // increased by 0.25753424657534246% (rate for 1/365 year)
|
|
assertEq(expectedBorrowExchangePrice, 1352767406315);
|
|
expectedRevenue += 0.001042498630136986 ether + 3689037; // tolerate some inaccuracy 3689037, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 7055845979174276467; // user total supply 20% fully expanded because start expand point was close
|
|
_assertState(
|
|
9400, // expected borrow rate
|
|
8215, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
7046226173400646912, // expected supply raw interest. total supply 8819807473967845584
|
|
0 ether, // expected supply interest free
|
|
6000181505490541312, // expected borrow raw interest. total borrow 8116849972601671502
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit.
|
|
9740219967122005802 // expected borrow limit. user total borrow fully expanded 20% because start expand point was close
|
|
);
|
|
|
|
// 7. test yield at max
|
|
_supply(mockProtocol, address(USDC), alice, 9.6 ether - 8819807473967845584); // bring total supply to 9.6 ether
|
|
_borrow(mockProtocol, address(USDC), alice, 9.6 ether - 8116849972601671502); // bring utilization to 100%
|
|
|
|
// warp & assert everything
|
|
// borrow rate at max = 150%.
|
|
// 9.6 ether paying 150% for a 10% of a year -> 15% yield. 5% of that is revenue.
|
|
// supply rate = 150% - 5% revenue fee -> 142.5%. 100% utilization.
|
|
// 1.44 ether in yield. 5% goes to revenue -> 0,072
|
|
vm.warp(block.timestamp + 365 days / 10); // earn a 10% year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 1142500) / 1000000; // increased by 14.25% (rate for 1/10 year)
|
|
assertEq(expectedSupplyExchangePrice, 1430074736608);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 1150000) / 1000000; // increased by 15% (rate for 1/10 year)
|
|
assertEq(expectedBorrowExchangePrice, 1555682517262);
|
|
expectedRevenue += 0.072 ether + 335487; // tolerate some inaccuracy 1335487, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 8774399999998312507; // user total supply 20% fully expanded
|
|
_assertState(
|
|
15000, // expected borrow rate
|
|
14250, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
7669529234544016768, // expected supply raw interest. total supply 10967999999997890634
|
|
0 ether, // expected supply interest free
|
|
7096563648107724032, // expected borrow raw interest. total borrow 11039999999998226085
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit.
|
|
13247999999997871301 // expected borrow limit. user total borrow fully expanded
|
|
);
|
|
|
|
// 8. test yield at utilization > 100%
|
|
// utilization is at 11039999999998226085 / 10967999999997890634 = 100.656455142235132184% precision cut off 100.65%
|
|
|
|
// warp & assert everything
|
|
// borrow rate at max = 150%. + continuing the slope of rate -> 6.5% of slope 70% (150% -80%)
|
|
// -> 150% + 4,55% = 154,55%
|
|
// 11039999999998226085 ether paying 154,55% for 1 year yield. 5% of that is revenue.
|
|
// supply rate = 154,55 - 5% revenue fee -> 146,8225%. 100.656455142235132184% utilization so 147,78624289%
|
|
// Note: supply rate calculation in resolver uses utilization not from storage so result has higher precision)
|
|
// supply exchange price calculation however uses 100.65% utilization so there it is 147,77684625.
|
|
// 17.062319999997258414 ether in yield. 5% goes to revenue -> 0,853115999999862920 ether
|
|
vm.warp(block.timestamp + 365 days); // earn a 1 year yield
|
|
expectedSupplyExchangePrice = (expectedSupplyExchangePrice * 24777684625) / 10000000000; // increased by 147,77684625%
|
|
assertEq(expectedSupplyExchangePrice, 3543394081385);
|
|
expectedBorrowExchangePrice = (expectedBorrowExchangePrice * 25455) / 10000; // increased by 154,55%
|
|
assertEq(expectedBorrowExchangePrice, 3959989847690);
|
|
expectedRevenue += 0.853115999999862920 ether + 1039503299800972; // tolerate some inaccuracy 1039503299800972, from total amounts rounding
|
|
// expected withdrawal limit:
|
|
expectedWithdrawalLimit = 21740931597353998440; // user total supply 20% fully expanded
|
|
_assertState(
|
|
15455, // expected borrow rate
|
|
14778, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
7669529234544016640, // expected supply raw interest. no changes only rounded down. total supply 27176164496692498051
|
|
0 ether, // expected supply interest free
|
|
7096563648107724160, // expected borrow raw interest. no changes only rounded up. total borrow 28102319999992497353
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit.
|
|
33722783999990996823 // expected borrow limit. user total borrow fully expanded
|
|
);
|
|
|
|
// 9. test max limit
|
|
// Set borrow config with lower max limit
|
|
AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_ = new AdminModuleStructs.UserBorrowConfig[](1);
|
|
userBorrowConfigs_[0] = AdminModuleStructs.UserBorrowConfig({
|
|
user: address(mockProtocol),
|
|
token: address(USDC),
|
|
mode: 1,
|
|
expandPercent: DEFAULT_EXPAND_DEBT_CEILING_PERCENT, // 20%
|
|
expandDuration: DEFAULT_EXPAND_DEBT_CEILING_DURATION, // 2 days;
|
|
baseDebtCeiling: 2 ether, // raw, so at exchange price ~4, this is ~8 ether
|
|
maxDebtCeiling: 5 ether // raw, so at exchange price ~4, this is ~20 ether
|
|
});
|
|
vm.prank(admin);
|
|
FluidLiquidityAdminModule(address(liquidity)).updateUserBorrowConfigs(userBorrowConfigs_);
|
|
|
|
// assert borrowLimit
|
|
(ResolverStructs.UserBorrowData memory userBorrowData, ) = resolver.getUserBorrowData(
|
|
address(mockProtocol),
|
|
address(USDC)
|
|
);
|
|
assertEq(
|
|
userBorrowData.borrowLimit,
|
|
(baseLimitAfterBigMath * expectedBorrowExchangePrice) / 1e12,
|
|
"borrowLimit off"
|
|
);
|
|
assertEq(userBorrowData.borrowableUntilLimit, 0, "borrowableUntilLimit off");
|
|
assertEq(userBorrowData.borrowable, 0, "borrowable off");
|
|
|
|
// assert reverts if borrowing more
|
|
vm.expectRevert(
|
|
abi.encodeWithSelector(Error.FluidLiquidityError.selector, ErrorTypes.UserModule__BorrowLimitReached)
|
|
);
|
|
_borrow(mockProtocol, address(USDC), alice, userBorrowData.borrowable + 1);
|
|
|
|
// 10. payback down to 50% utilization
|
|
_payback(mockProtocol, address(USDC), alice, (userBorrowData.borrow - 13588082248346249025)); // to 27176164496692498051 / 2
|
|
|
|
// borrow rate = 4% + 5/8 of slope 6% (10% -4%) -> 7.75%.
|
|
// supply rate = 7.75% - 5% revenue fee -> 7.3625%. only 50% utilization -> 3.68125%.
|
|
expectedRevenue += 1538; // no changes but tolerate some inaccuracy 1538, from total amounts rounding
|
|
_assertState(
|
|
775, // expected borrow rate
|
|
368, // expected supply rate.
|
|
expectedSupplyExchangePrice, // expected supply exchange price.
|
|
expectedBorrowExchangePrice, // expected borrow exchange price.
|
|
expectedRevenue, // expected revenue.
|
|
7669529234544016512, // expected supply raw interest. no changes only rounded down. total supply 27176164496692497597
|
|
0 ether, // expected supply interest free
|
|
3431342698081069760, // expected borrow raw interest. total borrow 13588082248346249094
|
|
0 ether, // expected borrow interest free
|
|
expectedWithdrawalLimit, // expected withdrawal limit.
|
|
16305698698015498659 // expected borrow limit. user total borrow fully expanded. allow minor precision diff of 253
|
|
);
|
|
|
|
// later:
|
|
// todo: 11. test with supply Interest free being added
|
|
// todo: 12. test with borrow interest free being added
|
|
}
|
|
|
|
function _assertState(
|
|
uint256 borrowRate,
|
|
uint256 supplyRate,
|
|
uint256 supplyExchangePrice,
|
|
uint256 borrowExchangePrice,
|
|
uint256 revenue,
|
|
uint256 supplyRawInterest,
|
|
uint256 supplyInterestFree,
|
|
uint256 borrowRawInterest,
|
|
uint256 borrowInterestFree,
|
|
uint256 withdrawalLimit,
|
|
uint256 borrowLimit
|
|
) internal {
|
|
(
|
|
ResolverStructs.UserSupplyData memory userSupplyData,
|
|
ResolverStructs.OverallTokenData memory tokenData
|
|
) = resolver.getUserSupplyData(address(mockProtocol), address(USDC));
|
|
|
|
assertEq(tokenData.borrowRate, borrowRate, "borrowRate off");
|
|
assertEq(tokenData.supplyRate, supplyRate, "supplyRate off");
|
|
assertEq(tokenData.supplyExchangePrice, supplyExchangePrice, "supplyExchangePrice off");
|
|
assertEq(tokenData.borrowExchangePrice, borrowExchangePrice, "borrowExchangePrice off");
|
|
assertApproxEqAbs(tokenData.revenue, revenue, 1e3, "revenue off");
|
|
assertEq(tokenData.supplyRawInterest, supplyRawInterest, "supplyRawInterest off");
|
|
assertEq(tokenData.supplyInterestFree, supplyInterestFree, "supplyInterestFree off");
|
|
assertEq(tokenData.borrowRawInterest, borrowRawInterest, "borrowRawInterest off");
|
|
assertEq(tokenData.borrowInterestFree, borrowInterestFree, "borrowInterestFree off");
|
|
assertEq(
|
|
tokenData.totalSupply,
|
|
(supplyRawInterest * supplyExchangePrice) / 1e12 + supplyInterestFree,
|
|
"totalSupply off"
|
|
);
|
|
assertEq(
|
|
tokenData.totalBorrow,
|
|
(borrowRawInterest * borrowExchangePrice) / 1e12 + borrowInterestFree,
|
|
"totalBorrow off"
|
|
);
|
|
|
|
assertGe(tokenData.totalBorrow + USDC.balanceOf(address(liquidity)), tokenData.totalSupply + tokenData.revenue);
|
|
|
|
// create liquidity to test withdrawable
|
|
_supply(mockProtocolInterestFree, address(USDC), alice, 30 ether);
|
|
(userSupplyData, ) = resolver.getUserSupplyData(address(mockProtocol), address(USDC));
|
|
|
|
// assert withdrawalLimit
|
|
assertApproxEqAbs(userSupplyData.withdrawalLimit, withdrawalLimit, 1e3, "withdrawalLimit off");
|
|
assertApproxEqAbs(
|
|
userSupplyData.withdrawableUntilLimit,
|
|
userSupplyData.supply - withdrawalLimit,
|
|
1e3,
|
|
"withdrawableUntilLimit off"
|
|
);
|
|
assertApproxEqAbs(
|
|
userSupplyData.withdrawable,
|
|
userSupplyData.supply - withdrawalLimit,
|
|
1e3,
|
|
"withdrawable off"
|
|
);
|
|
|
|
if (userSupplyData.supply > 0 && userSupplyData.withdrawable < userSupplyData.supply) {
|
|
// assert reverts if withdrawing more
|
|
vm.expectRevert(
|
|
abi.encodeWithSelector(
|
|
Error.FluidLiquidityError.selector,
|
|
ErrorTypes.UserModule__WithdrawalLimitReached
|
|
)
|
|
);
|
|
_withdraw(mockProtocol, address(USDC), alice, userSupplyData.withdrawable + 1);
|
|
}
|
|
|
|
if (userSupplyData.withdrawable > 0) {
|
|
// assert withdrawing exactly works
|
|
_withdraw(mockProtocol, address(USDC), alice, userSupplyData.withdrawable - 1);
|
|
// supply it back
|
|
_supply(mockProtocol, address(USDC), alice, userSupplyData.withdrawable - 1);
|
|
}
|
|
|
|
// assert borrowLimit
|
|
(ResolverStructs.UserBorrowData memory userBorrowData, ) = resolver.getUserBorrowData(
|
|
address(mockProtocol),
|
|
address(USDC)
|
|
);
|
|
assertEq(userBorrowData.borrowLimit, borrowLimit, "borrowLimit off");
|
|
assertEq(userBorrowData.borrowableUntilLimit, borrowLimit - userBorrowData.borrow, "borrowableUntilLimit off");
|
|
assertEq(userBorrowData.borrowable, borrowLimit - userBorrowData.borrow, "borrowable off");
|
|
|
|
// assert reverts if borrowing more
|
|
vm.expectRevert(
|
|
abi.encodeWithSelector(Error.FluidLiquidityError.selector, ErrorTypes.UserModule__BorrowLimitReached)
|
|
);
|
|
_borrow(mockProtocol, address(USDC), alice, userBorrowData.borrowable + 1);
|
|
|
|
if (userBorrowData.borrowable > 1e3) {
|
|
{
|
|
uint256 borrowedBefore_ = userBorrowData.borrow;
|
|
// assert borrowing exactly works
|
|
_borrow(mockProtocol, address(USDC), alice, userBorrowData.borrowable - 1);
|
|
// payback
|
|
(userBorrowData, ) = resolver.getUserBorrowData(address(mockProtocol), address(USDC));
|
|
_payback(mockProtocol, address(USDC), alice, userBorrowData.borrow - borrowedBefore_);
|
|
}
|
|
}
|
|
|
|
_withdraw(mockProtocolInterestFree, address(USDC), alice, 30 ether);
|
|
|
|
uint256[] memory returnedSupplyExchangePrice;
|
|
uint256[] memory returnedBorrowExchangePrice;
|
|
{
|
|
address[] memory tokens = new address[](1);
|
|
tokens[0] = address(USDC);
|
|
vm.prank(admin);
|
|
(returnedSupplyExchangePrice, returnedBorrowExchangePrice) = FluidLiquidityAdminModule(address(liquidity))
|
|
.updateExchangePrices(tokens);
|
|
}
|
|
|
|
assertEq(returnedSupplyExchangePrice[0], supplyExchangePrice);
|
|
assertEq(returnedBorrowExchangePrice[0], borrowExchangePrice);
|
|
}
|
|
}
|
|
|
|
contract LiquidityUserModuleYieldCombinationRateV1Test is LiquidityUserModuleYieldCombinationBaseTest {
|
|
function setUp() public virtual override {
|
|
super.setUp();
|
|
|
|
// set rate data v1
|
|
_setDefaultRateDataV1(address(liquidity), admin, address(USDC));
|
|
}
|
|
}
|
|
|
|
contract LiquidityUserModuleYieldCombinationRateV2Test is LiquidityUserModuleYieldCombinationBaseTest {
|
|
function setUp() public virtual override {
|
|
super.setUp();
|
|
|
|
// set rate data v2
|
|
_setDefaultRateDataV2(address(liquidity), admin, address(USDC));
|
|
}
|
|
}
|