mirror of
https://github.com/Instadapp/dsa-governance.git
synced 2024-07-29 22:27:52 +00:00
fix
This commit is contained in:
parent
69a7086c14
commit
9973676c13
|
@ -477,14 +477,11 @@ contract PayloadIGP30 {
|
|||
/// Action 1: Set wBTC token config and market rate curve on liquidity.
|
||||
action1();
|
||||
|
||||
/// Action 2: Deploy wBTC/ETH and ETH/wBTC vaults.
|
||||
/// Action 2: Deploy wBTC/USDC and wBTC/USDT vaults.
|
||||
action2();
|
||||
|
||||
/// Action 3: Deploy wstETH/wBTC and weETH/wBTC vaults.
|
||||
/// Action 3: call cast() - transfer 2 wBTC to Fluid Reserve contract from treasury.
|
||||
action3();
|
||||
|
||||
/// Action 4: Clone from old vault config to new vault
|
||||
action4();
|
||||
}
|
||||
|
||||
function verifyProposal() external view {}
|
||||
|
@ -526,11 +523,11 @@ contract PayloadIGP30 {
|
|||
|
||||
}
|
||||
|
||||
/// @notice Action 2: Deploy wBTC/ETH and ETH/wBTC vaults.
|
||||
/// @notice Action 2: Deploy wBTC/USDC and wBTC/USDT vaults.
|
||||
function action2() internal {
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: address(0),
|
||||
supplyToken: wBTC_ADDRESS,
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
|
@ -545,121 +542,55 @@ contract PayloadIGP30 {
|
|||
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 90 * 1e2, // 90%
|
||||
liquidationThreshold: 0,
|
||||
liquidationMaxLimit: 0,
|
||||
collateralFactor: 80 * 1e2, // 80%
|
||||
liquidationThreshold: 85 * 1e2, // 85%
|
||||
liquidationMaxLimit: 90 * 1e2, // 90%
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 2 * 1e2, // 2%
|
||||
liquidationPenalty: 0,
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: address(0)
|
||||
});
|
||||
|
||||
// Deploy wBTC/ETH vault.
|
||||
{
|
||||
vaultConfig.supplyToken = wBTC_ADDRESS;
|
||||
vaultConfig.borrowToken = ETH_ADDRESS;
|
||||
vaultConfig.borrowToken = USDC_ADDRESS;
|
||||
|
||||
vaultConfig.liquidationThreshold = 91 * 1e2; // 91%
|
||||
vaultConfig.liquidationMaxLimit = 93 * 1e2; // 93%
|
||||
vaultConfig.liquidationPenalty = 3 * 1e2; // 3%
|
||||
|
||||
vaultConfig.oracle = address(0x4C57Ef1012bDFFCe68FDDcD793Bb2b8B7D27DC06);
|
||||
vaultConfig.oracle = 0x131BA983Ab640Ce291B98694b3Def4288596cD09;
|
||||
|
||||
deployVault(vaultConfig);
|
||||
// Deploy wBTC/USDC vault.
|
||||
address vault_ = deployVault(vaultConfig);
|
||||
|
||||
// Set USDC rewards contract
|
||||
VAULT_T1_FACTORY.setVaultAuth(
|
||||
vault_,
|
||||
0xF561347c306E3Ccf213b73Ce2353D6ed79f92408,
|
||||
true
|
||||
);
|
||||
}
|
||||
|
||||
// Deploy ETH/wBTC vault.
|
||||
{
|
||||
vaultConfig.supplyToken = ETH_ADDRESS;
|
||||
vaultConfig.borrowToken = wBTC_ADDRESS;
|
||||
vaultConfig.borrowToken = USDT_ADDRESS;
|
||||
|
||||
vaultConfig.liquidationThreshold = 93 * 1e2; // 93%
|
||||
vaultConfig.liquidationMaxLimit = 95 * 1e2; // 95%
|
||||
vaultConfig.liquidationPenalty = 4 * 1e2; // 4%
|
||||
|
||||
vaultConfig.oracle = address(0x63Ae926f97A480B18d58370268672766643f577F);
|
||||
vaultConfig.oracle = 0xFF272430E88B3f804d9E30886677A36021864Cc4;
|
||||
|
||||
deployVault(vaultConfig);
|
||||
// Deploy wBTC/USDT vault.
|
||||
address vault_ = deployVault(vaultConfig);
|
||||
|
||||
// Set USDT rewards contract
|
||||
VAULT_T1_FACTORY.setVaultAuth(
|
||||
vault_,
|
||||
0x36C677a6AbDa7D6409fB74d1136A65aF1415F539,
|
||||
true
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Action 3: Deploy wstETH/wBTC and weETH/wBTC vaults.
|
||||
/// @notice Action 3: call cast() - transfer 2 wBTC to Fluid Reserve contract from treasury.
|
||||
function action3() internal {
|
||||
// wstETH/wBTC
|
||||
{
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: wstETH_ADDRESS,
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
supplyBaseLimitInUSD: 5_000_000, // $5M
|
||||
|
||||
borrowToken: wBTC_ADDRESS,
|
||||
borrowMode: 1, // Mode 1
|
||||
borrowExpandPercent: 20 * 1e2, // 20%
|
||||
borrowExpandDuration: 12 hours, // 12 hours
|
||||
borrowBaseLimitInUSD: 7_500_000, // $7.5M
|
||||
borrowMaxLimitInUSD: 200_000_000, // $200M
|
||||
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 88 * 1e2, // 88%
|
||||
liquidationThreshold: 91 * 1e2, // 91%
|
||||
liquidationMaxLimit: 94 * 1e2, // 94%
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 2 * 1e2, // 2%
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: 0xD25c68bb507f8E19386F4F102462e1bfbfA7869F
|
||||
});
|
||||
|
||||
// Deploy wstETH/wBTC
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
|
||||
// weETH/wBTC
|
||||
{
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: weETH_ADDRESS,
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
supplyBaseLimitInUSD: 5_000_000, // $5M
|
||||
|
||||
borrowToken: wBTC_ADDRESS,
|
||||
borrowMode: 1, // Mode 1
|
||||
borrowExpandPercent: 20 * 1e2, // 20%
|
||||
borrowExpandDuration: 12 hours, // 12 hours
|
||||
borrowBaseLimitInUSD: 7_500_000, // $7.5M
|
||||
borrowMaxLimitInUSD: 20_000_000, // $20M
|
||||
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 80 * 1e2, // 80%
|
||||
liquidationThreshold: 85 * 1e2, // 85%
|
||||
liquidationMaxLimit: 90 * 1e2, // 90%
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 5 * 1e2, // 5%
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: 0xBD7ea28840B120E2a2645F103273B0Dc23599E05
|
||||
});
|
||||
|
||||
// Deploy weETH/wBTC
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Action 4: Clone from old vault config to new vault
|
||||
function action4() internal {
|
||||
for (uint oldVaultId = 1; oldVaultId <= 10; oldVaultId++) {
|
||||
configNewVaultWithOldVaultConfigs(oldVaultId);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Action 5: call cast() - transfer 2 wBTC to Fluid Reserve contract from treasury.
|
||||
function action5() internal {
|
||||
string[] memory targets = new string[](1);
|
||||
bytes[] memory encodedSpells = new bytes[](1);
|
||||
|
||||
|
@ -790,140 +721,6 @@ contract PayloadIGP30 {
|
|||
}
|
||||
}
|
||||
|
||||
function getUserSupplyData(
|
||||
address token_,
|
||||
address oldVault_,
|
||||
address newVault_
|
||||
)
|
||||
internal
|
||||
view
|
||||
returns (AdminModuleStructs.UserSupplyConfig memory config_)
|
||||
{
|
||||
uint256 userSupplyData_ = LIQUIDITY.readFromStorage(
|
||||
LiquiditySlotsLink.calculateDoubleMappingStorageSlot(
|
||||
LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT,
|
||||
oldVault_,
|
||||
token_
|
||||
)
|
||||
);
|
||||
config_ = AdminModuleStructs.UserSupplyConfig({
|
||||
user: newVault_,
|
||||
token: token_,
|
||||
mode: uint8(userSupplyData_ & 1),
|
||||
expandPercent: (userSupplyData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14,
|
||||
expandDuration: (userSupplyData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_DURATION) & X24,
|
||||
baseWithdrawalLimit:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
)
|
||||
});
|
||||
}
|
||||
|
||||
function getUserBorrowData(
|
||||
address token_,
|
||||
address oldVault_,
|
||||
address newVault_
|
||||
)
|
||||
internal
|
||||
view
|
||||
returns (AdminModuleStructs.UserBorrowConfig memory config_)
|
||||
{
|
||||
uint256 userBorrowData_ = LIQUIDITY.readFromStorage(
|
||||
LiquiditySlotsLink.calculateDoubleMappingStorageSlot(
|
||||
LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT,
|
||||
oldVault_,
|
||||
token_
|
||||
)
|
||||
);
|
||||
|
||||
config_ = AdminModuleStructs.UserBorrowConfig({
|
||||
user: newVault_,
|
||||
token: token_,
|
||||
mode: uint8(userBorrowData_ & 1),
|
||||
expandPercent: (userBorrowData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14,
|
||||
expandDuration: (userBorrowData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_DURATION) & X24,
|
||||
baseDebtCeiling:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
),
|
||||
maxDebtCeiling:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
)
|
||||
});
|
||||
}
|
||||
|
||||
struct CloneVaultStruct {
|
||||
address oldVaultAddress;
|
||||
address newVaultAddress;
|
||||
}
|
||||
|
||||
function configNewVaultWithOldVaultConfigs(uint256 oldVaultId) internal {
|
||||
CloneVaultStruct memory data;
|
||||
|
||||
data.oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId);
|
||||
data.newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(
|
||||
oldVaultId + 10
|
||||
);
|
||||
|
||||
IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(
|
||||
data.oldVaultAddress
|
||||
).constantsView();
|
||||
|
||||
IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(
|
||||
data.newVaultAddress
|
||||
).constantsView();
|
||||
|
||||
{
|
||||
require(
|
||||
oldConstants.supplyToken == newConstants.supplyToken,
|
||||
"not-same-supply-token"
|
||||
);
|
||||
require(
|
||||
oldConstants.borrowToken == newConstants.borrowToken,
|
||||
"not-same-borrow-token"
|
||||
);
|
||||
}
|
||||
|
||||
// Set user supply config for the vault on Liquidity Layer.
|
||||
{
|
||||
AdminModuleStructs.UserSupplyConfig[]
|
||||
memory configs_ = new AdminModuleStructs.UserSupplyConfig[](1);
|
||||
|
||||
configs_[0] = getUserSupplyData(
|
||||
newConstants.supplyToken,
|
||||
data.oldVaultAddress,
|
||||
data.newVaultAddress
|
||||
);
|
||||
|
||||
LIQUIDITY.updateUserSupplyConfigs(configs_);
|
||||
}
|
||||
|
||||
// Set user borrow config for the vault on Liquidity Layer.
|
||||
{
|
||||
AdminModuleStructs.UserBorrowConfig[]
|
||||
memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1);
|
||||
|
||||
configs_[0] = getUserBorrowData(
|
||||
newConstants.borrowToken,
|
||||
data.oldVaultAddress,
|
||||
data.newVaultAddress
|
||||
);
|
||||
|
||||
LIQUIDITY.updateUserBorrowConfigs(configs_);
|
||||
}
|
||||
}
|
||||
|
||||
function getRawAmount(address token, uint256 amountInUSD, bool isSupply) public view returns(uint256){
|
||||
uint256 exchangePriceAndConfig_ =
|
||||
LIQUIDITY.readFromStorage(
|
||||
|
|
|
@ -329,50 +329,10 @@ interface IFluidVaultT1Factory {
|
|||
) external view returns (uint256 result_);
|
||||
}
|
||||
|
||||
interface IDSAV2 {
|
||||
function cast(
|
||||
string[] memory _targetNames,
|
||||
bytes[] memory _datas,
|
||||
address _origin
|
||||
)
|
||||
external
|
||||
payable
|
||||
returns (bytes32);
|
||||
|
||||
function isAuth(address user) external view returns (bool);
|
||||
}
|
||||
|
||||
interface IFluidVaultT1DeploymentLogic {
|
||||
function vaultT1(address supplyToken_, address borrowToken_) external;
|
||||
}
|
||||
|
||||
interface IFluidReserveContract {
|
||||
function isRebalancer(address user) external returns (bool);
|
||||
|
||||
function rebalanceFToken(address protocol_) external;
|
||||
|
||||
function rebalanceVault(address protocol_) external;
|
||||
|
||||
function transferFunds(address token_) external;
|
||||
|
||||
function getProtocolTokens(address protocol_) external;
|
||||
|
||||
function updateAuth(address auth_, bool isAuth_) external;
|
||||
|
||||
function updateRebalancer(address rebalancer_, bool isRebalancer_) external;
|
||||
|
||||
function approve(
|
||||
address[] memory protocols_,
|
||||
address[] memory tokens_,
|
||||
uint256[] memory amounts_
|
||||
) external;
|
||||
|
||||
function revoke(
|
||||
address[] memory protocols_,
|
||||
address[] memory tokens_
|
||||
) external;
|
||||
}
|
||||
|
||||
contract PayloadIGP31 {
|
||||
uint256 public constant PROPOSAL_ID = 31;
|
||||
|
||||
|
@ -385,8 +345,6 @@ contract PayloadIGP31 {
|
|||
address public constant PROPOSER_AVO_MULTISIG_2 =
|
||||
0x9efdE135CA4832AbF0408c44c6f5f370eB0f35e8;
|
||||
|
||||
IDSAV2 public constant TREASURY = IDSAV2(0x28849D2b63fA8D361e5fc15cB8aBB13019884d09);
|
||||
|
||||
IGovernorBravo public constant GOVERNOR =
|
||||
IGovernorBravo(0x0204Cd037B2ec03605CFdFe482D8e257C765fA1B);
|
||||
ITimelock public immutable TIMELOCK =
|
||||
|
@ -399,8 +357,6 @@ contract PayloadIGP31 {
|
|||
|
||||
IFluidLiquidityAdmin public constant LIQUIDITY =
|
||||
IFluidLiquidityAdmin(0x52Aa899454998Be5b000Ad077a46Bbe360F4e497);
|
||||
IFluidReserveContract public constant FLUID_RESERVE =
|
||||
IFluidReserveContract(0x264786EF916af64a1DB19F513F24a3681734ce92);
|
||||
IFluidVaultT1Factory public constant VAULT_T1_FACTORY =
|
||||
IFluidVaultT1Factory(0x324c5Dc1fC42c7a4D43d92df1eBA58a54d13Bf2d);
|
||||
IFluidVaultT1DeploymentLogic public constant VAULT_T1_DEPLOYMENT_LOGIC =
|
||||
|
@ -408,6 +364,13 @@ contract PayloadIGP31 {
|
|||
0x2Cc710218F2e3a82CcC77Cc4B3B93Ee6Ba9451CD
|
||||
);
|
||||
|
||||
address public constant ETH_ADDRESS =
|
||||
0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
|
||||
address public constant wstETH_ADDRESS =
|
||||
0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
|
||||
address public constant weETH_ADDRESS =
|
||||
0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee;
|
||||
|
||||
address public constant wBTC_ADDRESS =
|
||||
0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
|
||||
|
||||
|
@ -416,6 +379,18 @@ contract PayloadIGP31 {
|
|||
address public constant USDT_ADDRESS =
|
||||
0xdAC17F958D2ee523a2206206994597C13D831ec7;
|
||||
|
||||
uint256 internal constant X8 = 0xff;
|
||||
uint256 internal constant X10 = 0x3ff;
|
||||
uint256 internal constant X14 = 0x3fff;
|
||||
uint256 internal constant X15 = 0x7fff;
|
||||
uint256 internal constant X16 = 0xffff;
|
||||
uint256 internal constant X18 = 0x3ffff;
|
||||
uint256 internal constant X24 = 0xffffff;
|
||||
uint256 internal constant X64 = 0xffffffffffffffff;
|
||||
|
||||
uint256 internal constant DEFAULT_EXPONENT_SIZE = 8;
|
||||
uint256 internal constant DEFAULT_EXPONENT_MASK = 0xff;
|
||||
|
||||
constructor() {
|
||||
ADDRESS_THIS = address(this);
|
||||
}
|
||||
|
@ -455,11 +430,14 @@ contract PayloadIGP31 {
|
|||
function execute() external {
|
||||
require(address(this) == address(TIMELOCK), "not-valid-caller");
|
||||
|
||||
/// Action 1: Deploy wBTC/USDC and wBTC/USDT vaults.
|
||||
/// Action 1: Deploy wBTC/ETH and ETH/wBTC vaults.
|
||||
action1();
|
||||
|
||||
/// Action 2: call cast() - transfer 2 wBTC to Fluid Reserve contract from treasury.
|
||||
/// Action 2: Deploy wstETH/wBTC and weETH/wBTC vaults.
|
||||
action2();
|
||||
|
||||
/// Action 3: Clone from old vault config to new vault
|
||||
action3();
|
||||
}
|
||||
|
||||
function verifyProposal() external view {}
|
||||
|
@ -468,11 +446,11 @@ contract PayloadIGP31 {
|
|||
| Proposal Payload Actions |
|
||||
|__________________________________*/
|
||||
|
||||
/// @notice Action 1: Deploy wBTC/USDC and wBTC/USDT vaults.
|
||||
/// @notice Action 1: Deploy wBTC/ETH and ETH/wBTC vaults.
|
||||
function action1() internal {
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: wBTC_ADDRESS,
|
||||
supplyToken: address(0),
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
|
@ -487,68 +465,117 @@ contract PayloadIGP31 {
|
|||
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 80 * 1e2, // 80%
|
||||
liquidationThreshold: 85 * 1e2, // 85%
|
||||
liquidationMaxLimit: 90 * 1e2, // 90%
|
||||
collateralFactor: 90 * 1e2, // 90%
|
||||
liquidationThreshold: 0,
|
||||
liquidationMaxLimit: 0,
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 0,
|
||||
liquidationPenalty: 2 * 1e2, // 2%
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: address(0)
|
||||
});
|
||||
|
||||
// Deploy wBTC/ETH vault.
|
||||
{
|
||||
vaultConfig.borrowToken = USDC_ADDRESS;
|
||||
vaultConfig.supplyToken = wBTC_ADDRESS;
|
||||
vaultConfig.borrowToken = ETH_ADDRESS;
|
||||
|
||||
vaultConfig.liquidationPenalty = 3 * 1e2; // 3%
|
||||
vaultConfig.liquidationThreshold = 91 * 1e2; // 91%
|
||||
vaultConfig.liquidationMaxLimit = 93 * 1e2; // 93%
|
||||
|
||||
vaultConfig.oracle = 0x131BA983Ab640Ce291B98694b3Def4288596cD09;
|
||||
vaultConfig.oracle = address(0x4C57Ef1012bDFFCe68FDDcD793Bb2b8B7D27DC06);
|
||||
|
||||
// Deploy wBTC/USDC vault.
|
||||
address vault_ = deployVault(vaultConfig);
|
||||
|
||||
// Set USDC rewards contract
|
||||
VAULT_T1_FACTORY.setVaultAuth(
|
||||
vault_,
|
||||
0xF561347c306E3Ccf213b73Ce2353D6ed79f92408,
|
||||
true
|
||||
);
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
|
||||
// Deploy ETH/wBTC vault.
|
||||
{
|
||||
vaultConfig.borrowToken = USDT_ADDRESS;
|
||||
vaultConfig.supplyToken = ETH_ADDRESS;
|
||||
vaultConfig.borrowToken = wBTC_ADDRESS;
|
||||
|
||||
vaultConfig.liquidationPenalty = 4 * 1e2; // 4%
|
||||
vaultConfig.liquidationThreshold = 93 * 1e2; // 93%
|
||||
vaultConfig.liquidationMaxLimit = 95 * 1e2; // 95%
|
||||
|
||||
vaultConfig.oracle = 0xFF272430E88B3f804d9E30886677A36021864Cc4;
|
||||
vaultConfig.oracle = address(0x63Ae926f97A480B18d58370268672766643f577F);
|
||||
|
||||
// Deploy wBTC/USDT vault.
|
||||
address vault_ = deployVault(vaultConfig);
|
||||
|
||||
// Set USDT rewards contract
|
||||
VAULT_T1_FACTORY.setVaultAuth(
|
||||
vault_,
|
||||
0x36C677a6AbDa7D6409fB74d1136A65aF1415F539,
|
||||
true
|
||||
);
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Action 2: call cast() - transfer 2 wBTC to Fluid Reserve contract from treasury.
|
||||
/// @notice Action 2: Deploy wstETH/wBTC and weETH/wBTC vaults.
|
||||
function action2() internal {
|
||||
string[] memory targets = new string[](1);
|
||||
bytes[] memory encodedSpells = new bytes[](1);
|
||||
// wstETH/wBTC
|
||||
{
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: wstETH_ADDRESS,
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
supplyBaseLimitInUSD: 5_000_000, // $5M
|
||||
|
||||
string memory withdrawSignature = "withdraw(address,uint256,address,uint256,uint256)";
|
||||
borrowToken: wBTC_ADDRESS,
|
||||
borrowMode: 1, // Mode 1
|
||||
borrowExpandPercent: 20 * 1e2, // 20%
|
||||
borrowExpandDuration: 12 hours, // 12 hours
|
||||
borrowBaseLimitInUSD: 7_500_000, // $7.5M
|
||||
borrowMaxLimitInUSD: 200_000_000, // $200M
|
||||
|
||||
// Spell 1: Transfer wBTC
|
||||
{
|
||||
uint256 wBTC_AMOUNT = 2 * 1e8; // 2 wBTC
|
||||
targets[0] = "BASIC-A";
|
||||
encodedSpells[0] = abi.encodeWithSignature(withdrawSignature, wBTC_ADDRESS, wBTC_AMOUNT, FLUID_RESERVE, 0, 0);
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 88 * 1e2, // 88%
|
||||
liquidationThreshold: 91 * 1e2, // 91%
|
||||
liquidationMaxLimit: 94 * 1e2, // 94%
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 2 * 1e2, // 2%
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: 0xD25c68bb507f8E19386F4F102462e1bfbfA7869F
|
||||
});
|
||||
|
||||
// Deploy wstETH/wBTC
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
|
||||
IDSAV2(TREASURY).cast(targets, encodedSpells, address(this));
|
||||
// weETH/wBTC
|
||||
{
|
||||
VaultConfig memory vaultConfig = VaultConfig({
|
||||
// user supply config for the vault on Liquidity Layer.
|
||||
supplyToken: weETH_ADDRESS,
|
||||
supplyMode: 1, // Mode 1
|
||||
supplyExpandPercent: 25 * 1e2, // 25%
|
||||
supplyExpandDuration: 12 hours, // 12 hours
|
||||
supplyBaseLimitInUSD: 5_000_000, // $5M
|
||||
|
||||
borrowToken: wBTC_ADDRESS,
|
||||
borrowMode: 1, // Mode 1
|
||||
borrowExpandPercent: 20 * 1e2, // 20%
|
||||
borrowExpandDuration: 12 hours, // 12 hours
|
||||
borrowBaseLimitInUSD: 7_500_000, // $7.5M
|
||||
borrowMaxLimitInUSD: 20_000_000, // $20M
|
||||
|
||||
supplyRateMagnifier: 100 * 1e2, // 1x
|
||||
borrowRateMagnifier: 100 * 1e2, // 1x
|
||||
collateralFactor: 80 * 1e2, // 80%
|
||||
liquidationThreshold: 85 * 1e2, // 85%
|
||||
liquidationMaxLimit: 90 * 1e2, // 90%
|
||||
withdrawGap: 5 * 1e2, // 5%
|
||||
liquidationPenalty: 5 * 1e2, // 5%
|
||||
borrowFee: 0 * 1e2, // 0%
|
||||
|
||||
oracle: 0xBD7ea28840B120E2a2645F103273B0Dc23599E05
|
||||
});
|
||||
|
||||
// Deploy weETH/wBTC
|
||||
deployVault(vaultConfig);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Action 3: Clone from old vault config to new vault
|
||||
function action3() internal {
|
||||
for (uint oldVaultId = 1; oldVaultId <= 10; oldVaultId++) {
|
||||
configNewVaultWithOldVaultConfigs(oldVaultId);
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************|
|
||||
|
@ -666,6 +693,140 @@ contract PayloadIGP31 {
|
|||
}
|
||||
}
|
||||
|
||||
function getUserSupplyData(
|
||||
address token_,
|
||||
address oldVault_,
|
||||
address newVault_
|
||||
)
|
||||
internal
|
||||
view
|
||||
returns (AdminModuleStructs.UserSupplyConfig memory config_)
|
||||
{
|
||||
uint256 userSupplyData_ = LIQUIDITY.readFromStorage(
|
||||
LiquiditySlotsLink.calculateDoubleMappingStorageSlot(
|
||||
LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT,
|
||||
oldVault_,
|
||||
token_
|
||||
)
|
||||
);
|
||||
config_ = AdminModuleStructs.UserSupplyConfig({
|
||||
user: newVault_,
|
||||
token: token_,
|
||||
mode: uint8(userSupplyData_ & 1),
|
||||
expandPercent: (userSupplyData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14,
|
||||
expandDuration: (userSupplyData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_DURATION) & X24,
|
||||
baseWithdrawalLimit:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
)
|
||||
});
|
||||
}
|
||||
|
||||
function getUserBorrowData(
|
||||
address token_,
|
||||
address oldVault_,
|
||||
address newVault_
|
||||
)
|
||||
internal
|
||||
view
|
||||
returns (AdminModuleStructs.UserBorrowConfig memory config_)
|
||||
{
|
||||
uint256 userBorrowData_ = LIQUIDITY.readFromStorage(
|
||||
LiquiditySlotsLink.calculateDoubleMappingStorageSlot(
|
||||
LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT,
|
||||
oldVault_,
|
||||
token_
|
||||
)
|
||||
);
|
||||
|
||||
config_ = AdminModuleStructs.UserBorrowConfig({
|
||||
user: newVault_,
|
||||
token: token_,
|
||||
mode: uint8(userBorrowData_ & 1),
|
||||
expandPercent: (userBorrowData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14,
|
||||
expandDuration: (userBorrowData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_DURATION) & X24,
|
||||
baseDebtCeiling:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
),
|
||||
maxDebtCeiling:
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
)
|
||||
});
|
||||
}
|
||||
|
||||
struct CloneVaultStruct {
|
||||
address oldVaultAddress;
|
||||
address newVaultAddress;
|
||||
}
|
||||
|
||||
function configNewVaultWithOldVaultConfigs(uint256 oldVaultId) internal {
|
||||
CloneVaultStruct memory data;
|
||||
|
||||
data.oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId);
|
||||
data.newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(
|
||||
oldVaultId + 10
|
||||
);
|
||||
|
||||
IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(
|
||||
data.oldVaultAddress
|
||||
).constantsView();
|
||||
|
||||
IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(
|
||||
data.newVaultAddress
|
||||
).constantsView();
|
||||
|
||||
{
|
||||
require(
|
||||
oldConstants.supplyToken == newConstants.supplyToken,
|
||||
"not-same-supply-token"
|
||||
);
|
||||
require(
|
||||
oldConstants.borrowToken == newConstants.borrowToken,
|
||||
"not-same-borrow-token"
|
||||
);
|
||||
}
|
||||
|
||||
// Set user supply config for the vault on Liquidity Layer.
|
||||
{
|
||||
AdminModuleStructs.UserSupplyConfig[]
|
||||
memory configs_ = new AdminModuleStructs.UserSupplyConfig[](1);
|
||||
|
||||
configs_[0] = getUserSupplyData(
|
||||
newConstants.supplyToken,
|
||||
data.oldVaultAddress,
|
||||
data.newVaultAddress
|
||||
);
|
||||
|
||||
LIQUIDITY.updateUserSupplyConfigs(configs_);
|
||||
}
|
||||
|
||||
// Set user borrow config for the vault on Liquidity Layer.
|
||||
{
|
||||
AdminModuleStructs.UserBorrowConfig[]
|
||||
memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1);
|
||||
|
||||
configs_[0] = getUserBorrowData(
|
||||
newConstants.borrowToken,
|
||||
data.oldVaultAddress,
|
||||
data.newVaultAddress
|
||||
);
|
||||
|
||||
LIQUIDITY.updateUserBorrowConfigs(configs_);
|
||||
}
|
||||
}
|
||||
|
||||
function getRawAmount(address token, uint256 amountInUSD, bool isSupply) public view returns(uint256){
|
||||
uint256 exchangePriceAndConfig_ =
|
||||
LIQUIDITY.readFromStorage(
|
||||
|
|
156
contracts/payloads/IGP31/libraries/bigMathMinified.sol
Normal file
156
contracts/payloads/IGP31/libraries/bigMathMinified.sol
Normal file
|
@ -0,0 +1,156 @@
|
|||
// SPDX-License-Identifier: BUSL-1.1
|
||||
pragma solidity 0.8.21;
|
||||
|
||||
/// @title library that represents a number in BigNumber(coefficient and exponent) format to store in smaller bits.
|
||||
/// @notice the number is divided into two parts: a coefficient and an exponent. This comes at a cost of losing some precision
|
||||
/// at the end of the number because the exponent simply fills it with zeroes. This precision is oftentimes negligible and can
|
||||
/// result in significant gas cost reduction due to storage space reduction.
|
||||
/// Also note, a valid big number is as follows: if the exponent is > 0, then coefficient last bits should be occupied to have max precision.
|
||||
/// @dev roundUp is more like a increase 1, which happens everytime for the same number.
|
||||
/// roundDown simply sets trailing digits after coefficientSize to zero (floor), only once for the same number.
|
||||
library BigMathMinified {
|
||||
/// @dev constants to use for `roundUp` input param to increase readability
|
||||
bool internal constant ROUND_DOWN = false;
|
||||
bool internal constant ROUND_UP = true;
|
||||
|
||||
/// @dev converts `normal` number to BigNumber with `exponent` and `coefficient` (or precision).
|
||||
/// e.g.:
|
||||
/// 5035703444687813576399599 (normal) = (coefficient[32bits], exponent[8bits])[40bits]
|
||||
/// 5035703444687813576399599 (decimal) => 10000101010010110100000011111011110010100110100000000011100101001101001101011101111 (binary)
|
||||
/// => 10000101010010110100000011111011000000000000000000000000000000000000000000000000000
|
||||
/// ^-------------------- 51(exponent) -------------- ^
|
||||
/// coefficient = 1000,0101,0100,1011,0100,0000,1111,1011 (2236301563)
|
||||
/// exponent = 0011,0011 (51)
|
||||
/// bigNumber = 1000,0101,0100,1011,0100,0000,1111,1011,0011,0011 (572493200179)
|
||||
///
|
||||
/// @param normal number which needs to be converted into Big Number
|
||||
/// @param coefficientSize at max how many bits of precision there should be (64 = uint64 (64 bits precision))
|
||||
/// @param exponentSize at max how many bits of exponent there should be (8 = uint8 (8 bits exponent))
|
||||
/// @param roundUp signals if result should be rounded down or up
|
||||
/// @return bigNumber converted bigNumber (coefficient << exponent)
|
||||
function toBigNumber(
|
||||
uint256 normal,
|
||||
uint256 coefficientSize,
|
||||
uint256 exponentSize,
|
||||
bool roundUp
|
||||
) internal pure returns (uint256 bigNumber) {
|
||||
assembly {
|
||||
let lastBit_
|
||||
let number_ := normal
|
||||
if gt(number_, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
|
||||
number_ := shr(0x80, number_)
|
||||
lastBit_ := 0x80
|
||||
}
|
||||
if gt(number_, 0xFFFFFFFFFFFFFFFF) {
|
||||
number_ := shr(0x40, number_)
|
||||
lastBit_ := add(lastBit_, 0x40)
|
||||
}
|
||||
if gt(number_, 0xFFFFFFFF) {
|
||||
number_ := shr(0x20, number_)
|
||||
lastBit_ := add(lastBit_, 0x20)
|
||||
}
|
||||
if gt(number_, 0xFFFF) {
|
||||
number_ := shr(0x10, number_)
|
||||
lastBit_ := add(lastBit_, 0x10)
|
||||
}
|
||||
if gt(number_, 0xFF) {
|
||||
number_ := shr(0x8, number_)
|
||||
lastBit_ := add(lastBit_, 0x8)
|
||||
}
|
||||
if gt(number_, 0xF) {
|
||||
number_ := shr(0x4, number_)
|
||||
lastBit_ := add(lastBit_, 0x4)
|
||||
}
|
||||
if gt(number_, 0x3) {
|
||||
number_ := shr(0x2, number_)
|
||||
lastBit_ := add(lastBit_, 0x2)
|
||||
}
|
||||
if gt(number_, 0x1) {
|
||||
lastBit_ := add(lastBit_, 1)
|
||||
}
|
||||
if gt(number_, 0) {
|
||||
lastBit_ := add(lastBit_, 1)
|
||||
}
|
||||
if lt(lastBit_, coefficientSize) {
|
||||
// for throw exception
|
||||
lastBit_ := coefficientSize
|
||||
}
|
||||
let exponent := sub(lastBit_, coefficientSize)
|
||||
let coefficient := shr(exponent, normal)
|
||||
if and(roundUp, gt(exponent, 0)) {
|
||||
// rounding up is only needed if exponent is > 0, as otherwise the coefficient fully holds the original number
|
||||
coefficient := add(coefficient, 1)
|
||||
if eq(shl(coefficientSize, 1), coefficient) {
|
||||
// case were coefficient was e.g. 111, with adding 1 it became 1000 (in binary) and coefficientSize 3 bits
|
||||
// final coefficient would exceed it's size. -> reduce coefficent to 100 and increase exponent by 1.
|
||||
coefficient := shl(sub(coefficientSize, 1), 1)
|
||||
exponent := add(exponent, 1)
|
||||
}
|
||||
}
|
||||
if iszero(lt(exponent, shl(exponentSize, 1))) {
|
||||
// if exponent is >= exponentSize, the normal number is too big to fit within
|
||||
// BigNumber with too small sizes for coefficient and exponent
|
||||
revert(0, 0)
|
||||
}
|
||||
bigNumber := shl(exponentSize, coefficient)
|
||||
bigNumber := add(bigNumber, exponent)
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev get `normal` number from `bigNumber`, `exponentSize` and `exponentMask`
|
||||
function fromBigNumber(
|
||||
uint256 bigNumber,
|
||||
uint256 exponentSize,
|
||||
uint256 exponentMask
|
||||
) internal pure returns (uint256 normal) {
|
||||
assembly {
|
||||
let coefficient := shr(exponentSize, bigNumber)
|
||||
let exponent := and(bigNumber, exponentMask)
|
||||
normal := shl(exponent, coefficient)
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev gets the most significant bit `lastBit` of a `normal` number (length of given number of binary format).
|
||||
/// e.g.
|
||||
/// 5035703444687813576399599 = 10000101010010110100000011111011110010100110100000000011100101001101001101011101111
|
||||
/// lastBit = ^--------------------------------- 83 ----------------------------------------^
|
||||
function mostSignificantBit(uint256 normal) internal pure returns (uint lastBit) {
|
||||
assembly {
|
||||
let number_ := normal
|
||||
if gt(normal, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
|
||||
number_ := shr(0x80, number_)
|
||||
lastBit := 0x80
|
||||
}
|
||||
if gt(number_, 0xFFFFFFFFFFFFFFFF) {
|
||||
number_ := shr(0x40, number_)
|
||||
lastBit := add(lastBit, 0x40)
|
||||
}
|
||||
if gt(number_, 0xFFFFFFFF) {
|
||||
number_ := shr(0x20, number_)
|
||||
lastBit := add(lastBit, 0x20)
|
||||
}
|
||||
if gt(number_, 0xFFFF) {
|
||||
number_ := shr(0x10, number_)
|
||||
lastBit := add(lastBit, 0x10)
|
||||
}
|
||||
if gt(number_, 0xFF) {
|
||||
number_ := shr(0x8, number_)
|
||||
lastBit := add(lastBit, 0x8)
|
||||
}
|
||||
if gt(number_, 0xF) {
|
||||
number_ := shr(0x4, number_)
|
||||
lastBit := add(lastBit, 0x4)
|
||||
}
|
||||
if gt(number_, 0x3) {
|
||||
number_ := shr(0x2, number_)
|
||||
lastBit := add(lastBit, 0x2)
|
||||
}
|
||||
if gt(number_, 0x1) {
|
||||
lastBit := add(lastBit, 1)
|
||||
}
|
||||
if gt(number_, 0) {
|
||||
lastBit := add(lastBit, 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
27
contracts/payloads/IGP31/libraries/errorTypes.sol
Normal file
27
contracts/payloads/IGP31/libraries/errorTypes.sol
Normal file
|
@ -0,0 +1,27 @@
|
|||
// SPDX-License-Identifier: BUSL-1.1
|
||||
pragma solidity 0.8.21;
|
||||
|
||||
library LibsErrorTypes {
|
||||
/***********************************|
|
||||
| LiquidityCalcs |
|
||||
|__________________________________*/
|
||||
|
||||
/// @notice thrown when supply or borrow exchange price is zero at calc token data (token not configured yet)
|
||||
uint256 internal constant LiquidityCalcs__ExchangePriceZero = 70001;
|
||||
|
||||
/// @notice thrown when rate data is set to a version that is not implemented
|
||||
uint256 internal constant LiquidityCalcs__UnsupportedRateVersion = 70002;
|
||||
|
||||
/// @notice thrown when the calculated borrow rate turns negative. This should never happen.
|
||||
uint256 internal constant LiquidityCalcs__BorrowRateNegative = 70003;
|
||||
|
||||
/***********************************|
|
||||
| SafeTransfer |
|
||||
|__________________________________*/
|
||||
|
||||
/// @notice thrown when safe transfer from for an ERC20 fails
|
||||
uint256 internal constant SafeTransfer__TransferFromFailed = 71001;
|
||||
|
||||
/// @notice thrown when safe transfer for an ERC20 fails
|
||||
uint256 internal constant SafeTransfer__TransferFailed = 71002;
|
||||
}
|
686
contracts/payloads/IGP31/libraries/liquidityCalcs.sol
Normal file
686
contracts/payloads/IGP31/libraries/liquidityCalcs.sol
Normal file
|
@ -0,0 +1,686 @@
|
|||
// SPDX-License-Identifier: BUSL-1.1
|
||||
pragma solidity 0.8.21;
|
||||
|
||||
import { LibsErrorTypes as ErrorTypes } from "./errorTypes.sol";
|
||||
import { LiquiditySlotsLink } from "./liquiditySlotsLink.sol";
|
||||
import { BigMathMinified } from "./bigMathMinified.sol";
|
||||
|
||||
/// @notice implements calculation methods used for Fluid liquidity such as updated exchange prices,
|
||||
/// borrow rate, withdrawal / borrow limits, revenue amount.
|
||||
library LiquidityCalcs {
|
||||
error FluidLiquidityCalcsError(uint256 errorId_);
|
||||
|
||||
/// @notice emitted if the calculated borrow rate surpassed max borrow rate (16 bits) and was capped at maximum value 65535
|
||||
event BorrowRateMaxCap();
|
||||
|
||||
/// @dev constants as from Liquidity variables.sol
|
||||
uint256 internal constant EXCHANGE_PRICES_PRECISION = 1e12;
|
||||
|
||||
/// @dev Ignoring leap years
|
||||
uint256 internal constant SECONDS_PER_YEAR = 365 days;
|
||||
// constants used for BigMath conversion from and to storage
|
||||
uint256 internal constant DEFAULT_EXPONENT_SIZE = 8;
|
||||
uint256 internal constant DEFAULT_EXPONENT_MASK = 0xFF;
|
||||
|
||||
uint256 internal constant FOUR_DECIMALS = 1e4;
|
||||
uint256 internal constant TWELVE_DECIMALS = 1e12;
|
||||
uint256 internal constant X14 = 0x3fff;
|
||||
uint256 internal constant X15 = 0x7fff;
|
||||
uint256 internal constant X16 = 0xffff;
|
||||
uint256 internal constant X18 = 0x3ffff;
|
||||
uint256 internal constant X24 = 0xffffff;
|
||||
uint256 internal constant X33 = 0x1ffffffff;
|
||||
uint256 internal constant X64 = 0xffffffffffffffff;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
////////// CALC EXCHANGE PRICES /////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// @dev calculates interest (exchange prices) for a token given its' exchangePricesAndConfig from storage.
|
||||
/// @param exchangePricesAndConfig_ exchange prices and config packed uint256 read from storage
|
||||
/// @return supplyExchangePrice_ updated supplyExchangePrice
|
||||
/// @return borrowExchangePrice_ updated borrowExchangePrice
|
||||
function calcExchangePrices(
|
||||
uint256 exchangePricesAndConfig_
|
||||
) internal view returns (uint256 supplyExchangePrice_, uint256 borrowExchangePrice_) {
|
||||
// Extracting exchange prices
|
||||
supplyExchangePrice_ =
|
||||
(exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_SUPPLY_EXCHANGE_PRICE) &
|
||||
X64;
|
||||
borrowExchangePrice_ =
|
||||
(exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_BORROW_EXCHANGE_PRICE) &
|
||||
X64;
|
||||
|
||||
if (supplyExchangePrice_ == 0 || borrowExchangePrice_ == 0) {
|
||||
revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__ExchangePriceZero);
|
||||
}
|
||||
|
||||
uint256 temp_ = exchangePricesAndConfig_ & X16; // temp_ = borrowRate
|
||||
|
||||
unchecked {
|
||||
// last timestamp can not be > current timestamp
|
||||
uint256 secondsSinceLastUpdate_ = block.timestamp -
|
||||
((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_LAST_TIMESTAMP) & X33);
|
||||
|
||||
uint256 borrowRatio_ = (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_BORROW_RATIO) &
|
||||
X15;
|
||||
if (secondsSinceLastUpdate_ == 0 || temp_ == 0 || borrowRatio_ == 1) {
|
||||
// if no time passed, borrow rate is 0, or no raw borrowings: no exchange price update needed
|
||||
// (if borrowRatio_ == 1 means there is only borrowInterestFree, as first bit is 1 and rest is 0)
|
||||
return (supplyExchangePrice_, borrowExchangePrice_);
|
||||
}
|
||||
|
||||
// calculate new borrow exchange price.
|
||||
// formula borrowExchangePriceIncrease: previous price * borrow rate * secondsSinceLastUpdate_.
|
||||
// nominator is max uint112 (uint64 * uint16 * uint32). Divisor can not be 0.
|
||||
borrowExchangePrice_ +=
|
||||
(borrowExchangePrice_ * temp_ * secondsSinceLastUpdate_) /
|
||||
(SECONDS_PER_YEAR * FOUR_DECIMALS);
|
||||
|
||||
// FOR SUPPLY EXCHANGE PRICE:
|
||||
// all yield paid by borrowers (in mode with interest) goes to suppliers in mode with interest.
|
||||
// formula: previous price * supply rate * secondsSinceLastUpdate_.
|
||||
// where supply rate = (borrow rate - revenueFee%) * ratioSupplyYield. And
|
||||
// ratioSupplyYield = utilization * supplyRatio * borrowRatio
|
||||
//
|
||||
// Example:
|
||||
// supplyRawInterest is 80, supplyInterestFree is 20. totalSupply is 100. BorrowedRawInterest is 50.
|
||||
// BorrowInterestFree is 10. TotalBorrow is 60. borrow rate 40%, revenueFee 10%.
|
||||
// yield is 10 (so half a year must have passed).
|
||||
// supplyRawInterest must become worth 89. totalSupply must become 109. BorrowedRawInterest must become 60.
|
||||
// borrowInterestFree must still be 10. supplyInterestFree still 20. totalBorrow 70.
|
||||
// supplyExchangePrice would have to go from 1 to 1,125 (+ 0.125). borrowExchangePrice from 1 to 1,2 (+0.2).
|
||||
// utilization is 60%. supplyRatio = 20 / 80 = 25% (only 80% of lenders receiving yield).
|
||||
// borrowRatio = 10 / 50 = 20% (only 83,333% of borrowers paying yield):
|
||||
// x of borrowers paying yield = 100% - (20 / (100 + 20)) = 100% - 16.6666666% = 83,333%.
|
||||
// ratioSupplyYield = 60% * 83,33333% * (100% + 20%) = 62,5%
|
||||
// supplyRate = (40% * (100% - 10%)) * = 36% * 62,5% = 22.5%
|
||||
// increase in supplyExchangePrice, assuming 100 as previous price.
|
||||
// 100 * 22,5% * 1/2 (half a year) = 0,1125.
|
||||
// cross-check supplyRawInterest worth = 80 * 1.1125 = 89. totalSupply worth = 89 + 20.
|
||||
|
||||
// -------------- 1. calculate ratioSupplyYield --------------------------------
|
||||
// step1: utilization * supplyRatio (or actually part of lenders receiving yield)
|
||||
|
||||
// temp_ => supplyRatio (in 1e2: 100% = 10_000; 1% = 100 -> max value 16_383)
|
||||
// if first bit 0 then ratio is supplyInterestFree / supplyWithInterest (supplyWithInterest is bigger)
|
||||
// else ratio is supplyWithInterest / supplyInterestFree (supplyInterestFree is bigger)
|
||||
temp_ = (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_SUPPLY_RATIO) & X15;
|
||||
|
||||
if (temp_ == 1) {
|
||||
// if no raw supply: no exchange price update needed
|
||||
// (if supplyRatio_ == 1 means there is only supplyInterestFree, as first bit is 1 and rest is 0)
|
||||
return (supplyExchangePrice_, borrowExchangePrice_);
|
||||
}
|
||||
|
||||
// ratioSupplyYield precision is 1e27 as 100% for increased precision when supplyInterestFree > supplyWithInterest
|
||||
if (temp_ & 1 == 1) {
|
||||
// ratio is supplyWithInterest / supplyInterestFree (supplyInterestFree is bigger)
|
||||
temp_ = temp_ >> 1;
|
||||
|
||||
// Note: case where temp_ == 0 (only supplyInterestFree, no yield) already covered by early return
|
||||
// in the if statement a little above.
|
||||
|
||||
// based on above example but supplyRawInterest is 20, supplyInterestFree is 80. no fee.
|
||||
// supplyRawInterest must become worth 30. totalSupply must become 110.
|
||||
// supplyExchangePrice would have to go from 1 to 1,5. borrowExchangePrice from 1 to 1,2.
|
||||
// so ratioSupplyYield must come out as 2.5 (250%).
|
||||
// supplyRatio would be (20 * 10_000 / 80) = 2500. but must be inverted.
|
||||
temp_ = (1e27 * FOUR_DECIMALS) / temp_; // e.g. 1e31 / 2500 = 4e27. (* 1e27 for precision)
|
||||
// e.g. 5_000 * (1e27 + 4e27) / 1e27 = 25_000 (=250%).
|
||||
temp_ =
|
||||
// utilization * (100% + 100% / supplyRatio)
|
||||
(((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_UTILIZATION) & X14) *
|
||||
(1e27 + temp_)) / // extract utilization (max 16_383 so there is no way this can overflow).
|
||||
(FOUR_DECIMALS);
|
||||
// max possible value of temp_ here is 16383 * (1e27 + 1e31) / 1e4 = ~1.64e31
|
||||
} else {
|
||||
// ratio is supplyInterestFree / supplyWithInterest (supplyWithInterest is bigger)
|
||||
temp_ = temp_ >> 1;
|
||||
// if temp_ == 0 then only supplyWithInterest => full yield. temp_ is already 0
|
||||
|
||||
// e.g. 5_000 * 10_000 + (20 * 10_000 / 80) / 10_000 = 5000 * 12500 / 10000 = 6250 (=62.5%).
|
||||
temp_ =
|
||||
// 1e27 * utilization * (100% + supplyRatio) / 100%
|
||||
(1e27 *
|
||||
((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_UTILIZATION) & X14) * // extract utilization (max 16_383 so there is no way this can overflow).
|
||||
(FOUR_DECIMALS + temp_)) /
|
||||
(FOUR_DECIMALS * FOUR_DECIMALS);
|
||||
// max possible temp_ value: 1e27 * 16383 * 2e4 / 1e8 = 3.2766e27
|
||||
}
|
||||
// from here temp_ => ratioSupplyYield (utilization * supplyRatio part) scaled by 1e27. max possible value ~1.64e31
|
||||
|
||||
// step2 of ratioSupplyYield: add borrowRatio (only x% of borrowers paying yield)
|
||||
if (borrowRatio_ & 1 == 1) {
|
||||
// ratio is borrowWithInterest / borrowInterestFree (borrowInterestFree is bigger)
|
||||
borrowRatio_ = borrowRatio_ >> 1;
|
||||
// borrowRatio_ => x of total bororwers paying yield. scale to 1e27.
|
||||
|
||||
// Note: case where borrowRatio_ == 0 (only borrowInterestFree, no yield) already covered
|
||||
// at the beginning of the method by early return if `borrowRatio_ == 1`.
|
||||
|
||||
// based on above example but borrowRawInterest is 10, borrowInterestFree is 50. no fee. borrowRatio = 20%.
|
||||
// so only 16.66% of borrowers are paying yield. so the 100% - part of the formula is not needed.
|
||||
// x of borrowers paying yield = (borrowRatio / (100 + borrowRatio)) = 16.6666666%
|
||||
// borrowRatio_ => x of total bororwers paying yield. scale to 1e27.
|
||||
borrowRatio_ = (borrowRatio_ * 1e27) / (FOUR_DECIMALS + borrowRatio_);
|
||||
// max value here for borrowRatio_ is (1e31 / (1e4 + 1e4))= 5e26 (= 50% of borrowers paying yield).
|
||||
} else {
|
||||
// ratio is borrowInterestFree / borrowWithInterest (borrowWithInterest is bigger)
|
||||
borrowRatio_ = borrowRatio_ >> 1;
|
||||
|
||||
// borrowRatio_ => x of total bororwers paying yield. scale to 1e27.
|
||||
// x of borrowers paying yield = 100% - (borrowRatio / (100 + borrowRatio)) = 100% - 16.6666666% = 83,333%.
|
||||
borrowRatio_ = (1e27 - ((borrowRatio_ * 1e27) / (FOUR_DECIMALS + borrowRatio_)));
|
||||
// borrowRatio can never be > 100%. so max subtraction can be 100% - 100% / 200%.
|
||||
// or if borrowRatio_ is 0 -> 100% - 0. or if borrowRatio_ is 1 -> 100% - 1 / 101.
|
||||
// max value here for borrowRatio_ is 1e27 - 0 = 1e27 (= 100% of borrowers paying yield).
|
||||
}
|
||||
|
||||
// temp_ => ratioSupplyYield. scaled down from 1e25 = 1% each to normal percent precision 1e2 = 1%.
|
||||
// max nominator value is ~1.64e31 * 1e27 = 1.64e58. max result = 1.64e8
|
||||
temp_ = (FOUR_DECIMALS * temp_ * borrowRatio_) / 1e54;
|
||||
|
||||
// 2. calculate supply rate
|
||||
// temp_ => supply rate (borrow rate - revenueFee%) * ratioSupplyYield.
|
||||
// division part is done in next step to increase precision. (divided by 2x FOUR_DECIMALS, fee + borrowRate)
|
||||
// Note that all calculation divisions for supplyExchangePrice are rounded down.
|
||||
// Note supply rate can be bigger than the borrowRate, e.g. if there are only few lenders with interest
|
||||
// but more suppliers not earning interest.
|
||||
temp_ = ((exchangePricesAndConfig_ & X16) * // borrow rate
|
||||
temp_ * // ratioSupplyYield
|
||||
(FOUR_DECIMALS - ((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_FEE) & X14))); // revenueFee
|
||||
// fee can not be > 100%. max possible = 65535 * ~1.64e8 * 1e4 =~1.074774e17.
|
||||
|
||||
// 3. calculate increase in supply exchange price
|
||||
supplyExchangePrice_ += ((supplyExchangePrice_ * temp_ * secondsSinceLastUpdate_) /
|
||||
(SECONDS_PER_YEAR * FOUR_DECIMALS * FOUR_DECIMALS * FOUR_DECIMALS));
|
||||
// max possible nominator = max uint 64 * 1.074774e17 * max uint32 = ~8.52e45. Denominator can not be 0.
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
////////// CALC REVENUE /////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// @dev gets the `revenueAmount_` for a token given its' totalAmounts and exchangePricesAndConfig from storage
|
||||
/// and the current balance of the Fluid liquidity contract for the token.
|
||||
/// @param totalAmounts_ total amounts packed uint256 read from storage
|
||||
/// @param exchangePricesAndConfig_ exchange prices and config packed uint256 read from storage
|
||||
/// @param liquidityTokenBalance_ current balance of Liquidity contract (IERC20(token_).balanceOf(address(this)))
|
||||
/// @return revenueAmount_ collectable revenue amount
|
||||
function calcRevenue(
|
||||
uint256 totalAmounts_,
|
||||
uint256 exchangePricesAndConfig_,
|
||||
uint256 liquidityTokenBalance_
|
||||
) internal view returns (uint256 revenueAmount_) {
|
||||
// @dev no need to super-optimize this method as it is only used by admin
|
||||
|
||||
// calculate the new exchange prices based on earned interest
|
||||
(uint256 supplyExchangePrice_, uint256 borrowExchangePrice_) = calcExchangePrices(exchangePricesAndConfig_);
|
||||
|
||||
// total supply = interest free + with interest converted from raw
|
||||
uint256 totalSupply_ = getTotalSupply(totalAmounts_, supplyExchangePrice_);
|
||||
|
||||
if (totalSupply_ > 0) {
|
||||
// available revenue: balanceOf(token) + totalBorrowings - totalLendings.
|
||||
revenueAmount_ = liquidityTokenBalance_ + getTotalBorrow(totalAmounts_, borrowExchangePrice_);
|
||||
// ensure there is no possible case because of rounding etc. where this would revert,
|
||||
// explicitly check if >
|
||||
revenueAmount_ = revenueAmount_ > totalSupply_ ? revenueAmount_ - totalSupply_ : 0;
|
||||
// Note: if utilization > 100% (totalSupply < totalBorrow), then all the amount above 100% utilization
|
||||
// can only be revenue.
|
||||
} else {
|
||||
// if supply is 0, then rest of balance can be withdrawn as revenue so that no amounts get stuck
|
||||
revenueAmount_ = liquidityTokenBalance_;
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
////////// CALC LIMITS /////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// @dev calculates withdrawal limit before an operate execution:
|
||||
/// amount of user supply that must stay supplied (not amount that can be withdrawn).
|
||||
/// i.e. if user has supplied 100m and can withdraw 5M, this method returns the 95M, not the withdrawable amount 5M
|
||||
/// @param userSupplyData_ user supply data packed uint256 from storage
|
||||
/// @param userSupply_ current user supply amount already extracted from `userSupplyData_` and converted from BigMath
|
||||
/// @return currentWithdrawalLimit_ current withdrawal limit updated for expansion since last interaction.
|
||||
/// returned value is in raw for with interest mode, normal amount for interest free mode!
|
||||
function calcWithdrawalLimitBeforeOperate(
|
||||
uint256 userSupplyData_,
|
||||
uint256 userSupply_
|
||||
) internal view returns (uint256 currentWithdrawalLimit_) {
|
||||
// @dev must support handling the case where timestamp is 0 (config is set but no interactions yet).
|
||||
// first tx where timestamp is 0 will enter `if (lastWithdrawalLimit_ == 0)` because lastWithdrawalLimit_ is not set yet.
|
||||
// returning max withdrawal allowed, which is not exactly right but doesn't matter because the first interaction must be
|
||||
// a deposit anyway. Important is that it would not revert.
|
||||
|
||||
// Note the first time a deposit brings the user supply amount to above the base withdrawal limit, the active limit
|
||||
// is the fully expanded limit immediately.
|
||||
|
||||
// extract last set withdrawal limit
|
||||
uint256 lastWithdrawalLimit_ = (userSupplyData_ >>
|
||||
LiquiditySlotsLink.BITS_USER_SUPPLY_PREVIOUS_WITHDRAWAL_LIMIT) & X64;
|
||||
lastWithdrawalLimit_ =
|
||||
(lastWithdrawalLimit_ >> DEFAULT_EXPONENT_SIZE) <<
|
||||
(lastWithdrawalLimit_ & DEFAULT_EXPONENT_MASK);
|
||||
if (lastWithdrawalLimit_ == 0) {
|
||||
// withdrawal limit is not activated. Max withdrawal allowed
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint256 maxWithdrawableLimit_;
|
||||
uint256 temp_;
|
||||
unchecked {
|
||||
// extract max withdrawable percent of user supply and
|
||||
// calculate maximum withdrawable amount expandPercentage of user supply at full expansion duration elapsed
|
||||
// e.g.: if 10% expandPercentage, meaning 10% is withdrawable after full expandDuration has elapsed.
|
||||
|
||||
// userSupply_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).
|
||||
maxWithdrawableLimit_ =
|
||||
(((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14) * userSupply_) /
|
||||
FOUR_DECIMALS;
|
||||
|
||||
// time elapsed since last withdrawal limit was set (in seconds)
|
||||
// @dev last process timestamp is guaranteed to exist for withdrawal, as a supply must have happened before.
|
||||
// last timestamp can not be > current timestamp
|
||||
temp_ =
|
||||
block.timestamp -
|
||||
((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_LAST_UPDATE_TIMESTAMP) & X33);
|
||||
}
|
||||
// calculate withdrawable amount of expandPercent that is elapsed of expandDuration.
|
||||
// e.g. if 60% of expandDuration has elapsed, then user should be able to withdraw 6% of user supply, down to 94%.
|
||||
// Note: no explicit check for this needed, it is covered by setting minWithdrawalLimit_ if needed.
|
||||
temp_ =
|
||||
(maxWithdrawableLimit_ * temp_) /
|
||||
// extract expand duration: After this, decrement won't happen (user can withdraw 100% of withdraw limit)
|
||||
((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_DURATION) & X24); // expand duration can never be 0
|
||||
// calculate expanded withdrawal limit: last withdrawal limit - withdrawable amount.
|
||||
// Note: withdrawable amount here can grow bigger than userSupply if timeElapsed is a lot bigger than expandDuration,
|
||||
// which would cause the subtraction `lastWithdrawalLimit_ - withdrawableAmount_` to revert. In that case, set 0
|
||||
// which will cause minimum (fully expanded) withdrawal limit to be set in lines below.
|
||||
unchecked {
|
||||
// underflow explicitly checked & handled
|
||||
currentWithdrawalLimit_ = lastWithdrawalLimit_ > temp_ ? lastWithdrawalLimit_ - temp_ : 0;
|
||||
// calculate minimum withdrawal limit: minimum amount of user supply that must stay supplied at full expansion.
|
||||
// subtraction can not underflow as maxWithdrawableLimit_ is a percentage amount (<=100%) of userSupply_
|
||||
temp_ = userSupply_ - maxWithdrawableLimit_;
|
||||
}
|
||||
// if withdrawal limit is decreased below minimum then set minimum
|
||||
// (e.g. when more than expandDuration time has elapsed)
|
||||
if (temp_ > currentWithdrawalLimit_) {
|
||||
currentWithdrawalLimit_ = temp_;
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev calculates withdrawal limit after an operate execution:
|
||||
/// amount of user supply that must stay supplied (not amount that can be withdrawn).
|
||||
/// i.e. if user has supplied 100m and can withdraw 5M, this method returns the 95M, not the withdrawable amount 5M
|
||||
/// @param userSupplyData_ user supply data packed uint256 from storage
|
||||
/// @param userSupply_ current user supply amount already extracted from `userSupplyData_` and added / subtracted with the executed operate amount
|
||||
/// @param newWithdrawalLimit_ current withdrawal limit updated for expansion since last interaction, result from `calcWithdrawalLimitBeforeOperate`
|
||||
/// @return withdrawalLimit_ updated withdrawal limit that should be written to storage. returned value is in
|
||||
/// raw for with interest mode, normal amount for interest free mode!
|
||||
function calcWithdrawalLimitAfterOperate(
|
||||
uint256 userSupplyData_,
|
||||
uint256 userSupply_,
|
||||
uint256 newWithdrawalLimit_
|
||||
) internal pure returns (uint256) {
|
||||
// temp_ => base withdrawal limit. below this, maximum withdrawals are allowed
|
||||
uint256 temp_ = (userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT) & X18;
|
||||
temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
// if user supply is below base limit then max withdrawals are allowed
|
||||
if (userSupply_ < temp_) {
|
||||
return 0;
|
||||
}
|
||||
// temp_ => withdrawal limit expandPercent (is in 1e2 decimals)
|
||||
temp_ = (userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14;
|
||||
unchecked {
|
||||
// temp_ => minimum withdrawal limit: userSupply - max withdrawable limit (userSupply * expandPercent))
|
||||
// userSupply_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).
|
||||
// subtraction can not underflow as maxWithdrawableLimit_ is a percentage amount (<=100%) of userSupply_
|
||||
temp_ = userSupply_ - ((userSupply_ * temp_) / FOUR_DECIMALS);
|
||||
}
|
||||
// if new (before operation) withdrawal limit is less than minimum limit then set minimum limit.
|
||||
// e.g. can happen on new deposits. withdrawal limit is instantly fully expanded in a scenario where
|
||||
// increased deposit amount outpaces withrawals.
|
||||
if (temp_ > newWithdrawalLimit_) {
|
||||
return temp_;
|
||||
}
|
||||
return newWithdrawalLimit_;
|
||||
}
|
||||
|
||||
/// @dev calculates borrow limit before an operate execution:
|
||||
/// total amount user borrow can reach (not borrowable amount in current operation).
|
||||
/// i.e. if user has borrowed 50M and can still borrow 5M, this method returns the total 55M, not the borrowable amount 5M
|
||||
/// @param userBorrowData_ user borrow data packed uint256 from storage
|
||||
/// @param userBorrow_ current user borrow amount already extracted from `userBorrowData_`
|
||||
/// @return currentBorrowLimit_ current borrow limit updated for expansion since last interaction. returned value is in
|
||||
/// raw for with interest mode, normal amount for interest free mode!
|
||||
function calcBorrowLimitBeforeOperate(
|
||||
uint256 userBorrowData_,
|
||||
uint256 userBorrow_
|
||||
) internal view returns (uint256 currentBorrowLimit_) {
|
||||
// @dev must support handling the case where timestamp is 0 (config is set but no interactions yet) -> base limit.
|
||||
// first tx where timestamp is 0 will enter `if (maxExpandedBorrowLimit_ < baseBorrowLimit_)` because `userBorrow_` and thus
|
||||
// `maxExpansionLimit_` and thus `maxExpandedBorrowLimit_` is 0 and `baseBorrowLimit_` can not be 0.
|
||||
|
||||
// temp_ = extract borrow expand percent (is in 1e2 decimals)
|
||||
uint256 temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14;
|
||||
|
||||
uint256 maxExpansionLimit_;
|
||||
uint256 maxExpandedBorrowLimit_;
|
||||
unchecked {
|
||||
// calculate max expansion limit: Max amount limit can expand to since last interaction
|
||||
// userBorrow_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).
|
||||
maxExpansionLimit_ = ((userBorrow_ * temp_) / FOUR_DECIMALS);
|
||||
|
||||
// calculate max borrow limit: Max point limit can increase to since last interaction
|
||||
maxExpandedBorrowLimit_ = userBorrow_ + maxExpansionLimit_;
|
||||
}
|
||||
|
||||
// currentBorrowLimit_ = extract base borrow limit
|
||||
currentBorrowLimit_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18;
|
||||
currentBorrowLimit_ =
|
||||
(currentBorrowLimit_ >> DEFAULT_EXPONENT_SIZE) <<
|
||||
(currentBorrowLimit_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
if (maxExpandedBorrowLimit_ < currentBorrowLimit_) {
|
||||
return currentBorrowLimit_;
|
||||
}
|
||||
// time elapsed since last borrow limit was set (in seconds)
|
||||
unchecked {
|
||||
// temp_ = timeElapsed_ (last timestamp can not be > current timestamp)
|
||||
temp_ =
|
||||
block.timestamp -
|
||||
((userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_LAST_UPDATE_TIMESTAMP) & X33); // extract last update timestamp
|
||||
}
|
||||
|
||||
// currentBorrowLimit_ = expandedBorrowableAmount + extract last set borrow limit
|
||||
currentBorrowLimit_ =
|
||||
// calculate borrow limit expansion since last interaction for `expandPercent` that is elapsed of `expandDuration`.
|
||||
// divisor is extract expand duration (after this, full expansion to expandPercentage happened).
|
||||
((maxExpansionLimit_ * temp_) /
|
||||
((userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_DURATION) & X24)) + // expand duration can never be 0
|
||||
// extract last set borrow limit
|
||||
BigMathMinified.fromBigNumber(
|
||||
(userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_PREVIOUS_BORROW_LIMIT) & X64,
|
||||
DEFAULT_EXPONENT_SIZE,
|
||||
DEFAULT_EXPONENT_MASK
|
||||
);
|
||||
|
||||
// if timeElapsed is bigger than expandDuration, new borrow limit would be > max expansion,
|
||||
// so set to `maxExpandedBorrowLimit_` in that case.
|
||||
// also covers the case where last process timestamp = 0 (timeElapsed would simply be very big)
|
||||
if (currentBorrowLimit_ > maxExpandedBorrowLimit_) {
|
||||
currentBorrowLimit_ = maxExpandedBorrowLimit_;
|
||||
}
|
||||
// temp_ = extract hard max borrow limit. Above this user can never borrow (not expandable above)
|
||||
temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18;
|
||||
temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
if (currentBorrowLimit_ > temp_) {
|
||||
currentBorrowLimit_ = temp_;
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev calculates borrow limit after an operate execution:
|
||||
/// total amount user borrow can reach (not borrowable amount in current operation).
|
||||
/// i.e. if user has borrowed 50M and can still borrow 5M, this method returns the total 55M, not the borrowable amount 5M
|
||||
/// @param userBorrowData_ user borrow data packed uint256 from storage
|
||||
/// @param userBorrow_ current user borrow amount already extracted from `userBorrowData_` and added / subtracted with the executed operate amount
|
||||
/// @param newBorrowLimit_ current borrow limit updated for expansion since last interaction, result from `calcBorrowLimitBeforeOperate`
|
||||
/// @return borrowLimit_ updated borrow limit that should be written to storage.
|
||||
/// returned value is in raw for with interest mode, normal amount for interest free mode!
|
||||
function calcBorrowLimitAfterOperate(
|
||||
uint256 userBorrowData_,
|
||||
uint256 userBorrow_,
|
||||
uint256 newBorrowLimit_
|
||||
) internal pure returns (uint256 borrowLimit_) {
|
||||
// temp_ = extract borrow expand percent
|
||||
uint256 temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14; // (is in 1e2 decimals)
|
||||
|
||||
unchecked {
|
||||
// borrowLimit_ = calculate maximum borrow limit at full expansion.
|
||||
// userBorrow_ needs to be at least 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).
|
||||
borrowLimit_ = userBorrow_ + ((userBorrow_ * temp_) / FOUR_DECIMALS);
|
||||
}
|
||||
|
||||
// temp_ = extract base borrow limit
|
||||
temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18;
|
||||
temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
if (borrowLimit_ < temp_) {
|
||||
// below base limit, borrow limit is always base limit
|
||||
return temp_;
|
||||
}
|
||||
// temp_ = extract hard max borrow limit. Above this user can never borrow (not expandable above)
|
||||
temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18;
|
||||
temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
// make sure fully expanded borrow limit is not above hard max borrow limit
|
||||
if (borrowLimit_ > temp_) {
|
||||
borrowLimit_ = temp_;
|
||||
}
|
||||
// if new borrow limit (from before operate) is > max borrow limit, set max borrow limit.
|
||||
// (e.g. on a repay shrinking instantly to fully expanded borrow limit from new borrow amount. shrinking is instant)
|
||||
if (newBorrowLimit_ > borrowLimit_) {
|
||||
return borrowLimit_;
|
||||
}
|
||||
return newBorrowLimit_;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
////////// CALC RATES /////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// @dev Calculates new borrow rate from utilization for a token
|
||||
/// @param rateData_ rate data packed uint256 from storage for the token
|
||||
/// @param utilization_ totalBorrow / totalSupply. 1e4 = 100% utilization
|
||||
/// @return rate_ rate for that particular token in 1e2 precision (e.g. 5% rate = 500)
|
||||
function calcBorrowRateFromUtilization(uint256 rateData_, uint256 utilization_) internal returns (uint256 rate_) {
|
||||
// extract rate version: 4 bits (0xF) starting from bit 0
|
||||
uint256 rateVersion_ = (rateData_ & 0xF);
|
||||
|
||||
if (rateVersion_ == 1) {
|
||||
rate_ = calcRateV1(rateData_, utilization_);
|
||||
} else if (rateVersion_ == 2) {
|
||||
rate_ = calcRateV2(rateData_, utilization_);
|
||||
} else {
|
||||
revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__UnsupportedRateVersion);
|
||||
}
|
||||
|
||||
if (rate_ > X16) {
|
||||
// hard cap for borrow rate at maximum value 16 bits (65535) to make sure it does not overflow storage space.
|
||||
// this is unlikely to ever happen if configs stay within expected levels.
|
||||
rate_ = X16;
|
||||
// emit event to more easily become aware
|
||||
emit BorrowRateMaxCap();
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev calculates the borrow rate based on utilization for rate data version 1 (with one kink) in 1e2 precision
|
||||
/// @param rateData_ rate data packed uint256 from storage for the token
|
||||
/// @param utilization_ in 1e2 (100% = 1e4)
|
||||
/// @return rate_ rate in 1e2 precision
|
||||
function calcRateV1(uint256 rateData_, uint256 utilization_) internal pure returns (uint256 rate_) {
|
||||
/// For rate v1 (one kink) ------------------------------------------------------
|
||||
/// Next 16 bits => 4 - 19 => Rate at utilization 0% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 20- 35 => Utilization at kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 36- 51 => Rate at utilization kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 52- 67 => Rate at utilization 100% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Last 188 bits => 68-255 => blank, might come in use in future
|
||||
|
||||
// y = mx + c.
|
||||
// y is borrow rate
|
||||
// x is utilization
|
||||
// m = slope (m can also be negative for declining rates)
|
||||
// c is constant (c can be negative)
|
||||
|
||||
uint256 y1_;
|
||||
uint256 y2_;
|
||||
uint256 x1_;
|
||||
uint256 x2_;
|
||||
|
||||
// extract kink1: 16 bits (0xFFFF) starting from bit 20
|
||||
// kink is in 1e2, same as utilization, so no conversion needed for direct comparison of the two
|
||||
uint256 kink1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_UTILIZATION_AT_KINK) & X16;
|
||||
if (utilization_ < kink1_) {
|
||||
// if utilization is less than kink
|
||||
y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_ZERO) & X16;
|
||||
y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK) & X16;
|
||||
x1_ = 0; // 0%
|
||||
x2_ = kink1_;
|
||||
} else {
|
||||
// else utilization is greater than kink
|
||||
y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK) & X16;
|
||||
y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_MAX) & X16;
|
||||
x1_ = kink1_;
|
||||
x2_ = FOUR_DECIMALS; // 100%
|
||||
}
|
||||
|
||||
int256 constant_;
|
||||
int256 slope_;
|
||||
unchecked {
|
||||
// calculating slope with twelve decimal precision. m = (y2 - y1) / (x2 - x1).
|
||||
// utilization of x2 can not be <= utilization of x1 (so no underflow or 0 divisor)
|
||||
// y is in 1e2 so can not overflow when multiplied with TWELVE_DECIMALS
|
||||
slope_ = (int256(y2_ - y1_) * int256(TWELVE_DECIMALS)) / int256((x2_ - x1_));
|
||||
|
||||
// calculating constant at 12 decimal precision. slope is already in 12 decimal hence only multiple with y1. c = y - mx.
|
||||
// maximum y1_ value is 65535. 65535 * 1e12 can not overflow int256
|
||||
// maximum slope is 65535 - 0 * TWELVE_DECIMALS / 1 = 65535 * 1e12;
|
||||
// maximum x1_ is 100% (9_999 actually) => slope_ * x1_ can not overflow int256
|
||||
// subtraction most extreme case would be 0 - max value slope_ * x1_ => can not underflow int256
|
||||
constant_ = int256(y1_ * TWELVE_DECIMALS) - (slope_ * int256(x1_));
|
||||
|
||||
// calculating new borrow rate
|
||||
// - slope_ max value is 65535 * 1e12,
|
||||
// - utilization max value is let's say 500% (extreme case where borrow rate increases borrow amount without new supply)
|
||||
// - constant max value is 65535 * 1e12
|
||||
// so max values are 65535 * 1e12 * 50_000 + 65535 * 1e12 -> 3.2768*10^21, which easily fits int256
|
||||
// divisor TWELVE_DECIMALS can not be 0
|
||||
slope_ = (slope_ * int256(utilization_)) + constant_; // reusing `slope_` as variable for gas savings
|
||||
if (slope_ < 0) {
|
||||
revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__BorrowRateNegative);
|
||||
}
|
||||
rate_ = uint256(slope_) / TWELVE_DECIMALS;
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev calculates the borrow rate based on utilization for rate data version 2 (with two kinks) in 1e4 precision
|
||||
/// @param rateData_ rate data packed uint256 from storage for the token
|
||||
/// @param utilization_ in 1e2 (100% = 1e4)
|
||||
/// @return rate_ rate in 1e4 precision
|
||||
function calcRateV2(uint256 rateData_, uint256 utilization_) internal pure returns (uint256 rate_) {
|
||||
/// For rate v2 (two kinks) -----------------------------------------------------
|
||||
/// Next 16 bits => 4 - 19 => Rate at utilization 0% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 20- 35 => Utilization at kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 36- 51 => Rate at utilization kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 52- 67 => Utilization at kink2 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 68- 83 => Rate at utilization kink2 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Next 16 bits => 84- 99 => Rate at utilization 100% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)
|
||||
/// Last 156 bits => 100-255 => blank, might come in use in future
|
||||
|
||||
// y = mx + c.
|
||||
// y is borrow rate
|
||||
// x is utilization
|
||||
// m = slope (m can also be negative for declining rates)
|
||||
// c is constant (c can be negative)
|
||||
|
||||
uint256 y1_;
|
||||
uint256 y2_;
|
||||
uint256 x1_;
|
||||
uint256 x2_;
|
||||
|
||||
// extract kink1: 16 bits (0xFFFF) starting from bit 20
|
||||
// kink is in 1e2, same as utilization, so no conversion needed for direct comparison of the two
|
||||
uint256 kink1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_UTILIZATION_AT_KINK1) & X16;
|
||||
if (utilization_ < kink1_) {
|
||||
// if utilization is less than kink1
|
||||
y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_ZERO) & X16;
|
||||
y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1) & X16;
|
||||
x1_ = 0; // 0%
|
||||
x2_ = kink1_;
|
||||
} else {
|
||||
// extract kink2: 16 bits (0xFFFF) starting from bit 52
|
||||
uint256 kink2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_UTILIZATION_AT_KINK2) & X16;
|
||||
if (utilization_ < kink2_) {
|
||||
// if utilization is less than kink2
|
||||
y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1) & X16;
|
||||
y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2) & X16;
|
||||
x1_ = kink1_;
|
||||
x2_ = kink2_;
|
||||
} else {
|
||||
// else utilization is greater than kink2
|
||||
y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2) & X16;
|
||||
y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_MAX) & X16;
|
||||
x1_ = kink2_;
|
||||
x2_ = FOUR_DECIMALS;
|
||||
}
|
||||
}
|
||||
|
||||
int256 constant_;
|
||||
int256 slope_;
|
||||
unchecked {
|
||||
// calculating slope with twelve decimal precision. m = (y2 - y1) / (x2 - x1).
|
||||
// utilization of x2 can not be <= utilization of x1 (so no underflow or 0 divisor)
|
||||
// y is in 1e2 so can not overflow when multiplied with TWELVE_DECIMALS
|
||||
slope_ = (int256(y2_ - y1_) * int256(TWELVE_DECIMALS)) / int256((x2_ - x1_));
|
||||
|
||||
// calculating constant at 12 decimal precision. slope is already in 12 decimal hence only multiple with y1. c = y - mx.
|
||||
// maximum y1_ value is 65535. 65535 * 1e12 can not overflow int256
|
||||
// maximum slope is 65535 - 0 * TWELVE_DECIMALS / 1 = 65535 * 1e12;
|
||||
// maximum x1_ is 100% (9_999 actually) => slope_ * x1_ can not overflow int256
|
||||
// subtraction most extreme case would be 0 - max value slope_ * x1_ => can not underflow int256
|
||||
constant_ = int256(y1_ * TWELVE_DECIMALS) - (slope_ * int256(x1_));
|
||||
|
||||
// calculating new borrow rate
|
||||
// - slope_ max value is 65535 * 1e12,
|
||||
// - utilization max value is let's say 500% (extreme case where borrow rate increases borrow amount without new supply)
|
||||
// - constant max value is 65535 * 1e12
|
||||
// so max values are 65535 * 1e12 * 50_000 + 65535 * 1e12 -> 3.2768*10^21, which easily fits int256
|
||||
// divisor TWELVE_DECIMALS can not be 0
|
||||
slope_ = (slope_ * int256(utilization_)) + constant_; // reusing `slope_` as variable for gas savings
|
||||
if (slope_ < 0) {
|
||||
revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__BorrowRateNegative);
|
||||
}
|
||||
rate_ = uint256(slope_) / TWELVE_DECIMALS;
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev reads the total supply out of Liquidity packed storage `totalAmounts_` for `supplyExchangePrice_`
|
||||
function getTotalSupply(
|
||||
uint256 totalAmounts_,
|
||||
uint256 supplyExchangePrice_
|
||||
) internal pure returns (uint256 totalSupply_) {
|
||||
// totalSupply_ => supplyInterestFree
|
||||
totalSupply_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_SUPPLY_INTEREST_FREE) & X64;
|
||||
totalSupply_ = (totalSupply_ >> DEFAULT_EXPONENT_SIZE) << (totalSupply_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
uint256 totalSupplyRaw_ = totalAmounts_ & X64; // no shifting as supplyRaw is first 64 bits
|
||||
totalSupplyRaw_ = (totalSupplyRaw_ >> DEFAULT_EXPONENT_SIZE) << (totalSupplyRaw_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
// totalSupply = supplyInterestFree + supplyRawInterest normalized from raw
|
||||
totalSupply_ += ((totalSupplyRaw_ * supplyExchangePrice_) / EXCHANGE_PRICES_PRECISION);
|
||||
}
|
||||
|
||||
/// @dev reads the total borrow out of Liquidity packed storage `totalAmounts_` for `borrowExchangePrice_`
|
||||
function getTotalBorrow(
|
||||
uint256 totalAmounts_,
|
||||
uint256 borrowExchangePrice_
|
||||
) internal pure returns (uint256 totalBorrow_) {
|
||||
// totalBorrow_ => borrowInterestFree
|
||||
// no & mask needed for borrow interest free as it occupies the last bits in the storage slot
|
||||
totalBorrow_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_BORROW_INTEREST_FREE);
|
||||
totalBorrow_ = (totalBorrow_ >> DEFAULT_EXPONENT_SIZE) << (totalBorrow_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
uint256 totalBorrowRaw_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_BORROW_WITH_INTEREST) & X64;
|
||||
totalBorrowRaw_ = (totalBorrowRaw_ >> DEFAULT_EXPONENT_SIZE) << (totalBorrowRaw_ & DEFAULT_EXPONENT_MASK);
|
||||
|
||||
// totalBorrow = borrowInterestFree + borrowRawInterest normalized from raw
|
||||
totalBorrow_ += ((totalBorrowRaw_ * borrowExchangePrice_) / EXCHANGE_PRICES_PRECISION);
|
||||
}
|
||||
}
|
101
contracts/payloads/IGP31/libraries/liquiditySlotsLink.sol
Normal file
101
contracts/payloads/IGP31/libraries/liquiditySlotsLink.sol
Normal file
|
@ -0,0 +1,101 @@
|
|||
// SPDX-License-Identifier: BUSL-1.1
|
||||
pragma solidity 0.8.21;
|
||||
|
||||
/// @notice library that helps in reading / working with storage slot data of Fluid Liquidity.
|
||||
/// @dev as all data for Fluid Liquidity is internal, any data must be fetched directly through manual
|
||||
/// slot reading through this library or, if gas usage is less important, through the FluidLiquidityResolver.
|
||||
library LiquiditySlotsLink {
|
||||
/// @dev storage slot for status at Liquidity
|
||||
uint256 internal constant LIQUIDITY_STATUS_SLOT = 1;
|
||||
/// @dev storage slot for auths mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_AUTHS_MAPPING_SLOT = 2;
|
||||
/// @dev storage slot for guardians mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_GUARDIANS_MAPPING_SLOT = 3;
|
||||
/// @dev storage slot for user class mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_USER_CLASS_MAPPING_SLOT = 4;
|
||||
/// @dev storage slot for exchangePricesAndConfig mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT = 5;
|
||||
/// @dev storage slot for rateData mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_RATE_DATA_MAPPING_SLOT = 6;
|
||||
/// @dev storage slot for totalAmounts mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_TOTAL_AMOUNTS_MAPPING_SLOT = 7;
|
||||
/// @dev storage slot for user supply double mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT = 8;
|
||||
/// @dev storage slot for user borrow double mapping at Liquidity
|
||||
uint256 internal constant LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT = 9;
|
||||
/// @dev storage slot for listed tokens array at Liquidity
|
||||
uint256 internal constant LIQUIDITY_LISTED_TOKENS_ARRAY_SLOT = 10;
|
||||
|
||||
// --------------------------------
|
||||
// @dev stacked uint256 storage slots bits position data for each:
|
||||
|
||||
// ExchangePricesAndConfig
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_RATE = 0;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_FEE = 16;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_UTILIZATION = 30;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_UPDATE_THRESHOLD = 44;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_LAST_TIMESTAMP = 58;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_SUPPLY_EXCHANGE_PRICE = 91;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_EXCHANGE_PRICE = 155;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_SUPPLY_RATIO = 219;
|
||||
uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_RATIO = 234;
|
||||
|
||||
// RateData:
|
||||
uint256 internal constant BITS_RATE_DATA_VERSION = 0;
|
||||
// RateData: V1
|
||||
uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_ZERO = 4;
|
||||
uint256 internal constant BITS_RATE_DATA_V1_UTILIZATION_AT_KINK = 20;
|
||||
uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK = 36;
|
||||
uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_MAX = 52;
|
||||
// RateData: V2
|
||||
uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_ZERO = 4;
|
||||
uint256 internal constant BITS_RATE_DATA_V2_UTILIZATION_AT_KINK1 = 20;
|
||||
uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1 = 36;
|
||||
uint256 internal constant BITS_RATE_DATA_V2_UTILIZATION_AT_KINK2 = 52;
|
||||
uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2 = 68;
|
||||
uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_MAX = 84;
|
||||
|
||||
// TotalAmounts
|
||||
uint256 internal constant BITS_TOTAL_AMOUNTS_SUPPLY_WITH_INTEREST = 0;
|
||||
uint256 internal constant BITS_TOTAL_AMOUNTS_SUPPLY_INTEREST_FREE = 64;
|
||||
uint256 internal constant BITS_TOTAL_AMOUNTS_BORROW_WITH_INTEREST = 128;
|
||||
uint256 internal constant BITS_TOTAL_AMOUNTS_BORROW_INTEREST_FREE = 192;
|
||||
|
||||
// UserSupplyData
|
||||
uint256 internal constant BITS_USER_SUPPLY_MODE = 0;
|
||||
uint256 internal constant BITS_USER_SUPPLY_AMOUNT = 1;
|
||||
uint256 internal constant BITS_USER_SUPPLY_PREVIOUS_WITHDRAWAL_LIMIT = 65;
|
||||
uint256 internal constant BITS_USER_SUPPLY_LAST_UPDATE_TIMESTAMP = 129;
|
||||
uint256 internal constant BITS_USER_SUPPLY_EXPAND_PERCENT = 162;
|
||||
uint256 internal constant BITS_USER_SUPPLY_EXPAND_DURATION = 176;
|
||||
uint256 internal constant BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT = 200;
|
||||
uint256 internal constant BITS_USER_SUPPLY_IS_PAUSED = 255;
|
||||
|
||||
// UserBorrowData
|
||||
uint256 internal constant BITS_USER_BORROW_MODE = 0;
|
||||
uint256 internal constant BITS_USER_BORROW_AMOUNT = 1;
|
||||
uint256 internal constant BITS_USER_BORROW_PREVIOUS_BORROW_LIMIT = 65;
|
||||
uint256 internal constant BITS_USER_BORROW_LAST_UPDATE_TIMESTAMP = 129;
|
||||
uint256 internal constant BITS_USER_BORROW_EXPAND_PERCENT = 162;
|
||||
uint256 internal constant BITS_USER_BORROW_EXPAND_DURATION = 176;
|
||||
uint256 internal constant BITS_USER_BORROW_BASE_BORROW_LIMIT = 200;
|
||||
uint256 internal constant BITS_USER_BORROW_MAX_BORROW_LIMIT = 218;
|
||||
uint256 internal constant BITS_USER_BORROW_IS_PAUSED = 255;
|
||||
|
||||
// --------------------------------
|
||||
|
||||
/// @notice Calculating the slot ID for Liquidity contract for single mapping at `slot_` for `key_`
|
||||
function calculateMappingStorageSlot(uint256 slot_, address key_) internal pure returns (bytes32) {
|
||||
return keccak256(abi.encode(key_, slot_));
|
||||
}
|
||||
|
||||
/// @notice Calculating the slot ID for Liquidity contract for double mapping at `slot_` for `key1_` and `key2_`
|
||||
function calculateDoubleMappingStorageSlot(
|
||||
uint256 slot_,
|
||||
address key1_,
|
||||
address key2_
|
||||
) internal pure returns (bytes32) {
|
||||
bytes32 intermediateSlot_ = keccak256(abi.encode(key1_, slot_));
|
||||
return keccak256(abi.encode(key2_, intermediateSlot_));
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue
Block a user