From ce46ad09ffbadc78e00b05b0218f957b2fffbd99 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Mon, 10 Jun 2024 19:40:12 -0400 Subject: [PATCH 1/9] IGP26 --- contracts/payloads/IGP26/PayloadIGP26.sol | 646 ++++++++++++++++++ .../IGP26/libraries/bigMathMinified.sol | 156 +++++ .../IGP26/libraries/liquiditySlotsLink.sol | 101 +++ 3 files changed, 903 insertions(+) create mode 100644 contracts/payloads/IGP26/PayloadIGP26.sol create mode 100644 contracts/payloads/IGP26/libraries/bigMathMinified.sol create mode 100644 contracts/payloads/IGP26/libraries/liquiditySlotsLink.sol diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol new file mode 100644 index 0000000..2ad8b19 --- /dev/null +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -0,0 +1,646 @@ +pragma solidity ^0.7.0; +pragma experimental ABIEncoderV2; + +import { BigMathMinified } from "./libraries/bigMathMinified.sol"; +import { LiquiditySlotsLink } from "./libraries/liquiditySlotsLink.sol"; + +interface IGovernorBravo { + function _acceptAdmin() external; + + function _setVotingDelay(uint newVotingDelay) external; + + function _setVotingPeriod(uint newVotingPeriod) external; + + function _acceptAdminOnTimelock() external; + + function _setImplementation(address implementation_) external; + + function propose( + address[] memory targets, + uint[] memory values, + string[] memory signatures, + bytes[] memory calldatas, + string memory description + ) external returns (uint); + + function admin() external view returns (address); + + function pendingAdmin() external view returns (address); + + function timelock() external view returns (address); + + function votingDelay() external view returns (uint256); + + function votingPeriod() external view returns (uint256); +} + +interface ITimelock { + function acceptAdmin() external; + + function setDelay(uint delay_) external; + + function setPendingAdmin(address pendingAdmin_) external; + + function queueTransaction( + address target, + uint value, + string memory signature, + bytes memory data, + uint eta + ) external returns (bytes32); + + function executeTransaction( + address target, + uint value, + string memory signature, + bytes memory data, + uint eta + ) external payable returns (bytes memory); + + function pendingAdmin() external view returns (address); + + function admin() external view returns (address); + + function delay() external view returns (uint256); +} + +interface AdminModuleStructs { + struct AddressBool { + address addr; + bool value; + } + + struct AddressUint256 { + address addr; + uint256 value; + } + + struct RateDataV1Params { + address token; + uint256 kink; + uint256 rateAtUtilizationZero; + uint256 rateAtUtilizationKink; + uint256 rateAtUtilizationMax; + } + + struct RateDataV2Params { + address token; + uint256 kink1; + uint256 kink2; + uint256 rateAtUtilizationZero; + uint256 rateAtUtilizationKink1; + uint256 rateAtUtilizationKink2; + uint256 rateAtUtilizationMax; + } + + struct TokenConfig { + address token; + uint256 fee; + uint256 threshold; + uint256 maxUtilization; + } + + struct UserSupplyConfig { + address user; + address token; + uint8 mode; + uint256 expandPercent; + uint256 expandDuration; + uint256 baseWithdrawalLimit; + } + + struct UserBorrowConfig { + address user; + address token; + uint8 mode; + uint256 expandPercent; + uint256 expandDuration; + uint256 baseDebtCeiling; + uint256 maxDebtCeiling; + } +} + +interface IProxy { + function setAdmin(address newAdmin_) external; + + function setDummyImplementation(address newDummyImplementation_) external; + + function addImplementation( + address implementation_, + bytes4[] calldata sigs_ + ) external; + + function removeImplementation(address implementation_) external; + + function getAdmin() external view returns (address); + + function getDummyImplementation() external view returns (address); + + function getImplementationSigs( + address impl_ + ) external view returns (bytes4[] memory); + + function getSigsImplementation(bytes4 sig_) external view returns (address); + + function readFromStorage( + bytes32 slot_ + ) external view returns (uint256 result_); +} + +interface IFluidLiquidityAdmin { + /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract. + /// auths can be helpful in reducing governance overhead where it's not needed. + /// @param authsStatus_ array of structs setting allowed status for an address. + /// status true => add auth, false => remove auth + function updateAuths( + AdminModuleStructs.AddressBool[] calldata authsStatus_ + ) external; + + /// @notice adds/removes guardians. Only callable by Governance. + /// @param guardiansStatus_ array of structs setting allowed status for an address. + /// status true => add guardian, false => remove guardian + function updateGuardians( + AdminModuleStructs.AddressBool[] calldata guardiansStatus_ + ) external; + + /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance. + /// @param revenueCollector_ new revenue collector address + function updateRevenueCollector(address revenueCollector_) external; + + /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths. + /// @param newStatus_ new status + /// status = 2 -> pause, status = 1 -> resume. + function changeStatus(uint256 newStatus_) external; + + /// @notice update tokens rate data version 1. Only callable by Auths. + /// @param tokensRateData_ array of RateDataV1Params with rate data to set for each token + function updateRateDataV1s( + AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_ + ) external; + + /// @notice update tokens rate data version 2. Only callable by Auths. + /// @param tokensRateData_ array of RateDataV2Params with rate data to set for each token + function updateRateDataV2s( + AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_ + ) external; + + /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold. + /// Only callable by Auths. + /// @param tokenConfigs_ contains token address, fee & utilization threshold + function updateTokenConfigs( + AdminModuleStructs.TokenConfig[] calldata tokenConfigs_ + ) external; + + /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols. + /// Only callable by Auths. + /// @param userClasses_ struct array of uint256 value to assign for each user address + function updateUserClasses( + AdminModuleStructs.AddressUint256[] calldata userClasses_ + ) external; + + /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits. + /// Only callable by Auths. + /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info + function updateUserSupplyConfigs( + AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_ + ) external; + + /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits. + /// Only callable by Auths. + /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info + function updateUserBorrowConfigs( + AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_ + ) external; + + /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians). + /// Only callable by Guardians. + /// @param user_ address of user to pause operations for + /// @param supplyTokens_ token addresses to pause withdrawals for + /// @param borrowTokens_ token addresses to pause borrowings for + function pauseUser( + address user_, + address[] calldata supplyTokens_, + address[] calldata borrowTokens_ + ) external; + + /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians). + /// Only callable by Guardians. + /// @param user_ address of user to unpause operations for + /// @param supplyTokens_ token addresses to unpause withdrawals for + /// @param borrowTokens_ token addresses to unpause borrowings for + function unpauseUser( + address user_, + address[] calldata supplyTokens_, + address[] calldata borrowTokens_ + ) external; + + /// @notice collects revenue for tokens to configured revenueCollector address. + /// @param tokens_ array of tokens to collect revenue for + /// @dev Note that this can revert if token balance is < revenueAmount (utilization > 100%) + function collectRevenue(address[] calldata tokens_) external; + + /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage. + /// @param tokens_ tokens to update exchange prices for + /// @return supplyExchangePrices_ new supply rates of overall system for each token + /// @return borrowExchangePrices_ new borrow rates of overall system for each token + function updateExchangePrices( + address[] calldata tokens_ + ) + external + returns ( + uint256[] memory supplyExchangePrices_, + uint256[] memory borrowExchangePrices_ + ); +} + +interface IFluidVaultT1Factory { + /// @notice Deploys a new vault using the specified deployment logic `vaultDeploymentLogic_` and data `vaultDeploymentData_`. + /// Only accounts with deployer access or the owner can deploy a new vault. + /// @param vaultDeploymentLogic_ The address of the vault deployment logic contract. + /// @param vaultDeploymentData_ The data to be used for vault deployment. + /// @return vault_ Returns the address of the newly deployed vault. + function deployVault( + address vaultDeploymentLogic_, + bytes calldata vaultDeploymentData_ + ) external returns (address vault_); + + /// @notice Sets an address as allowed vault deployment logic (`deploymentLogic_`) contract or not. + /// This function can only be called by the owner. + /// @param deploymentLogic_ The address of the vault deployment logic contract to be set. + /// @param allowed_ A boolean indicating whether the specified address is allowed to deploy new type of vault. + function setVaultDeploymentLogic( + address deploymentLogic_, + bool allowed_ + ) external; + + + /// @notice Computes the address of a vault based on its given ID (`vaultId_`). + /// @param vaultId_ The ID of the vault. + /// @return vault_ Returns the computed address of the vault. + function getVaultAddress(uint256 vaultId_) external view returns (address vault_); +} + + +interface IFluidVaultT1 { + /// @notice updates the Vault oracle to `newOracle_`. Must implement the FluidOracle interface. + function updateOracle(address newOracle_) external; + + /// @notice updates the all Vault core settings according to input params. + /// All input values are expected in 1e2 (1% = 100, 100% = 10_000). + function updateCoreSettings( + uint256 supplyRateMagnifier_, + uint256 borrowRateMagnifier_, + uint256 collateralFactor_, + uint256 liquidationThreshold_, + uint256 liquidationMaxLimit_, + uint256 withdrawGap_, + uint256 liquidationPenalty_, + uint256 borrowFee_ + ) external; + + /// @notice updates the allowed rebalancer to `newRebalancer_`. + function updateRebalancer(address newRebalancer_) external; + + /// @notice updates the supply rate magnifier to `supplyRateMagnifier_`. Input in 1e2 (1% = 100, 100% = 10_000). + function updateSupplyRateMagnifier(uint supplyRateMagnifier_) external; + + /// @notice updates the collateral factor to `collateralFactor_`. Input in 1e2 (1% = 100, 100% = 10_000). + function updateCollateralFactor(uint collateralFactor_) external; + + struct ConstantViews { + address liquidity; + address factory; + address adminImplementation; + address secondaryImplementation; + address supplyToken; + address borrowToken; + uint8 supplyDecimals; + uint8 borrowDecimals; + uint vaultId; + bytes32 liquiditySupplyExchangePriceSlot; + bytes32 liquidityBorrowExchangePriceSlot; + bytes32 liquidityUserSupplySlot; + bytes32 liquidityUserBorrowSlot; + } + + /// @notice returns all Vault constants + function constantsView() external view returns (ConstantViews memory constantsView_); + + struct Configs { + uint16 supplyRateMagnifier; + uint16 borrowRateMagnifier; + uint16 collateralFactor; + uint16 liquidationThreshold; + uint16 liquidationMaxLimit; + uint16 withdrawalGap; + uint16 liquidationPenalty; + uint16 borrowFee; + address oracle; + uint oraclePriceOperate; + uint oraclePriceLiquidate; + address rebalancer; + } +} + +interface IFluidOracle { + /// @dev Deprecated. Use `getExchangeRateOperate()` and `getExchangeRateLiquidate()` instead. Only implemented for + /// backwards compatibility. + function getExchangeRate() external view returns (uint256 exchangeRate_); + + /// @notice Get the `exchangeRate_` between the underlying asset and the peg asset in 1e27 for operates + function getExchangeRateOperate() external view returns (uint256 exchangeRate_); + + /// @notice Get the `exchangeRate_` between the underlying asset and the peg asset in 1e27 for liquidations + function getExchangeRateLiquidate() external view returns (uint256 exchangeRate_); +} + +contract PayloadIGP26 { + uint256 public constant PROPOSAL_ID = 26; + + address public constant PROPOSER = + 0xA45f7bD6A5Ff45D31aaCE6bCD3d426D9328cea01; + + address public constant PROPOSER_AVO_MULTISIG = + 0x059A94A72951c0ae1cc1CE3BF0dB52421bbE8210; + + address public constant PROPOSER_AVO_MULTISIG_2 = + 0x9efdE135CA4832AbF0408c44c6f5f370eB0f35e8; + + IGovernorBravo public constant GOVERNOR = + IGovernorBravo(0x0204Cd037B2ec03605CFdFe482D8e257C765fA1B); + ITimelock public immutable TIMELOCK = + ITimelock(0x2386DC45AdDed673317eF068992F19421B481F4c); + + address public immutable ADDRESS_THIS; + + address public constant TEAM_MULTISIG = + 0x4F6F977aCDD1177DCD81aB83074855EcB9C2D49e; + + IFluidLiquidityAdmin public constant LIQUIDITY = + IFluidLiquidityAdmin(0x52Aa899454998Be5b000Ad077a46Bbe360F4e497); + IFluidVaultT1Factory public constant VAULT_T1_FACTORY = + IFluidVaultT1Factory(0x324c5Dc1fC42c7a4D43d92df1eBA58a54d13Bf2d); + + uint256 internal constant X14 = 0x3fff; + uint256 internal constant X18 = 0x3ffff; + uint256 internal constant X24 = 0xffffff; + uint256 internal constant X64 = 0xffffffffffffffff; + + address public constant ETH_ADDRESS = + 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public constant wstETH_ADDRESS = + 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0; + address public constant weETH_ADDRESS = + 0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee; + + address public constant sUSDe_ADDRESS = + 0x9D39A5DE30e57443BfF2A8307A4256c8797A3497; + address public constant USDC_ADDRESS = + 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + address public constant USDT_ADDRESS = + 0xdAC17F958D2ee523a2206206994597C13D831ec7; + + constructor() { + ADDRESS_THIS = address(this); + } + + function propose(string memory description) external { + require( + msg.sender == PROPOSER || + msg.sender == TEAM_MULTISIG || + address(this) == PROPOSER_AVO_MULTISIG || + address(this) == PROPOSER_AVO_MULTISIG_2, + "msg.sender-not-allowed" + ); + + uint256 totalActions = 1; + address[] memory targets = new address[](totalActions); + uint256[] memory values = new uint256[](totalActions); + string[] memory signatures = new string[](totalActions); + bytes[] memory calldatas = new bytes[](totalActions); + + // Action 1: call executePayload on timelock contract to execute payload related to Fluid + targets[0] = address(TIMELOCK); + values[0] = 0; + signatures[0] = "executePayload(address,string,bytes)"; + calldatas[0] = abi.encode(ADDRESS_THIS, "execute()", abi.encode()); + + uint256 proposedId = GOVERNOR.propose( + targets, + values, + signatures, + calldatas, + description + ); + + require(proposedId == PROPOSAL_ID, "PROPOSAL_IS_NOT_SAME"); + } + + function execute() external { + require(address(this) == address(TIMELOCK), "not-valid-caller"); + + // Action 1: Clone from old vault config to new vault + action1(); + } + + /***********************************| + | Proposal Payload Actions | + |__________________________________*/ + + /// @notice Action 1: Clone from old vault config to new vault + function action1() internal { + for (uint oldVaultId = 1; oldVaultId <= 10; oldVaultId++) { + cloneVault(oldVaultId); + } + } + + /***********************************| + | Proposal Payload Helpers | + |__________________________________*/ + + function getUserSupplyData( + address token_, + address user_ + ) internal view returns(AdminModuleStructs.UserSupplyConfig memory config_) { + bytes32 _LIQUDITY_PROTOCOL_SUPPLY_SLOT = LiquiditySlotsLink.calculateDoubleMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT, + user_, + token_ + ); + + uint256 userSupplyData_ = LIQUIDITY.readFromStorage(_LIQUDITY_PROTOCOL_SUPPLY_SLOT); + + config_ = AdminModuleStructs.UserSupplyConfig({ + user: user_, + token: token_, + mode: uint8(userSupplyData_ & 1), + expandPercent: (userSupply_ >> 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 user_, + ) internal view returns(AdminModuleStructs.UserBorrowConfig memory config_) { + bytes32 _LIQUDITY_PROTOCOL_BORROW_SLOT = LiquiditySlotsLink.calculateDoubleMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, + user_, + token_ + ); + + uint256 userBorrowData_ = LIQUIDITY.readFromStorage(_LIQUDITY_PROTOCOL_BORROW_SLOT); + + config_ = AdminModuleStructs.UserBorrowConfig({ + user: user_, + 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 + ) + }); + } + + function getAllowance(address token) internal returns (uint256, uint256) { + if (token == ETH_ADDRESS) { + return (3 * 1e18, 4 * 1e18); + } else if (token == wstETH_ADDRESS) { + return (2.33 * 1e18, 3.5 * 1e18); + } else if (token == weETH_ADDRESS) { + return (2.6 * 1e18, 3.95 * 1e18); + } else if (token == USDC_ADDRESS || token == USDT_ADDRESS) { + return (10_000 * 1e6, 15_000 * 1e6); + } else if (token == sUSDe_ADDRESS) { + return (9_200 * 1e18, 13_900 * 1e18); + } else { + revert "no allowance found"; + } + } + + function getOracleAddress(uint256 vaultId) internal returns(address) { + if (vaultId == 11) { + return 0x5b2860C6D6F888319C752aaCDaf8165C21095E3a; // VAULT_ETH_USDC + } else if (vaultId == 12) { + return 0x7eA20E1FB456AF31C6425813bFfD4Ef6E0A4C86E; // VAULT_ETH_USDT + } else if (vaultId == 13) { + return 0xadE0948e2431DEFB87e75760e94f190cbF35E95b; // VAULT_WSTETH_ETH + } else if (vaultId == 14) { + return 0xc5911Fa3917c507fBEbAb910C8b47cBdD3Ce147e; // VAULT_WSTETH_USDC + } else if (vaultId == 15) { + return 0x38aE6fa3d6376D86D1EE591364CD4b45C99adE22; // VAULT_WSTETH_USDT + } else if (vaultId == 16) { + return 0xEA0C58bE3133Cb7f035faCF45cb1d4F84CF178B4; // VAULT_WEETH_WSTETH + } else if (vaultId == 17) { + return 0x72DB9B7Bd2b0BC282708E85E16123023b32de6A9; // VAULT_SUSDE_USDC + } else if (vaultId == 18) { + return 0x72DB9B7Bd2b0BC282708E85E16123023b32de6A9; // VAULT_SUSDE_USDT + } else if (vaultId == 19) { + return 0xda8a70b9533DEBE425F8A3b2B33bc09c0415e5FE; // VAULT_WEETH_USDC + } else if (vaultId == 20) { + return 0x32eE0cB3587C6e9f8Ad2a0CF83B6Cf326848b7c6; // VAULT_WEETH_USDT + } else { + revert "no oracle address"; + } + } + + function getVaultConfig(address vault) internal view returns (IFluidVaultT1.Configs memory configs) { + uint vaultVariables2 = IFluidVaultT1(vault_).readFromStorage(bytes32(1)); + configs_.supplyRateMagnifier = uint16(vaultVariables2 & X16); + configs_.borrowRateMagnifier = uint16((vaultVariables2 >> 16) & X16); + configs_.collateralFactor = (uint16((vaultVariables2 >> 32) & X10)) * 10; + configs_.liquidationThreshold = (uint16((vaultVariables2 >> 42) & X10)) * 10; + configs_.liquidationMaxLimit = (uint16((vaultVariables2 >> 52) & X10) * 10); + configs_.withdrawalGap = uint16((vaultVariables2 >> 62) & X10) * 10; + configs_.liquidationPenalty = uint16((vaultVariables2 >> 72) & X10); + configs_.borrowFee = uint16((vaultVariables2 >> 82) & X10); + configs_.oracle = address(uint160(vaultVariables2 >> 96)); + } + + function cloneVault(uint256 oldVaultId) internal { + address oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId); + address newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId + 10); + + IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(oldVaultAddress).constantsView(); + IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(newVaultAddress).constantsView(); + + address newOracleAddress = getOracleAddress(oldVaultId + 10); + + { + 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_ = getUserSupplyData(newConstants.supplyToken, oldVaultAddress); + + (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.supplyToken); + + configs_[0].baseWithdrawalLimit = baseAllowance; + + LIQUIDITY.updateUserSupplyConfigs(configs_); + } + + // Set user borrow config for the vault on Liquidity Layer. + { + AdminModuleStructs.UserBorrowConfig[] + memory configs_ = getUserBorrowData(newConstants.borrowToken, oldVaultAddress); + + (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.borrowAllowance); + + configs_[0].baseDebtCeiling = baseAllowance; + configs_[0].maxDebtCeiling = maxAllowance; + + LIQUIDITY.updateUserBorrowConfigs(configs_); + } + + // Clone core settings from old vault to new vault. + { + IFluidVaultT1.Configs memory configs = getVaultConfig(oldVaultAddress); + + { + require( + IFluidOracle(configs.oracle).getExchangeRate() == IFluidOracle(newOracleAddress).getExchangeRate(), + "oracle exchangePrice is not same" + ) + } + + IFluidVaultT1(newVaultAddress).updateCoreSettings( + configs.supplyRateMagnifier, // supplyRateMagnifier + configs.borrowRateMagnifier, // borrowRateMagnifier + configs.collateralFactor, // collateralFactor + configs.liquidationThreshold, // liquidationThreshold + configs.liquidationMaxLimit, // liquidationMaxLimit + configs.withdrawGap, // withdrawGap + configs.liquidationPenalty, // liquidationPenalty + configs.borrowFee // borrowFee + ); + } + + // Update oracle on new vault. + { + IFluidVaultT1(vault_).updateOracle(newOracleAddress); + } + + // Update rebalancer on new vault. + { + IFluidVaultT1(vault_).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); + } + } + +} diff --git a/contracts/payloads/IGP26/libraries/bigMathMinified.sol b/contracts/payloads/IGP26/libraries/bigMathMinified.sol new file mode 100644 index 0000000..374783e --- /dev/null +++ b/contracts/payloads/IGP26/libraries/bigMathMinified.sol @@ -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) + } + } + } +} \ No newline at end of file diff --git a/contracts/payloads/IGP26/libraries/liquiditySlotsLink.sol b/contracts/payloads/IGP26/libraries/liquiditySlotsLink.sol new file mode 100644 index 0000000..afd30e2 --- /dev/null +++ b/contracts/payloads/IGP26/libraries/liquiditySlotsLink.sol @@ -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_)); + } +} From 5ba1914bd263f07aeb0a317a8c784138d23fe907 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Mon, 10 Jun 2024 19:46:35 -0400 Subject: [PATCH 2/9] IGP-26 --- contracts/payloads/IGP26/PayloadIGP26.sol | 62 ++++++++++++++--------- 1 file changed, 39 insertions(+), 23 deletions(-) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 2ad8b19..4bae2b8 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -1,4 +1,4 @@ -pragma solidity ^0.7.0; +pragma solidity >=0.7.0; pragma experimental ABIEncoderV2; import { BigMathMinified } from "./libraries/bigMathMinified.sol"; @@ -251,6 +251,8 @@ interface IFluidLiquidityAdmin { uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_ ); + + function readFromStorage(bytes32 slot_) external view returns (uint256 result_); } interface IFluidVaultT1Factory { @@ -278,6 +280,8 @@ interface IFluidVaultT1Factory { /// @param vaultId_ The ID of the vault. /// @return vault_ Returns the computed address of the vault. function getVaultAddress(uint256 vaultId_) external view returns (address vault_); + + function readFromStorage(bytes32 slot_) external view returns (uint256 result_); } @@ -326,6 +330,8 @@ interface IFluidVaultT1 { /// @notice returns all Vault constants function constantsView() external view returns (ConstantViews memory constantsView_); + function readFromStorage(bytes32 slot_) external view returns (uint256 result_); + struct Configs { uint16 supplyRateMagnifier; uint16 borrowRateMagnifier; @@ -381,11 +387,18 @@ contract PayloadIGP26 { IFluidVaultT1Factory public constant VAULT_T1_FACTORY = IFluidVaultT1Factory(0x324c5Dc1fC42c7a4D43d92df1eBA58a54d13Bf2d); + 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; + address public constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address public constant wstETH_ADDRESS = @@ -474,7 +487,7 @@ contract PayloadIGP26 { user: user_, token: token_, mode: uint8(userSupplyData_ & 1), - expandPercent: (userSupply_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14, + 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, @@ -486,7 +499,7 @@ contract PayloadIGP26 { function getUserBorrowData( address token_, - address user_, + address user_ ) internal view returns(AdminModuleStructs.UserBorrowConfig memory config_) { bytes32 _LIQUDITY_PROTOCOL_BORROW_SLOT = LiquiditySlotsLink.calculateDoubleMappingStorageSlot( LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, @@ -527,7 +540,7 @@ contract PayloadIGP26 { } else if (token == sUSDe_ADDRESS) { return (9_200 * 1e18, 13_900 * 1e18); } else { - revert "no allowance found"; + revert ("no allowance found"); } } @@ -553,21 +566,21 @@ contract PayloadIGP26 { } else if (vaultId == 20) { return 0x32eE0cB3587C6e9f8Ad2a0CF83B6Cf326848b7c6; // VAULT_WEETH_USDT } else { - revert "no oracle address"; + revert ("no oracle address"); } } function getVaultConfig(address vault) internal view returns (IFluidVaultT1.Configs memory configs) { - uint vaultVariables2 = IFluidVaultT1(vault_).readFromStorage(bytes32(1)); - configs_.supplyRateMagnifier = uint16(vaultVariables2 & X16); - configs_.borrowRateMagnifier = uint16((vaultVariables2 >> 16) & X16); - configs_.collateralFactor = (uint16((vaultVariables2 >> 32) & X10)) * 10; - configs_.liquidationThreshold = (uint16((vaultVariables2 >> 42) & X10)) * 10; - configs_.liquidationMaxLimit = (uint16((vaultVariables2 >> 52) & X10) * 10); - configs_.withdrawalGap = uint16((vaultVariables2 >> 62) & X10) * 10; - configs_.liquidationPenalty = uint16((vaultVariables2 >> 72) & X10); - configs_.borrowFee = uint16((vaultVariables2 >> 82) & X10); - configs_.oracle = address(uint160(vaultVariables2 >> 96)); + uint vaultVariables2 = IFluidVaultT1(vault).readFromStorage(bytes32(uint256(1))); + configs.supplyRateMagnifier = uint16(vaultVariables2 & X16); + configs.borrowRateMagnifier = uint16((vaultVariables2 >> 16) & X16); + configs.collateralFactor = (uint16((vaultVariables2 >> 32) & X10)) * 10; + configs.liquidationThreshold = (uint16((vaultVariables2 >> 42) & X10)) * 10; + configs.liquidationMaxLimit = (uint16((vaultVariables2 >> 52) & X10) * 10); + configs.withdrawalGap = uint16((vaultVariables2 >> 62) & X10) * 10; + configs.liquidationPenalty = uint16((vaultVariables2 >> 72) & X10); + configs.borrowFee = uint16((vaultVariables2 >> 82) & X10); + configs.oracle = address(uint160(vaultVariables2 >> 96)); } function cloneVault(uint256 oldVaultId) internal { @@ -587,9 +600,11 @@ contract PayloadIGP26 { // Set user supply config for the vault on Liquidity Layer. { AdminModuleStructs.UserSupplyConfig[] - memory configs_ = getUserSupplyData(newConstants.supplyToken, oldVaultAddress); + memory configs_ = new AdminModuleStructs.UserSupplyConfig[](1); - (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.supplyToken); + configs_[0] = getUserSupplyData(newConstants.supplyToken, oldVaultAddress); + + (uint256 baseAllowance, ) = getAllowance(newConstants.supplyToken); configs_[0].baseWithdrawalLimit = baseAllowance; @@ -599,9 +614,10 @@ contract PayloadIGP26 { // Set user borrow config for the vault on Liquidity Layer. { AdminModuleStructs.UserBorrowConfig[] - memory configs_ = getUserBorrowData(newConstants.borrowToken, oldVaultAddress); + memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); - (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.borrowAllowance); + configs_[0] = getUserBorrowData(newConstants.borrowToken, oldVaultAddress); + (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.borrowToken); configs_[0].baseDebtCeiling = baseAllowance; configs_[0].maxDebtCeiling = maxAllowance; @@ -617,7 +633,7 @@ contract PayloadIGP26 { require( IFluidOracle(configs.oracle).getExchangeRate() == IFluidOracle(newOracleAddress).getExchangeRate(), "oracle exchangePrice is not same" - ) + ); } IFluidVaultT1(newVaultAddress).updateCoreSettings( @@ -626,7 +642,7 @@ contract PayloadIGP26 { configs.collateralFactor, // collateralFactor configs.liquidationThreshold, // liquidationThreshold configs.liquidationMaxLimit, // liquidationMaxLimit - configs.withdrawGap, // withdrawGap + configs.withdrawalGap, // withdrawGap configs.liquidationPenalty, // liquidationPenalty configs.borrowFee // borrowFee ); @@ -634,12 +650,12 @@ contract PayloadIGP26 { // Update oracle on new vault. { - IFluidVaultT1(vault_).updateOracle(newOracleAddress); + IFluidVaultT1(newVaultAddress).updateOracle(newOracleAddress); } // Update rebalancer on new vault. { - IFluidVaultT1(vault_).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); + IFluidVaultT1(newVaultAddress).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); } } From 03f74fcd23009d520c4b7abb537947af95d9a1ec Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Mon, 10 Jun 2024 22:52:24 -0400 Subject: [PATCH 3/9] wip --- contracts/payloads/IGP26/PayloadIGP26.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 4bae2b8..7d62714 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -528,7 +528,7 @@ contract PayloadIGP26 { }); } - function getAllowance(address token) internal returns (uint256, uint256) { + function getAllowance(address token) internal pure returns (uint256, uint256) { if (token == ETH_ADDRESS) { return (3 * 1e18, 4 * 1e18); } else if (token == wstETH_ADDRESS) { @@ -544,7 +544,7 @@ contract PayloadIGP26 { } } - function getOracleAddress(uint256 vaultId) internal returns(address) { + function getOracleAddress(uint256 vaultId) internal pure returns(address) { if (vaultId == 11) { return 0x5b2860C6D6F888319C752aaCDaf8165C21095E3a; // VAULT_ETH_USDC } else if (vaultId == 12) { From aac53cc82c037d40998622f92c7e079335ca3bab Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Tue, 11 Jun 2024 10:43:29 -0400 Subject: [PATCH 4/9] added dust allowance --- contracts/payloads/IGP26/PayloadIGP26.sol | 47 +++++++++++++++++++---- 1 file changed, 39 insertions(+), 8 deletions(-) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 7d62714..4128054 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -528,17 +528,17 @@ contract PayloadIGP26 { }); } - function getAllowance(address token) internal pure returns (uint256, uint256) { + function getAllowance(address token) internal pure returns (uint256, uint256, ) { if (token == ETH_ADDRESS) { - return (3 * 1e18, 4 * 1e18); + return (3 * 1e18, 4 * 1e18, 0.03 * 1e18); } else if (token == wstETH_ADDRESS) { - return (2.33 * 1e18, 3.5 * 1e18); + return (2.33 * 1e18, 3.5 * 1e18, 0.03 * 1e18); } else if (token == weETH_ADDRESS) { - return (2.6 * 1e18, 3.95 * 1e18); + return (2.6 * 1e18, 3.95 * 1e18, 0.03 * 1e18); } else if (token == USDC_ADDRESS || token == USDT_ADDRESS) { - return (10_000 * 1e6, 15_000 * 1e6); + return (10_000 * 1e6, 15_000 * 1e6, 100 * 1e6); } else if (token == sUSDe_ADDRESS) { - return (9_200 * 1e18, 13_900 * 1e18); + return (9_200 * 1e18, 13_900 * 1e18, 100 * 1e18); } else { revert ("no allowance found"); } @@ -592,6 +592,8 @@ contract PayloadIGP26 { address newOracleAddress = getOracleAddress(oldVaultId + 10); + uint256[] memory amounts = new uint256[](2); + { require(oldConstants.supplyToken == newConstants.supplyToken, "not-same-supply-token"); require(oldConstants.borrowToken == newConstants.borrowToken, "not-same-borrow-token"); @@ -604,7 +606,9 @@ contract PayloadIGP26 { configs_[0] = getUserSupplyData(newConstants.supplyToken, oldVaultAddress); - (uint256 baseAllowance, ) = getAllowance(newConstants.supplyToken); + (uint256 baseAllowance, , supplyAllowance) = getAllowance(newConstants.supplyToken); + + amounts[0] = supplyAllowance; configs_[0].baseWithdrawalLimit = baseAllowance; @@ -617,7 +621,18 @@ contract PayloadIGP26 { memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); configs_[0] = getUserBorrowData(newConstants.borrowToken, oldVaultAddress); - (uint256 baseAllowance, uint256 maxAllowance) = getAllowance(newConstants.borrowToken); + (uint256 baseAllowance, uint256 maxAllowance, uint256 borrowAllowance) = getAllowance(newConstants.borrowToken); + + amounts[1] = borrowAllowance; + + uint256 exchangePriceAndConfig_ = LIQUIDITY.readFromStorage( + LiquiditySlotsLink.calculateMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT, + newConstants.borrowToken + ) + ); + + (uint256 supplyExchangePrice, uint256 borrowExchangePrice) = LiquidityCalcs.calcExchangePrices(exchangePriceAndConfig_); configs_[0].baseDebtCeiling = baseAllowance; configs_[0].maxDebtCeiling = maxAllowance; @@ -657,6 +672,22 @@ contract PayloadIGP26 { { IFluidVaultT1(newVaultAddress).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); } + + // Approve new vault to spend the reserves dust tokens + { + address[] memory protocols = new address[](2); + address[] memory tokens = new address[](2); + + { + protocols[0] = newVaultAddress; + tokens[0] = newConstants.supplyToken; + + protocols[1] = newVaultAddress; + tokens[1] = newConstants.borrowToken; + + FLUID_RESERVE.approve(protocols, tokens, amounts); + } + } } } From bcc820c992d416d0a2e9199514e4b6d49ab45e73 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Tue, 11 Jun 2024 10:59:13 -0400 Subject: [PATCH 5/9] fixes --- contracts/payloads/IGP26/PayloadIGP26.sol | 127 ++-- .../payloads/IGP26/libraries/errorTypes.sol | 27 + .../IGP26/libraries/liquidityCalcs.sol | 686 ++++++++++++++++++ 3 files changed, 794 insertions(+), 46 deletions(-) create mode 100644 contracts/payloads/IGP26/libraries/errorTypes.sol create mode 100644 contracts/payloads/IGP26/libraries/liquidityCalcs.sol diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 4128054..e3b36b3 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -3,6 +3,7 @@ pragma experimental ABIEncoderV2; import { BigMathMinified } from "./libraries/bigMathMinified.sol"; import { LiquiditySlotsLink } from "./libraries/liquiditySlotsLink.sol"; +import { LiquidityCalcs } from "./libraries/liquidityCalcs.sol"; interface IGovernorBravo { function _acceptAdmin() external; @@ -360,6 +361,33 @@ interface IFluidOracle { function getExchangeRateLiquidate() external view returns (uint256 exchangeRate_); } +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 PayloadIGP26 { uint256 public constant PROPOSAL_ID = 26; @@ -386,6 +414,8 @@ contract PayloadIGP26 { IFluidLiquidityAdmin(0x52Aa899454998Be5b000Ad077a46Bbe360F4e497); IFluidVaultT1Factory public constant VAULT_T1_FACTORY = IFluidVaultT1Factory(0x324c5Dc1fC42c7a4D43d92df1eBA58a54d13Bf2d); + IFluidReserveContract public constant FLUID_RESERVE = + IFluidReserveContract(0x264786EF916af64a1DB19F513F24a3681734ce92); uint256 internal constant X8 = 0xff; uint256 internal constant X10 = 0x3ff; @@ -471,17 +501,27 @@ contract PayloadIGP26 { | Proposal Payload Helpers | |__________________________________*/ - function getUserSupplyData( + function getUserSupplyDataAndSetLimits( address token_, - address user_ + address user_, + uint256 withdrawalLimit ) internal view returns(AdminModuleStructs.UserSupplyConfig memory config_) { - bytes32 _LIQUDITY_PROTOCOL_SUPPLY_SLOT = LiquiditySlotsLink.calculateDoubleMappingStorageSlot( - LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT, - user_, - token_ + uint256 userSupplyData_ = LIQUIDITY.readFromStorage( + LiquiditySlotsLink.calculateDoubleMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT, + user_, + token_ + ) + ); + + (uint256 supplyExchangePrice, ) = LiquidityCalcs.calcExchangePrices( + LIQUIDITY.readFromStorage( + LiquiditySlotsLink.calculateMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT, + token_ + ) + ) ); - - uint256 userSupplyData_ = LIQUIDITY.readFromStorage(_LIQUDITY_PROTOCOL_SUPPLY_SLOT); config_ = AdminModuleStructs.UserSupplyConfig({ user: user_, @@ -489,25 +529,32 @@ contract PayloadIGP26 { 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 - ) + baseWithdrawalLimit: withdrawalLimit * 1e12 / supplyExchangePrice }); } - function getUserBorrowData( + function getUserBorrowDataAndSetLimits( address token_, - address user_ + address user_, + uint256 baseLimit, + uint256 maxLimit ) internal view returns(AdminModuleStructs.UserBorrowConfig memory config_) { - bytes32 _LIQUDITY_PROTOCOL_BORROW_SLOT = LiquiditySlotsLink.calculateDoubleMappingStorageSlot( - LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, - user_, - token_ + uint256 userBorrowData_ = LIQUIDITY.readFromStorage( + LiquiditySlotsLink.calculateDoubleMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, + user_, + token_ + ) ); - uint256 userBorrowData_ = LIQUIDITY.readFromStorage(_LIQUDITY_PROTOCOL_BORROW_SLOT); + (, uint256 borrowExchangePrice) = LiquidityCalcs.calcExchangePrices( + LIQUIDITY.readFromStorage( + LiquiditySlotsLink.calculateMappingStorageSlot( + LiquiditySlotsLink.LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT, + token_ + ) + ) + ); config_ = AdminModuleStructs.UserBorrowConfig({ user: user_, @@ -515,20 +562,12 @@ contract PayloadIGP26 { 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 - ) + baseDebtCeiling: baseLimit * 1e12 / borrowExchangePrice, + maxDebtCeiling: maxLimit * 1e12 / borrowExchangePrice }); } - function getAllowance(address token) internal pure returns (uint256, uint256, ) { + function getAllowance(address token) internal pure returns (uint256, uint256, uint256) { if (token == ETH_ADDRESS) { return (3 * 1e18, 4 * 1e18, 0.03 * 1e18); } else if (token == wstETH_ADDRESS) { @@ -604,13 +643,15 @@ contract PayloadIGP26 { AdminModuleStructs.UserSupplyConfig[] memory configs_ = new AdminModuleStructs.UserSupplyConfig[](1); - configs_[0] = getUserSupplyData(newConstants.supplyToken, oldVaultAddress); - - (uint256 baseAllowance, , supplyAllowance) = getAllowance(newConstants.supplyToken); + (uint256 baseAllowance, , uint256 supplyAllowance) = getAllowance(newConstants.supplyToken); amounts[0] = supplyAllowance; - configs_[0].baseWithdrawalLimit = baseAllowance; + configs_[0] = getUserSupplyDataAndSetLimits( + newConstants.supplyToken, + oldVaultAddress, + baseAllowance + ); LIQUIDITY.updateUserSupplyConfigs(configs_); } @@ -620,23 +661,17 @@ contract PayloadIGP26 { AdminModuleStructs.UserBorrowConfig[] memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); - configs_[0] = getUserBorrowData(newConstants.borrowToken, oldVaultAddress); (uint256 baseAllowance, uint256 maxAllowance, uint256 borrowAllowance) = getAllowance(newConstants.borrowToken); amounts[1] = borrowAllowance; - uint256 exchangePriceAndConfig_ = LIQUIDITY.readFromStorage( - LiquiditySlotsLink.calculateMappingStorageSlot( - LiquiditySlotsLink.LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT, - newConstants.borrowToken - ) + configs_[0] = getUserBorrowDataAndSetLimits( + newConstants.borrowToken, + oldVaultAddress, + baseAllowance, + maxAllowance ); - (uint256 supplyExchangePrice, uint256 borrowExchangePrice) = LiquidityCalcs.calcExchangePrices(exchangePriceAndConfig_); - - configs_[0].baseDebtCeiling = baseAllowance; - configs_[0].maxDebtCeiling = maxAllowance; - LIQUIDITY.updateUserBorrowConfigs(configs_); } diff --git a/contracts/payloads/IGP26/libraries/errorTypes.sol b/contracts/payloads/IGP26/libraries/errorTypes.sol new file mode 100644 index 0000000..00cd2ec --- /dev/null +++ b/contracts/payloads/IGP26/libraries/errorTypes.sol @@ -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; +} \ No newline at end of file diff --git a/contracts/payloads/IGP26/libraries/liquidityCalcs.sol b/contracts/payloads/IGP26/libraries/liquidityCalcs.sol new file mode 100644 index 0000000..9cccdb5 --- /dev/null +++ b/contracts/payloads/IGP26/libraries/liquidityCalcs.sol @@ -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); + } +} \ No newline at end of file From 68bf94c6d88349c1cec126d35f5509a4e37052f2 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Tue, 11 Jun 2024 12:21:32 -0400 Subject: [PATCH 6/9] fix --- contracts/payloads/IGP26/PayloadIGP26.sol | 102 +++++++++++++--------- 1 file changed, 63 insertions(+), 39 deletions(-) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index e3b36b3..232a80d 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -503,13 +503,14 @@ contract PayloadIGP26 { function getUserSupplyDataAndSetLimits( address token_, - address user_, + address oldVault_, + address newVault_, uint256 withdrawalLimit ) internal view returns(AdminModuleStructs.UserSupplyConfig memory config_) { uint256 userSupplyData_ = LIQUIDITY.readFromStorage( LiquiditySlotsLink.calculateDoubleMappingStorageSlot( LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT, - user_, + oldVault_, token_ ) ); @@ -524,7 +525,7 @@ contract PayloadIGP26 { ); config_ = AdminModuleStructs.UserSupplyConfig({ - user: user_, + user: newVault_, token: token_, mode: uint8(userSupplyData_ & 1), expandPercent: (userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14, @@ -535,14 +536,15 @@ contract PayloadIGP26 { function getUserBorrowDataAndSetLimits( address token_, - address user_, + address oldVault_, + address newVault_, uint256 baseLimit, uint256 maxLimit ) internal view returns(AdminModuleStructs.UserBorrowConfig memory config_) { uint256 userBorrowData_ = LIQUIDITY.readFromStorage( LiquiditySlotsLink.calculateDoubleMappingStorageSlot( LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, - user_, + oldVault_, token_ ) ); @@ -557,7 +559,7 @@ contract PayloadIGP26 { ); config_ = AdminModuleStructs.UserBorrowConfig({ - user: user_, + user: newVault_, token: token_, mode: uint8(userBorrowData_ & 1), expandPercent: (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14, @@ -569,7 +571,7 @@ contract PayloadIGP26 { function getAllowance(address token) internal pure returns (uint256, uint256, uint256) { if (token == ETH_ADDRESS) { - return (3 * 1e18, 4 * 1e18, 0.03 * 1e18); + return (3 * 1e18, 4 * 1e18, 0); } else if (token == wstETH_ADDRESS) { return (2.33 * 1e18, 3.5 * 1e18, 0.03 * 1e18); } else if (token == weETH_ADDRESS) { @@ -622,16 +624,33 @@ contract PayloadIGP26 { configs.oracle = address(uint160(vaultVariables2 >> 96)); } + struct CloneVaultStruct { + address oldVaultAddress; + address newVaultAddress; + address newOracleAddress; + address[] protocols; + address[] tokens; + uint256[] amounts; + uint256 supplyBaseAllowance; + uint256 supplyReserveAllowance; + uint256 borrowBaseAllowance; + uint256 borrowMaxAllowance; + uint256 borrowReserveAllowance; + } + function cloneVault(uint256 oldVaultId) internal { - address oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId); - address newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId + 10); + CloneVaultStruct memory data; - IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(oldVaultAddress).constantsView(); - IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(newVaultAddress).constantsView(); + data.oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId); + data.newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId + 10); - address newOracleAddress = getOracleAddress(oldVaultId + 10); + IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(data.oldVaultAddress).constantsView(); + IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(data.newVaultAddress).constantsView(); - uint256[] memory amounts = new uint256[](2); + data.newOracleAddress = getOracleAddress(oldVaultId + 10); + + (data.supplyBaseAllowance, , data.supplyReserveAllowance) = getAllowance(newConstants.supplyToken); + (data.borrowBaseAllowance, data.borrowMaxAllowance, data.borrowReserveAllowance) = getAllowance(newConstants.borrowToken); { require(oldConstants.supplyToken == newConstants.supplyToken, "not-same-supply-token"); @@ -643,14 +662,12 @@ contract PayloadIGP26 { AdminModuleStructs.UserSupplyConfig[] memory configs_ = new AdminModuleStructs.UserSupplyConfig[](1); - (uint256 baseAllowance, , uint256 supplyAllowance) = getAllowance(newConstants.supplyToken); - - amounts[0] = supplyAllowance; configs_[0] = getUserSupplyDataAndSetLimits( newConstants.supplyToken, - oldVaultAddress, - baseAllowance + data.oldVaultAddress, + data.newVaultAddress, + data.supplyBaseAllowance ); LIQUIDITY.updateUserSupplyConfigs(configs_); @@ -661,15 +678,12 @@ contract PayloadIGP26 { AdminModuleStructs.UserBorrowConfig[] memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); - (uint256 baseAllowance, uint256 maxAllowance, uint256 borrowAllowance) = getAllowance(newConstants.borrowToken); - - amounts[1] = borrowAllowance; - configs_[0] = getUserBorrowDataAndSetLimits( newConstants.borrowToken, - oldVaultAddress, - baseAllowance, - maxAllowance + data.oldVaultAddress, + data.newVaultAddress, + data.borrowBaseAllowance, + data.borrowMaxAllowance ); LIQUIDITY.updateUserBorrowConfigs(configs_); @@ -677,16 +691,16 @@ contract PayloadIGP26 { // Clone core settings from old vault to new vault. { - IFluidVaultT1.Configs memory configs = getVaultConfig(oldVaultAddress); + IFluidVaultT1.Configs memory configs = getVaultConfig(data.oldVaultAddress); { require( - IFluidOracle(configs.oracle).getExchangeRate() == IFluidOracle(newOracleAddress).getExchangeRate(), + IFluidOracle(configs.oracle).getExchangeRate() == IFluidOracle(data.newOracleAddress).getExchangeRate(), "oracle exchangePrice is not same" ); } - IFluidVaultT1(newVaultAddress).updateCoreSettings( + IFluidVaultT1(data.newVaultAddress).updateCoreSettings( configs.supplyRateMagnifier, // supplyRateMagnifier configs.borrowRateMagnifier, // borrowRateMagnifier configs.collateralFactor, // collateralFactor @@ -700,29 +714,39 @@ contract PayloadIGP26 { // Update oracle on new vault. { - IFluidVaultT1(newVaultAddress).updateOracle(newOracleAddress); + IFluidVaultT1(data.newVaultAddress).updateOracle(data.newOracleAddress); } // Update rebalancer on new vault. { - IFluidVaultT1(newVaultAddress).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); + IFluidVaultT1(data.newVaultAddress).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); } // Approve new vault to spend the reserves dust tokens { - address[] memory protocols = new address[](2); - address[] memory tokens = new address[](2); + uint256 len = data.supplyReserveAllowance == 0 || data.borrowReserveAllowance == 0 ? 1 : 2; + uint256 i = 0; + + data.protocols = new address[](len); + data.tokens = new address[](len); + data.amounts = new uint256[](len); { - protocols[0] = newVaultAddress; - tokens[0] = newConstants.supplyToken; + if (data.supplyReserveAllowance != 0) { + data.protocols[i] = data.newVaultAddress; + data.tokens[i] = newConstants.supplyToken; + data.amounts[i] = data.supplyReserveAllowance; + i++; + } + + if (data.borrowReserveAllowance != 0) { + data.protocols[i] = data.newVaultAddress; + data.tokens[i] = newConstants.borrowToken; + data.amounts[i] = data.borrowReserveAllowance; + } - protocols[1] = newVaultAddress; - tokens[1] = newConstants.borrowToken; - - FLUID_RESERVE.approve(protocols, tokens, amounts); + FLUID_RESERVE.approve(data.protocols, data.tokens, data.amounts); } } } - } From 7e9a4c7066677fdb3589821f1d15c3abee7ae437 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Wed, 12 Jun 2024 16:39:02 -0400 Subject: [PATCH 7/9] collect revenue --- contracts/payloads/IGP26/PayloadIGP26.sol | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 232a80d..f96d3dc 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -497,6 +497,18 @@ contract PayloadIGP26 { } } + /// @notice Action 2: Collect revenue from Liquditiy Layer + function action2() internal { + address[] memory tokens = new address[](4); + + tokens[0] = ETH_ADDRESS; + tokens[1] = wstETH_ADDRESS; + tokens[2] = USDC_ADDRESS; + tokens[3] = USDT_ADDRESS; + + LIQUIDITY.collectRevenue(tokens); + } + /***********************************| | Proposal Payload Helpers | |__________________________________*/ From 9ff76a2779991b5cc3c664624524bae8496932b4 Mon Sep 17 00:00:00 2001 From: Samyak Jain <34437877+KaymasJain@users.noreply.github.com> Date: Thu, 13 Jun 2024 04:36:05 +0400 Subject: [PATCH 8/9] Better oracle check commit --- contracts/payloads/IGP26/PayloadIGP26.sol | 174 +++++++++++++++------- 1 file changed, 124 insertions(+), 50 deletions(-) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index f96d3dc..882335b 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -1,9 +1,9 @@ pragma solidity >=0.7.0; pragma experimental ABIEncoderV2; -import { BigMathMinified } from "./libraries/bigMathMinified.sol"; -import { LiquiditySlotsLink } from "./libraries/liquiditySlotsLink.sol"; -import { LiquidityCalcs } from "./libraries/liquidityCalcs.sol"; +import {BigMathMinified} from "./libraries/bigMathMinified.sol"; +import {LiquiditySlotsLink} from "./libraries/liquiditySlotsLink.sol"; +import {LiquidityCalcs} from "./libraries/liquidityCalcs.sol"; interface IGovernorBravo { function _acceptAdmin() external; @@ -252,8 +252,10 @@ interface IFluidLiquidityAdmin { uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_ ); - - function readFromStorage(bytes32 slot_) external view returns (uint256 result_); + + function readFromStorage( + bytes32 slot_ + ) external view returns (uint256 result_); } interface IFluidVaultT1Factory { @@ -276,16 +278,18 @@ interface IFluidVaultT1Factory { bool allowed_ ) external; - /// @notice Computes the address of a vault based on its given ID (`vaultId_`). /// @param vaultId_ The ID of the vault. /// @return vault_ Returns the computed address of the vault. - function getVaultAddress(uint256 vaultId_) external view returns (address vault_); + function getVaultAddress( + uint256 vaultId_ + ) external view returns (address vault_); - function readFromStorage(bytes32 slot_) external view returns (uint256 result_); + function readFromStorage( + bytes32 slot_ + ) external view returns (uint256 result_); } - interface IFluidVaultT1 { /// @notice updates the Vault oracle to `newOracle_`. Must implement the FluidOracle interface. function updateOracle(address newOracle_) external; @@ -329,9 +333,14 @@ interface IFluidVaultT1 { } /// @notice returns all Vault constants - function constantsView() external view returns (ConstantViews memory constantsView_); + function constantsView() + external + view + returns (ConstantViews memory constantsView_); - function readFromStorage(bytes32 slot_) external view returns (uint256 result_); + function readFromStorage( + bytes32 slot_ + ) external view returns (uint256 result_); struct Configs { uint16 supplyRateMagnifier; @@ -355,10 +364,16 @@ interface IFluidOracle { function getExchangeRate() external view returns (uint256 exchangeRate_); /// @notice Get the `exchangeRate_` between the underlying asset and the peg asset in 1e27 for operates - function getExchangeRateOperate() external view returns (uint256 exchangeRate_); + function getExchangeRateOperate() + external + view + returns (uint256 exchangeRate_); /// @notice Get the `exchangeRate_` between the underlying asset and the peg asset in 1e27 for liquidations - function getExchangeRateLiquidate() external view returns (uint256 exchangeRate_); + function getExchangeRateLiquidate() + external + view + returns (uint256 exchangeRate_); } interface IFluidReserveContract { @@ -518,7 +533,11 @@ contract PayloadIGP26 { address oldVault_, address newVault_, uint256 withdrawalLimit - ) internal view returns(AdminModuleStructs.UserSupplyConfig memory config_) { + ) + internal + view + returns (AdminModuleStructs.UserSupplyConfig memory config_) + { uint256 userSupplyData_ = LIQUIDITY.readFromStorage( LiquiditySlotsLink.calculateDoubleMappingStorageSlot( LiquiditySlotsLink.LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT, @@ -526,7 +545,7 @@ contract PayloadIGP26 { token_ ) ); - + (uint256 supplyExchangePrice, ) = LiquidityCalcs.calcExchangePrices( LIQUIDITY.readFromStorage( LiquiditySlotsLink.calculateMappingStorageSlot( @@ -540,9 +559,11 @@ contract PayloadIGP26 { 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: withdrawalLimit * 1e12 / supplyExchangePrice + expandPercent: (userSupplyData_ >> + LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14, + expandDuration: (userSupplyData_ >> + LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_DURATION) & X24, + baseWithdrawalLimit: (withdrawalLimit * 1e12) / supplyExchangePrice }); } @@ -552,7 +573,11 @@ contract PayloadIGP26 { address newVault_, uint256 baseLimit, uint256 maxLimit - ) internal view returns(AdminModuleStructs.UserBorrowConfig memory config_) { + ) + internal + view + returns (AdminModuleStructs.UserBorrowConfig memory config_) + { uint256 userBorrowData_ = LIQUIDITY.readFromStorage( LiquiditySlotsLink.calculateDoubleMappingStorageSlot( LiquiditySlotsLink.LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT, @@ -574,14 +599,18 @@ contract PayloadIGP26 { 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: baseLimit * 1e12 / borrowExchangePrice, - maxDebtCeiling: maxLimit * 1e12 / borrowExchangePrice + expandPercent: (userBorrowData_ >> + LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14, + expandDuration: (userBorrowData_ >> + LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_DURATION) & X24, + baseDebtCeiling: (baseLimit * 1e12) / borrowExchangePrice, + maxDebtCeiling: (maxLimit * 1e12) / borrowExchangePrice }); } - function getAllowance(address token) internal pure returns (uint256, uint256, uint256) { + function getAllowance( + address token + ) internal pure returns (uint256, uint256, uint256) { if (token == ETH_ADDRESS) { return (3 * 1e18, 4 * 1e18, 0); } else if (token == wstETH_ADDRESS) { @@ -593,11 +622,11 @@ contract PayloadIGP26 { } else if (token == sUSDe_ADDRESS) { return (9_200 * 1e18, 13_900 * 1e18, 100 * 1e18); } else { - revert ("no allowance found"); + revert("no allowance found"); } } - function getOracleAddress(uint256 vaultId) internal pure returns(address) { + function getOracleAddress(uint256 vaultId) internal pure returns (address) { if (vaultId == 11) { return 0x5b2860C6D6F888319C752aaCDaf8165C21095E3a; // VAULT_ETH_USDC } else if (vaultId == 12) { @@ -619,17 +648,24 @@ contract PayloadIGP26 { } else if (vaultId == 20) { return 0x32eE0cB3587C6e9f8Ad2a0CF83B6Cf326848b7c6; // VAULT_WEETH_USDT } else { - revert ("no oracle address"); + revert("no oracle address"); } } - function getVaultConfig(address vault) internal view returns (IFluidVaultT1.Configs memory configs) { - uint vaultVariables2 = IFluidVaultT1(vault).readFromStorage(bytes32(uint256(1))); + function getVaultConfig( + address vault + ) internal view returns (IFluidVaultT1.Configs memory configs) { + uint vaultVariables2 = IFluidVaultT1(vault).readFromStorage( + bytes32(uint256(1)) + ); configs.supplyRateMagnifier = uint16(vaultVariables2 & X16); configs.borrowRateMagnifier = uint16((vaultVariables2 >> 16) & X16); configs.collateralFactor = (uint16((vaultVariables2 >> 32) & X10)) * 10; - configs.liquidationThreshold = (uint16((vaultVariables2 >> 42) & X10)) * 10; - configs.liquidationMaxLimit = (uint16((vaultVariables2 >> 52) & X10) * 10); + configs.liquidationThreshold = + (uint16((vaultVariables2 >> 42) & X10)) * + 10; + configs.liquidationMaxLimit = (uint16((vaultVariables2 >> 52) & X10) * + 10); configs.withdrawalGap = uint16((vaultVariables2 >> 62) & X10) * 10; configs.liquidationPenalty = uint16((vaultVariables2 >> 72) & X10); configs.borrowFee = uint16((vaultVariables2 >> 82) & X10); @@ -654,27 +690,46 @@ contract PayloadIGP26 { CloneVaultStruct memory data; data.oldVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId); - data.newVaultAddress = VAULT_T1_FACTORY.getVaultAddress(oldVaultId + 10); + data.newVaultAddress = VAULT_T1_FACTORY.getVaultAddress( + oldVaultId + 10 + ); - IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1(data.oldVaultAddress).constantsView(); - IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1(data.newVaultAddress).constantsView(); + IFluidVaultT1.ConstantViews memory oldConstants = IFluidVaultT1( + data.oldVaultAddress + ).constantsView(); + IFluidVaultT1.ConstantViews memory newConstants = IFluidVaultT1( + data.newVaultAddress + ).constantsView(); data.newOracleAddress = getOracleAddress(oldVaultId + 10); - (data.supplyBaseAllowance, , data.supplyReserveAllowance) = getAllowance(newConstants.supplyToken); - (data.borrowBaseAllowance, data.borrowMaxAllowance, data.borrowReserveAllowance) = getAllowance(newConstants.borrowToken); + ( + data.supplyBaseAllowance, + , + data.supplyReserveAllowance + ) = getAllowance(newConstants.supplyToken); + ( + data.borrowBaseAllowance, + data.borrowMaxAllowance, + data.borrowReserveAllowance + ) = getAllowance(newConstants.borrowToken); { - require(oldConstants.supplyToken == newConstants.supplyToken, "not-same-supply-token"); - require(oldConstants.borrowToken == newConstants.borrowToken, "not-same-borrow-token"); + 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] = getUserSupplyDataAndSetLimits( newConstants.supplyToken, data.oldVaultAddress, @@ -688,8 +743,8 @@ contract PayloadIGP26 { // Set user borrow config for the vault on Liquidity Layer. { AdminModuleStructs.UserBorrowConfig[] - memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); - + memory configs_ = new AdminModuleStructs.UserBorrowConfig[](1); + configs_[0] = getUserBorrowDataAndSetLimits( newConstants.borrowToken, data.oldVaultAddress, @@ -703,11 +758,19 @@ contract PayloadIGP26 { // Clone core settings from old vault to new vault. { - IFluidVaultT1.Configs memory configs = getVaultConfig(data.oldVaultAddress); + IFluidVaultT1.Configs memory configs = getVaultConfig( + data.oldVaultAddress + ); { require( - IFluidOracle(configs.oracle).getExchangeRate() == IFluidOracle(data.newOracleAddress).getExchangeRate(), + (IFluidOracle(configs.oracle).getExchangeRate() == + IFluidOracle(data.newOracleAddress) + .getExchangeRateOperate()) && + (IFluidOracle(data.newOracleAddress) + .getExchangeRateOperate() == + IFluidOracle(data.newOracleAddress) + .getExchangeRateLiquidate()), "oracle exchangePrice is not same" ); } @@ -726,38 +789,49 @@ contract PayloadIGP26 { // Update oracle on new vault. { - IFluidVaultT1(data.newVaultAddress).updateOracle(data.newOracleAddress); + IFluidVaultT1(data.newVaultAddress).updateOracle( + data.newOracleAddress + ); } // Update rebalancer on new vault. { - IFluidVaultT1(data.newVaultAddress).updateRebalancer(0x264786EF916af64a1DB19F513F24a3681734ce92); + IFluidVaultT1(data.newVaultAddress).updateRebalancer( + 0x264786EF916af64a1DB19F513F24a3681734ce92 + ); } // Approve new vault to spend the reserves dust tokens { - uint256 len = data.supplyReserveAllowance == 0 || data.borrowReserveAllowance == 0 ? 1 : 2; + uint256 len = data.supplyReserveAllowance == 0 || + data.borrowReserveAllowance == 0 + ? 1 + : 2; uint256 i = 0; data.protocols = new address[](len); data.tokens = new address[](len); data.amounts = new uint256[](len); - { + { if (data.supplyReserveAllowance != 0) { data.protocols[i] = data.newVaultAddress; data.tokens[i] = newConstants.supplyToken; data.amounts[i] = data.supplyReserveAllowance; i++; } - + if (data.borrowReserveAllowance != 0) { data.protocols[i] = data.newVaultAddress; data.tokens[i] = newConstants.borrowToken; data.amounts[i] = data.borrowReserveAllowance; } - FLUID_RESERVE.approve(data.protocols, data.tokens, data.amounts); + FLUID_RESERVE.approve( + data.protocols, + data.tokens, + data.amounts + ); } } } From 945b0605643b6c39ecd9c3d7f86d96618c002d78 Mon Sep 17 00:00:00 2001 From: Thrilok kumar Date: Sat, 15 Jun 2024 00:02:33 -0400 Subject: [PATCH 9/9] fix --- contracts/payloads/IGP26/PayloadIGP26.sol | 3 +++ 1 file changed, 3 insertions(+) diff --git a/contracts/payloads/IGP26/PayloadIGP26.sol b/contracts/payloads/IGP26/PayloadIGP26.sol index 882335b..e0b69fb 100644 --- a/contracts/payloads/IGP26/PayloadIGP26.sol +++ b/contracts/payloads/IGP26/PayloadIGP26.sol @@ -499,6 +499,9 @@ contract PayloadIGP26 { // Action 1: Clone from old vault config to new vault action1(); + + // Action 2: Collect revenue from Liquditiy Layer + action2(); } /***********************************|