Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 47 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Close Credit Acc... | 19263656 | 191 days ago | IN | 0 ETH | 0.0181999 | ||||
Close Credit Acc... | 19228910 | 196 days ago | IN | 0 ETH | 0.01292737 | ||||
Liquidate Credit... | 19182579 | 202 days ago | IN | 0 ETH | 0.03608349 | ||||
Close Credit Acc... | 18967725 | 232 days ago | IN | 0 ETH | 0.00445749 | ||||
Multicall | 18967718 | 232 days ago | IN | 0 ETH | 0.00589525 | ||||
Close Credit Acc... | 18962717 | 233 days ago | IN | 0 ETH | 0.0114963 | ||||
Close Credit Acc... | 18958432 | 234 days ago | IN | 0 ETH | 0.01632967 | ||||
Close Credit Acc... | 18958418 | 234 days ago | IN | 0 ETH | 0.02136389 | ||||
Close Credit Acc... | 18952472 | 234 days ago | IN | 0 ETH | 0.00631562 | ||||
Multicall | 18952465 | 234 days ago | IN | 0 ETH | 0.00858506 | ||||
Close Credit Acc... | 18944072 | 236 days ago | IN | 0 ETH | 0.0179004 | ||||
Close Credit Acc... | 18848660 | 249 days ago | IN | 0 ETH | 0.01045054 | ||||
Close Credit Acc... | 18848611 | 249 days ago | IN | 0 ETH | 0.00996135 | ||||
Close Credit Acc... | 18843687 | 250 days ago | IN | 0 ETH | 0.0133423 | ||||
Close Credit Acc... | 18833268 | 251 days ago | IN | 0 ETH | 0.02419248 | ||||
Close Credit Acc... | 18825047 | 252 days ago | IN | 0 ETH | 0.01721201 | ||||
Close Credit Acc... | 18814011 | 254 days ago | IN | 0 ETH | 0.03995323 | ||||
Multicall | 18812669 | 254 days ago | IN | 0 ETH | 0.00926024 | ||||
Multicall | 18812659 | 254 days ago | IN | 0 ETH | 0.01049762 | ||||
Close Credit Acc... | 18775753 | 259 days ago | IN | 0 ETH | 0.00961607 | ||||
Multicall | 18775750 | 259 days ago | IN | 0 ETH | 0.01326524 | ||||
Multicall | 18769295 | 260 days ago | IN | 0 ETH | 0.00797525 | ||||
Multicall | 18769292 | 260 days ago | IN | 0 ETH | 0.01025775 | ||||
Close Credit Acc... | 18767599 | 260 days ago | IN | 0 ETH | 0.01231065 | ||||
Multicall | 18753121 | 262 days ago | IN | 0 ETH | 0.00658146 |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x5BcB06c5...ca3F5a2f4 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
CreditFacade
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 2000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { Address } from "@openzeppelin/contracts/utils/Address.sol"; import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol"; // DATA import { MultiCall } from "../libraries/MultiCall.sol"; import { Balance } from "../libraries/Balances.sol"; /// INTERFACES import { ICreditFacade, ICreditFacadeExtended } from "../interfaces/ICreditFacade.sol"; import { ICreditManagerV2, ClosureAction } from "../interfaces/ICreditManagerV2.sol"; import { IPriceOracleV2 } from "../interfaces/IPriceOracle.sol"; import { IDegenNFT } from "../interfaces/IDegenNFT.sol"; import { IWETH } from "../interfaces/external/IWETH.sol"; import { IBlacklistHelper } from "../interfaces/IBlacklistHelper.sol"; import { IPausable } from "../interfaces/IPausable.sol"; // CONSTANTS import { LEVERAGE_DECIMALS } from "../libraries/Constants.sol"; import { PERCENTAGE_FACTOR } from "../libraries/PercentageMath.sol"; // EXCEPTIONS import { ZeroAddressException } from "../interfaces/IErrors.sol"; struct Params { /// @dev Maximal amount of new debt that can be taken per block uint128 maxBorrowedAmountPerBlock; /// @dev True if increasing debt is forbidden bool isIncreaseDebtForbidden; /// @dev Timestamp of the next expiration (for expirable Credit Facades only) uint40 expirationDate; /// @dev Liquidation discount applied to totalValue for emergency liquidator uint16 emergencyLiquidationDiscount; } struct Limits { /// @dev Minimal borrowed amount per credit account uint128 minBorrowedAmount; /// @dev Maximum borrowed amount per credit account uint128 maxBorrowedAmount; } struct CumulativeLossParams { /// @dev Current cumulative loss from all bad debt liquidations uint128 currentCumulativeLoss; /// @dev Max cumulative loss accrued before the system is paused uint128 maxCumulativeLoss; } struct TotalDebt { /// @dev Current total borrowing uint128 currentTotalDebt; /// @dev Total borrowing limit uint128 totalDebtLimit; } /// @title CreditFacade /// @notice User interface for interacting with Credit Manager /// @dev Direct interaction with the Credit Manager is forbidden, but Credit Facade provides all the needed /// account management functions: open / close / liquidate / addCollateral / manageDebt / multicall. /// The latter allows to perform multiple actions within a single transaction, followed by a single /// collateral check in the end. contract CreditFacade is ICreditFacade, ReentrancyGuard { using EnumerableSet for EnumerableSet.AddressSet; using Address for address; using SafeCast for uint256; /// @dev Credit Manager connected to this Credit Facade ICreditManagerV2 public immutable creditManager; /// @dev Whether the whitelisted mode is active bool public immutable whitelisted; /// @dev Whether the Credit Manager's underlying has blacklisting bool public immutable isBlacklistableUnderlying; /// @dev Whether the Credit Facade implements expirable logic bool public immutable expirable; /// @dev Keeps frequently accessed parameters for storage access optimization Params public override params; /// @dev Keeps borrowing limits together for storage access optimization Limits public override limits; /// @dev Keeps parameters that are used to pause the system after too much bad debt over a short period CumulativeLossParams public override lossParams; TotalDebt public override totalDebt; /// @dev Address of the underlying token address public immutable underlying; /// @dev A map that stores whether a user allows a transfer of an account from another user to themselves mapping(address => mapping(address => bool)) public override transfersAllowed; /// @dev Address of WETH address public immutable wethAddress; /// @dev Address of the DegenNFT that gatekeeps account openings in whitelisted mode address public immutable override degenNFT; /// @dev Address of the BlacklistHelper if underlying is blacklistable, otherwise address(0) address public immutable override blacklistHelper; /// @dev Address of the pool connected to the Credit Manager address public immutable pool; /// @dev Stores in a compressed state the last block where borrowing happened and the total amount borrowed in that block uint256 internal totalBorrowedInBlock; /// @dev Contract version uint256 public constant override version = 2_20; /// @dev Restricts actions for users with opened credit accounts only modifier creditConfiguratorOnly() { if (msg.sender != creditManager.creditConfigurator()) revert CreditConfiguratorOnlyException(); _; } /// @dev Initializes creditFacade and connects it with CreditManager /// @param _creditManager address of Credit Manager /// @param _degenNFT address of the DegenNFT or address(0) if whitelisted mode is not used /// @param _blacklistHelper address of the funds recovery contract for blacklistable underlyings. /// Must be address(0) is the underlying is not blacklistable /// @param _expirable Whether the CreditFacade can expire and implements expiration-related logic constructor( address _creditManager, address _degenNFT, address _blacklistHelper, bool _expirable ) { // Additional check that _creditManager is not address(0) if (_creditManager == address(0)) revert ZeroAddressException(); // F:[FA-1] creditManager = ICreditManagerV2(_creditManager); // F:[FA-1A] underlying = ICreditManagerV2(_creditManager).underlying(); // F:[FA-1A] wethAddress = ICreditManagerV2(_creditManager).wethAddress(); // F:[FA-1A] pool = ICreditManagerV2(_creditManager).pool(); degenNFT = _degenNFT; // F:[FA-1A] whitelisted = _degenNFT != address(0); // F:[FA-1A] blacklistHelper = _blacklistHelper; isBlacklistableUnderlying = _blacklistHelper != address(0); if (_blacklistHelper != address(0)) { emit BlacklistHelperSet(_blacklistHelper); } expirable = _expirable; totalDebt.totalDebtLimit = type(uint128).max; } // Notice: ETH interactions // CreditFacade implements a new flow for interacting with WETH compared to V1. // During all actions, any sent ETH value is automatically wrapped into WETH and // sent back to the message sender. This makes the protocol's behavior regarding // ETH more flexible and consistent, since there is no need to pre-wrap WETH before // interacting with the protocol, and no need to compute how much unused ETH has to be sent back. /// @dev Opens credit account, borrows funds from the pool and pulls collateral /// without any additional action. /// - Performs sanity checks to determine whether opening an account is allowed /// - Wraps ETH to WETH and sends it msg. sender is value > 0 /// - Requests CreditManager to open a Credit Account with a specified borrowed amount /// - Transfers collateral in the underlying asset from the user /// - Emits OpenCreditAccount event /// /// More info: https://dev.gearbox.fi/developers/credit/credit_manager#open-credit-account /// /// @param amount The amount of collateral provided by the borrower /// @param onBehalfOf The address to open an account for. Transfers to it have to be allowed if /// msg.sender != obBehalfOf /// @param leverageFactor Percentage of the user's own funds to borrow. 100 is equal to 100% - borrows the same amount /// as the user's own collateral, equivalent to 2x leverage. /// @param referralCode Referral code that is used for potential rewards. 0 if no referral code provided. function openCreditAccount( uint256 amount, address onBehalfOf, uint16 leverageFactor, uint16 referralCode ) external payable override nonReentrant { uint256 borrowedAmount = (amount * leverageFactor) / LEVERAGE_DECIMALS; // F:[FA-5] // Checks whether the new borrowed amount does not violate the block limit _checkAndUpdateBorrowedBlockLimit(borrowedAmount); // F:[FA-11A] // Checks that the borrowed amount is within the borrowing limits _revertIfOutOfBorrowedLimits(borrowedAmount); // F:[FA-11B] // Checks that the msg.sender can open an account for onBehalfOf _revertIfOpenCreditAccountNotAllowed(onBehalfOf); // F:[FA-4A, 4B, 57] // Wraps ETH and sends it back to msg.sender _wrapETH(); // F:[FA-3A] // Checks that the total debt limit is not exceeded and increases total debt _checkAndUpdateTotalDebt(borrowedAmount, true); // F: [FA-11C] // Gets the LT of the underlying (, uint256 ltu) = creditManager.collateralTokens(0); // F:[FA-6] // In order for the account to pass the health check after opening, // the inequality "(amount + borrowedAmount) * LTU > borrowedAmount" must hold // this can be transformed into "amount * LTU > borrowedAmount * (1 - LTU)" if (amount * ltu <= borrowedAmount * (PERCENTAGE_FACTOR - ltu)) revert NotEnoughCollateralException(); // F:[FA-6] // Opens credit accnount and borrows funds from the pool // Returns the new credit account's address address creditAccount = creditManager.openCreditAccount( borrowedAmount, onBehalfOf ); // F:[FA-5] // Emits openCreditAccount event before adding collateral, so that order of events is correct emit OpenCreditAccount( onBehalfOf, creditAccount, borrowedAmount, referralCode ); // F:[FA-5] // Transfers collateral from the user to the new Credit Account addCollateral(onBehalfOf, creditAccount, underlying, amount); // F:[FA-5] } /// @dev Opens a Credit Account and runs a batch of operations in a multicall /// - Opens credit account with the desired borrowed amount /// - Executes all operations in a multicall /// - Checks that the new account has enough collateral /// - Emits OpenCreditAccount event /// /// @param borrowedAmount Debt size /// @param onBehalfOf The address to open an account for. Transfers to it have to be allowed if /// msg.sender != onBehalfOf /// @param calls The array of MultiCall structs encoding the required operations. Generally must have /// at least a call to addCollateral, as otherwise the health check at the end will fail. /// @param referralCode Referral code which is used for potential rewards. 0 if no referral code provided function openCreditAccountMulticall( uint256 borrowedAmount, address onBehalfOf, MultiCall[] calldata calls, uint16 referralCode ) external payable override nonReentrant { // Checks whether the new borrowed amount does not violate the block limit _checkAndUpdateBorrowedBlockLimit(borrowedAmount); // F:[FA-11] // Checks that the msg.sender can open an account for onBehalfOf _revertIfOpenCreditAccountNotAllowed(onBehalfOf); // F:[FA-4A, 4B, 57] // Checks that the borrowed amount is within the borrowing limits _revertIfOutOfBorrowedLimits(borrowedAmount); // F:[FA-11B] // Wraps ETH and sends it back to msg.sender address _wrapETH(); // F:[FA-3B] // Checks that the total debt limit is not exceeded and increases total debt _checkAndUpdateTotalDebt(borrowedAmount, true); // F: [FA-11C] // Requests the Credit Manager to open a Credit Account address creditAccount = creditManager.openCreditAccount( borrowedAmount, onBehalfOf ); // F:[FA-8] // emits a new event emit OpenCreditAccount( onBehalfOf, creditAccount, borrowedAmount, referralCode ); // F:[FA-8] // F:[FA-10]: no free flashloans through opening a Credit Account // and immediately decreasing debt if (calls.length != 0) _multicall(calls, onBehalfOf, creditAccount, false, true); // F:[FA-8] // Checks that the new credit account has enough collateral to cover the debt creditManager.fullCollateralCheck(creditAccount); // F:[FA-8, 9] } /// @dev A version of `closeCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function closeCreditAccount( address to, uint256 skipTokenMask, bool, MultiCall[] calldata calls ) external payable override nonReentrant { _closeCreditAccount(to, skipTokenMask, calls); } /// @dev Runs a batch of transactions within a multicall and closes the account /// - Wraps ETH to WETH and sends it msg.sender if value > 0 /// - Executes the multicall - the main purpose of a multicall when closing is to convert all assets to underlying /// in order to pay the debt. /// - Closes credit account: /// + Checks the underlying balance: if it is greater than the amount paid to the pool, transfers the underlying /// from the Credit Account and proceeds. If not, tries to transfer the shortfall from msg.sender. /// + Transfers all enabled assets with non-zero balances to the "to" address, unless they are marked /// to be skipped in skipTokenMask /// - Emits a CloseCreditAccount event /// /// @param to Address to send funds to during account closing /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before closing the account. function closeCreditAccount( address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable override nonReentrant { _closeCreditAccount(to, skipTokenMask, calls); } /// @dev IMPLEMENTATION: closeCreditAccount function _closeCreditAccount( address to, uint256 skipTokenMask, MultiCall[] calldata calls ) internal { // Check for existing CA address creditAccount = creditManager.getCreditAccountOrRevert( msg.sender ); // F:[FA-2] // Wraps ETH and sends it back to msg.sender _wrapETH(); // F:[FA-3C] // [FA-13]: Calls to CreditFacade are forbidden during closure if (calls.length != 0) _multicall(calls, msg.sender, creditAccount, true, false); // F:[FA-2, 12, 13] uint256 availableLiquidityBefore = _getAvailableLiquidity(); ( uint256 borrowedAmount, uint256 borrowAmountWithInterest, ) = creditManager.calcCreditAccountAccruedInterest(creditAccount); // Requests the Credit manager to close the Credit Account creditManager.closeCreditAccount( msg.sender, ClosureAction.CLOSE_ACCOUNT, 0, msg.sender, to, skipTokenMask, false ); // F:[FA-2, 12] uint256 availableLiquidityAfter = _getAvailableLiquidity(); if ( availableLiquidityAfter < availableLiquidityBefore + borrowAmountWithInterest ) { revert LiquiditySanityCheckException(); } // Decreases the total debt _checkAndUpdateTotalDebt(borrowedAmount, false); // Emits a CloseCreditAccount event emit CloseCreditAccount(msg.sender, to); // F:[FA-12] } /// @dev Runs a batch of transactions within a multicall and liquidates the account /// - Computes the total value and checks that hf < 1. An account can't be liquidated when hf >= 1. /// Total value has to be computed before the multicall, otherwise the liquidator would be able /// to manipulate it. /// - Wraps ETH to WETH and sends it to msg.sender (liquidator) if value > 0 /// - Executes the multicall - the main purpose of a multicall when liquidating is to convert all assets to underlying /// in order to pay the debt. /// - Liquidate credit account: /// + Computes the amount that needs to be paid to the pool. If totalValue * liquidationDiscount < borrow + interest + fees, /// only totalValue * liquidationDiscount has to be paid. Since liquidationDiscount < 1, the liquidator can take /// totalValue * (1 - liquidationDiscount) as premium. Also computes the remaining funds to be sent to borrower /// as totalValue * liquidationDiscount - amountToPool. /// + If borrower happens to be blacklisted in the underlying asset, sends funds to the blacklist helper /// and marks them as claimable by the borrower. /// + Checks the underlying balance: if it is greater than amountToPool + remainingFunds, transfers the underlying /// from the Credit Account and proceeds. If not, tries to transfer the shortfall from the liquidator. /// + Transfers all enabled assets with non-zero balances to the "to" address, unless they are marked /// to be skipped in skipTokenMask. If the liquidator is confident that all assets were converted /// during the multicall, they can set the mask to uint256.max - 1, to only transfer the underlying /// - Emits LiquidateCreditAccount event /// /// @param to Address to send funds to after liquidation /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before liquidating the account. function liquidateCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable override nonReentrant { _liquidateCreditAccount(borrower, to, skipTokenMask, calls); } /// @dev A version of `liquidateCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function liquidateCreditAccount( address borrower, address to, uint256 skipTokenMask, bool, MultiCall[] calldata calls ) external payable override nonReentrant { _liquidateCreditAccount(borrower, to, skipTokenMask, calls); } /// @dev IMPLEMENTATION: liquidateCreditAccount function _liquidateCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) internal { // Checks that the CA exists to revert early for late liquidations and save gas address creditAccount = creditManager.getCreditAccountOrRevert( borrower ); // F:[FA-2] // Checks that the to address is not zero if (to == address(0)) revert ZeroAddressException(); // F:[FA-16A] // Checks that the account hf < 1 and computes the totalValue // before the multicall (bool isLiquidatable, uint256 totalValue) = _isAccountLiquidatable( creditAccount ); // F:[FA-14] // An account can't be liquidated if hf >= 1 if (!isLiquidatable) revert CantLiquidateWithSuchHealthFactorException(); // F:[FA-14] // Wraps ETH and sends it back to msg.sender _wrapETH(); // F:[FA-3D] // Checks if the liquidation is done while the contract is paused bool emergencyLiquidation = _checkIfEmergencyLiquidator(true); if (calls.length != 0) _multicall(calls, borrower, creditAccount, true, false); // F:[FA-15] if (emergencyLiquidation) { totalValue = (totalValue * params.emergencyLiquidationDiscount) / PERCENTAGE_FACTOR; _checkIfEmergencyLiquidator(false); } uint256 remainingFunds = _closeLiquidatedAccount( totalValue, creditAccount, borrower, to, skipTokenMask, false ); emit LiquidateCreditAccount(borrower, msg.sender, to, remainingFunds); // F:[FA-15] } /// @dev Runs a batch of transactions within a multicall and liquidates the account when /// this Credit Facade is expired /// The general flow of liquidation is nearly the same as normal liquidations, with two main differences: /// - An account can be liquidated on an expired Credit Facade even with hf > 1. However, /// no accounts can be liquidated through this function if the Credit Facade is not expired. /// - Liquidation premiums and fees for liquidating expired accounts are reduced. /// It is still possible to normally liquidate an underwater Credit Account, even when the Credit Facade /// is expired. /// @param to Address to send funds to after liquidation /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before liquidating the account. /// @notice See more at https://dev.gearbox.fi/docs/documentation/credit/liquidation#liquidating-accounts-by-expiration function liquidateExpiredCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable override nonReentrant { _liquidateExpiredCreditAccount(borrower, to, skipTokenMask, calls); } /// @dev A version of `liquidateExpiredCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function liquidateExpiredCreditAccount( address borrower, address to, uint256 skipTokenMask, bool, MultiCall[] calldata calls ) external payable override nonReentrant { _liquidateExpiredCreditAccount(borrower, to, skipTokenMask, calls); } /// @dev IMPLEMENTATION: liquidateExpiredCreditAccount function _liquidateExpiredCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) internal { // Checks that the CA exists to revert early for late liquidations and save gas address creditAccount = creditManager.getCreditAccountOrRevert( borrower ); // Checks that the to address is not zero if (to == address(0)) revert ZeroAddressException(); // Checks that this Credit Facade is expired and reverts if not if (!_isExpired()) { revert CantLiquidateNonExpiredException(); // F: [FA-47,48] } // Calculates the total value of an account (uint256 totalValue, ) = calcTotalValue(creditAccount); // Wraps ETH and sends it back to msg.sender address _wrapETH(); // Checks if the liquidation is done while the contract is paused bool emergencyLiquidation = _checkIfEmergencyLiquidator(true); if (calls.length != 0) _multicall(calls, borrower, creditAccount, true, false); // F:[FA-49] if (emergencyLiquidation) { totalValue = (totalValue * params.emergencyLiquidationDiscount) / PERCENTAGE_FACTOR; _checkIfEmergencyLiquidator(false); } uint256 remainingFunds = _closeLiquidatedAccount( totalValue, creditAccount, borrower, to, skipTokenMask, true ); // Emits event emit LiquidateExpiredCreditAccount( borrower, msg.sender, to, remainingFunds ); // F:[FA-49] } /// @dev Closes a liquidated credit account, possibly expired function _closeLiquidatedAccount( uint256 totalValue, address creditAccount, address borrower, address to, uint256 skipTokenMask, bool expired ) internal returns (uint256 remainingFunds) { uint256 helperBalance = _isBlacklisted(borrower); // If the borrower is blacklisted, transfer the account to a special recovery contract, // so that the attempt to transfer remaining funds to a blacklisted borrower does not // break the liquidation. The borrower can retrieve the funds from the recovery contract afterwards. if (helperBalance > 0) { creditManager.transferAccountOwnership(borrower, blacklistHelper); // F:[FA-56] } uint256 availableLiquidityBefore = _getAvailableLiquidity(); ( uint256 borrowedAmount, uint256 borrowAmountWithInterest, ) = creditManager.calcCreditAccountAccruedInterest(creditAccount); // Liquidates the CA and sends the remaining funds to the borrower or blacklist helper remainingFunds = creditManager.closeCreditAccount( helperBalance > 0 ? blacklistHelper : borrower, expired ? ClosureAction.LIQUIDATE_EXPIRED_ACCOUNT : ClosureAction.LIQUIDATE_ACCOUNT, totalValue, msg.sender, to, skipTokenMask, false ); // F:[FA-15,49] uint256 availableLiquidityAfter = _getAvailableLiquidity(); uint256 loss = availableLiquidityAfter < availableLiquidityBefore + borrowAmountWithInterest ? availableLiquidityBefore + borrowAmountWithInterest - availableLiquidityAfter : 0; if (loss > 0) { params.isIncreaseDebtForbidden = true; // F: [FA-15A] lossParams.currentCumulativeLoss += loss.toUint128(); if ( lossParams.currentCumulativeLoss > lossParams.maxCumulativeLoss ) { _pauseCreditManager(); // F: [FA-15B] } emit IncurLossOnLiquidation(loss); } // Decreases the total debt _checkAndUpdateTotalDebt(borrowedAmount, false); /// Credit Facade increases borrower's claimable balance in BlacklistHelper, so the /// borrower can recover funds to a different address if (helperBalance > 0 && remainingFunds > 1) { _increaseClaimableBalance(borrower, helperBalance); } } /// @dev Checks whether borrower is blacklisted in the underlying token and, if so, /// returns non-zero value equal to blacklist helper's balance of underlying // Zero return value always indicates that borrower is not blacklisted function _isBlacklisted(address borrower) internal view returns (uint256 helperBalance) { if ( isBlacklistableUnderlying && IBlacklistHelper(blacklistHelper).isBlacklisted( underlying, borrower ) // F:[FA-56] ) { // can't realistically overflow unchecked { helperBalance = IERC20(underlying).balanceOf(blacklistHelper) + 1; } } } /// @dev Checks if blacklist helper's balance of underlying increased after liquidation /// and, if so, increases the borrower's claimable balance by the difference /// Not relying on `remainingFunds` to support fee-on-transfer tokens function _increaseClaimableBalance( address borrower, uint256 helperBalanceBefore ) internal { uint256 helperBalance = IERC20(underlying).balanceOf(blacklistHelper); if (helperBalance > helperBalanceBefore) { uint256 amount; unchecked { amount = helperBalance - helperBalanceBefore + 1; } IBlacklistHelper(blacklistHelper).addClaimable( underlying, borrower, amount ); // F:[FA-56] emit UnderlyingSentToBlacklistHelper(borrower, amount); // F:[FA-56] } } /// @dev Increases debt for a Credit Account /// @param borrower Owner of the account /// @param creditAccount CA to increase debt for /// @param amount Amount to borrow function _increaseDebt( address borrower, address creditAccount, uint256 amount ) internal { // It is forbidden to take new debt if increaseDebtForbidden mode is enabled if (params.isIncreaseDebtForbidden) { revert IncreaseDebtForbiddenException(); } // F:[FA-18C] // Checks that the borrowed amount does not violate the per block limit _checkAndUpdateBorrowedBlockLimit(amount); // F:[FA-18A] // Checks that there are no forbidden tokens, as borrowing // is prohibited when forbidden tokens are enabled on the account _checkForbiddenTokens(creditAccount); // Checks that the total debt limit is not exceeded and increases total debt _checkAndUpdateTotalDebt(amount, true); // F: [FA-11C] // Requests the Credit Manager to borrow additional funds from the pool uint256 newBorrowedAmount = creditManager.manageDebt( creditAccount, amount, true ); // F:[FA-17] // Checks that the new total borrowed amount is within bounds _revertIfOutOfBorrowedLimits(newBorrowedAmount); // F:[FA-18B] // Emits event emit IncreaseBorrowedAmount(borrower, amount); // F:[FA-17] } /// @dev Checks that there are no intersections between the user's enabled tokens /// and the set of forbidden tokens /// @notice The main purpose of forbidding tokens is to prevent exposing /// pool funds to dangerous or exploited collateral, without immediately /// liquidating accounts that hold the forbidden token /// There are two ways pool funds can be exposed: /// - The CA owner tries to swap borrowed funds to the forbidden asset: /// this will be blocked by checkAndEnableToken, which is invoked for tokenOut /// after every operation; /// - The CA owner with an already enabled forbidden token transfers it /// to the account - they can't use addCollateral / enableToken due to checkAndEnableToken, /// but can transfer the token directly when it is enabled and it will be counted in the collateral - /// an borrows against it. This check is used to prevent this. /// If the owner has a forbidden token and want to take more debt, they must first /// dispose of the token and disable it. function _checkForbiddenTokens(address creditAccount) internal view { uint256 enabledTokenMask = creditManager.enabledTokensMap( creditAccount ); uint256 forbiddenTokenMask = creditManager.forbiddenTokenMask(); if (enabledTokenMask & forbiddenTokenMask > 0) { revert ActionProhibitedWithForbiddenTokensException(); } } /// @dev Decreases debt for a Credit Account /// @param borrower Owner of the account /// @param creditAccount Account to decrease debt for /// @param amount Amount to repay function _decreaseDebt( address borrower, address creditAccount, uint256 amount ) internal { (uint256 borrowedAmountBefore, , ) = creditManager .calcCreditAccountAccruedInterest(creditAccount); // Requests the creditManager to reduce the borrowed sum by amount uint256 newBorrowedAmount = creditManager.manageDebt( creditAccount, amount, false ); // F:[FA-19] // Checks that the new borrowed amount is within limits _revertIfOutOfBorrowedLimits(newBorrowedAmount); // F:[FA-20] // Decreases total debt // Since part of the amount can be used to repay interest, // we need to compute the difference between the old and new borrowed amount _checkAndUpdateTotalDebt( borrowedAmountBefore - newBorrowedAmount, false ); // Emits an event emit DecreaseBorrowedAmount(borrower, amount); // F:[FA-19] } /// @dev Adds collateral to borrower's credit account /// @param onBehalfOf Address of the borrower whose account is funded /// @param token Address of a collateral token /// @param amount Amount to add function addCollateral( address onBehalfOf, address token, uint256 amount ) external payable override nonReentrant { // Wraps ETH and sends it back to msg.sender _wrapETH(); // F:[FA-3E] // Checks that onBehalfOf has an account address creditAccount = creditManager.getCreditAccountOrRevert( onBehalfOf ); // F:[FA-2] addCollateral(onBehalfOf, creditAccount, token, amount); // Since this action can enable new tokens, Credit Manager // needs to check that the max enabled token limit is not // breached creditManager.checkAndOptimizeEnabledTokens(creditAccount); // F: [FA-21C] } function addCollateral( address onBehalfOf, address creditAccount, address token, uint256 amount ) internal { // Checks that msg.sender can transfer funds to onBehalfOf's account // This is done to prevent malicious actors sending bad collateral // to users // mgs.sender can only add collateral if transfer are approved // from itself to onBehalfOf _revertIfActionOnAccountNotAllowed(onBehalfOf); // F: [FA-21A] // Requests Credit Manager to transfer collateral to the Credit Account creditManager.addCollateral(msg.sender, creditAccount, token, amount); // F:[FA-21] // Emits event emit AddCollateral(onBehalfOf, token, amount); // F:[FA-21] } /// @dev Executes a batch of transactions within a Multicall, to manage an existing account /// - Wraps ETH and sends it back to msg.sender, if value > 0 /// - Executes the Multicall /// - Performs a fullCollateralCheck to verify that hf > 1 after all actions /// @param calls The array of MultiCall structs encoding the operations to execute. function multicall(MultiCall[] calldata calls) external payable override nonReentrant { // Checks that msg.sender has an account address creditAccount = creditManager.getCreditAccountOrRevert( msg.sender ); // Wraps ETH and sends it back to msg.sender _wrapETH(); // F:[FA-3F] if (calls.length != 0) { _multicall(calls, msg.sender, creditAccount, false, false); // Performs a fullCollateralCheck // During a multicall, all intermediary health checks are skipped, // as one fullCollateralCheck at the end is sufficient creditManager.fullCollateralCheck(creditAccount); } } /// @dev IMPLEMENTATION: multicall /// - Transfers ownership from borrower to this contract, as most adapter and Credit Manager functions retrieve /// the Credit Account by msg.sender /// - Executes the provided list of calls: /// + if targetContract == address(this), parses call data in the struct and calls the appropriate function (see _processCreditFacadeMulticall below) /// + if targetContract == adapter, calls the adapter with call data as provided. /// @param borrower Owner of the Credit Account /// @param creditAccount Credit Account address /// @param isClosure Whether the multicall is being invoked during a closure action. Calls to Credit Facade are forbidden inside /// multicalls on closure. /// @param increaseDebtWasCalled True if debt was increased before or during the multicall. Used to prevent free flashloans by /// increasing and decreasing debt within a single multicall. function _multicall( MultiCall[] calldata calls, address borrower, address creditAccount, bool isClosure, bool increaseDebtWasCalled ) internal { // Takes ownership of the Credit Account creditManager.transferAccountOwnership(borrower, address(this)); // F:[FA-26] // Emits event for multicall start - used in analytics to track actions within multicalls emit MultiCallStarted(borrower); // F:[FA-26] // Declares the expectedBalances array, which can later be used for slippage control Balance[] memory expectedBalances; uint256 len = calls.length; // F:[FA-26] for (uint256 i = 0; i < len; ) { MultiCall calldata mcall = calls[i]; // F:[FA-26] // Reverts of calldata has less than 4 bytes if (mcall.callData.length < 4) revert IncorrectCallDataException(); // F:[FA-22] if (mcall.target == address(this)) { // No internal calls on closure except slippage control, to avoid loss manipulation if (isClosure) { bytes4 method = bytes4(mcall.callData); if ( method != ICreditFacadeExtended.revertIfReceivedLessThan.selector ) revert ForbiddenDuringClosureException(); // F:[FA-13] } // // CREDIT FACADE // // increaseDebtWasCalled and expectedBalances are parameters that persist throughout multicall, // therefore they are passed to the internal function processor, which returns updated values ( increaseDebtWasCalled, expectedBalances ) = _processCreditFacadeMulticall( borrower, creditAccount, mcall.callData, increaseDebtWasCalled, expectedBalances ); } else { // // ADAPTERS // // Checks that the target is an allowed adapter and not CreditManager // As CreditFacade has powerful permissions in CreditManagers, // functionCall to it is strictly forbidden, even if // the Configurator adds it as an adapter if ( creditManager.adapterToContract(mcall.target) == address(0) || mcall.target == address(creditManager) ) revert TargetContractNotAllowedException(); // F:[FA-24] // Makes a call mcall.target.functionCall(mcall.callData); // F:[FA-29] } unchecked { ++i; } } // If expectedBalances was set by calling revertIfGetLessThan, // checks that actual token balances are not less than expected balances if (expectedBalances.length != 0) _compareBalances(expectedBalances, creditAccount); // Emits event for multicall end - used in analytics to track actions within multicalls emit MultiCallFinished(); // F:[FA-27,27,29] // Returns ownership back to the borrower creditManager.transferAccountOwnership(address(this), borrower); // F:[FA-27,27,29] } /// @dev Internal function for processing calls to Credit Facade within the multicall /// @param borrower Original owner of the Credit Account /// @param creditAccount Credit Account address /// @param callData Call data of the currently processed call /// @param increaseDebtWasCalledBefore Whether debt was increased before entering the function /// @param expectedBalances Array of expected balances before entering the function function _processCreditFacadeMulticall( address borrower, address creditAccount, bytes calldata callData, bool increaseDebtWasCalledBefore, Balance[] memory expectedBalancesBefore ) internal returns (bool increaseDebtWasCalled, Balance[] memory expectedBalances) { increaseDebtWasCalled = increaseDebtWasCalledBefore; expectedBalances = expectedBalancesBefore; bytes4 method = bytes4(callData); // // REVERT_IF_GET_LESS_THAN // // This is an extension function that instructs CreditFacade to check token balances at the end // Used to control slippage after the entire sequence of operations, since tracking slippage // On each operation is not ideal if (method == ICreditFacadeExtended.revertIfReceivedLessThan.selector) { // Method can only be called once since the provided Balance array // contains deltas that are added to the current balances // Calling this function again could potentially override old values // and cause confusion, especially if called later in the MultiCall if (expectedBalances.length != 0) revert ExpectedBalancesAlreadySetException(); // F:[FA-45A] // Retrieves the balance list from calldata expectedBalances = abi.decode(callData[4:], (Balance[])); // F:[FA-45] // Sets expected balances to currentBalance + delta expectedBalances = _storeBalances(expectedBalances, creditAccount); // F:[FA-45] } // // ADD COLLATERAL // else if (method == ICreditFacadeExtended.addCollateral.selector) { // Parses parameters from calldata (address token, uint256 amount) = abi.decode( callData[4:], (address, uint256) ); // F:[FA-26, 27] // In case onBehalfOf isn't the owner of the currently processed account, // retrieves onBehalfOf's account addCollateral(msg.sender, creditAccount, token, amount); // F:[FA-26, 27] } // // INCREASE DEBT // else if (method == ICreditFacadeExtended.increaseDebt.selector) { // Sets increaseDebtWasCalled to prevent debt reductions afterwards, // as that could be used to get free flash loans increaseDebtWasCalled = true; // F:[FA-28] // Parses parameters from calldata uint256 amount = abi.decode(callData[4:], (uint256)); // F:[FA-26] _increaseDebt(borrower, creditAccount, amount); // F:[FA-26] } // // DECREASE DEBT // else if (method == ICreditFacadeExtended.decreaseDebt.selector) { // it's forbidden to call decreaseDebt after increaseDebt, in the same multicall if (increaseDebtWasCalled) revert IncreaseAndDecreaseForbiddenInOneCallException(); // F:[FA-28] // Parses parameters from calldata uint256 amount = abi.decode(callData[4:], (uint256)); // F:[FA-27] _decreaseDebt(borrower, creditAccount, amount); // F:[FA-27] } // // ENABLE TOKEN // else if (method == ICreditFacadeExtended.enableToken.selector) { // Parses token address token = abi.decode(callData[4:], (address)); // F: [FA-53] // Executes enableToken for creditAccount _enableToken(borrower, creditAccount, token); // F: [FA-53] } // // DISABLE TOKEN // // This is an extenstion method used to disable tokens on a Credit Account // Can be used to remove troublesome tokens (e.g., forbidden tokens) from an account else if (method == ICreditFacadeExtended.disableToken.selector) { // Parses token address token = abi.decode(callData[4:], (address)); // F: [FA-54] // Executes disableToken for creditAccount _disableToken(borrower, creditAccount, token); // F: [FA-54] } else { // Reverts if the passed selector is unrecognized revert UnknownMethodException(); // F:[FA-23] } } /// @dev Adds expected deltas to current balances on a Credit account and returns the result /// @param expected Expected changes to existing balances /// @param creditAccount Credit Account to compute balances for function _storeBalances(Balance[] memory expected, address creditAccount) internal view returns (Balance[] memory) { uint256 len = expected.length; // F:[FA-45] for (uint256 i = 0; i < len; ) { expected[i].balance += IERC20(expected[i].token).balanceOf( creditAccount ); // F:[FA-45] unchecked { ++i; } } return expected; // F:[FA-45] } /// @dev Compares current balances to previously saved expected balances. /// Reverts if at least one balance is lower than expected /// @param expected Expected balances after all operations /// @param creditAccount Credit Account to check function _compareBalances(Balance[] memory expected, address creditAccount) internal view { uint256 len = expected.length; // F:[FA-45] for (uint256 i = 0; i < len; ) { if ( IERC20(expected[i].token).balanceOf(creditAccount) < expected[i].balance ) revert BalanceLessThanMinimumDesiredException(expected[i].token); // F:[FA-45] unchecked { ++i; } } } /// @dev Transfers credit account to another user /// By default, this action is forbidden, and the user has to approve transfers from sender to itself /// by calling approveAccountTransfer. /// This is done to prevent malicious actors from transferring compromised accounts to other users. /// @param to Address to transfer the account to function transferAccountOwnership(address to) external override nonReentrant { // In whitelisted mode only select addresses can have Credit Accounts // So this action is prohibited if (whitelisted) revert NotAllowedInWhitelistedMode(); // F:[FA-32] address creditAccount = creditManager.getCreditAccountOrRevert( msg.sender ); // F:[FA-2] // Checks that transfer is allowed if (!transfersAllowed[msg.sender][to]) revert AccountTransferNotAllowedException(); // F:[FA-33] /// Checks that the account hf > 1, as it is forbidden to transfer /// accounts that are liquidatable (bool isLiquidatable, ) = _isAccountLiquidatable(creditAccount); // F:[FA-34] if (isLiquidatable) revert CantTransferLiquidatableAccountException(); // F:[FA-34] // Requests the Credit Manager to transfer the account creditManager.transferAccountOwnership(msg.sender, to); // F:[FA-35] // Emits event emit TransferAccount(msg.sender, to); // F:[FA-35] } /// @dev Verifies that the msg.sender can open an account for onBehalfOf /// - For expirable Credit Facade, expiration date must not be reached /// - For whitelisted mode, msg.sender must open the account for themselves /// and have at least one DegenNFT to burn /// - Otherwise, checks that account transfers from msg.sender to onBehalfOf /// are approved /// @param onBehalfOf Account which would own credit account function _revertIfOpenCreditAccountNotAllowed(address onBehalfOf) internal { // Opening new Credit Accounts is prohibited in increaseDebtForbidden mode if (params.isIncreaseDebtForbidden) revert IncreaseDebtForbiddenException(); // F:[FA-7] // Checks that this CreditFacade is not expired if (_isExpired()) { revert OpenAccountNotAllowedAfterExpirationException(); // F: [FA-46] } // Checks that the borrower is not blacklisted, if the underlying is blacklistable if (_isBlacklisted(onBehalfOf) != 0) { revert NotAllowedForBlacklistedAddressException(); // F:[FA-57] } // F:[FA-5] covers case when degenNFT == address(0) if (degenNFT != address(0)) { // F:[FA-4B] // In whitelisted mode, users can only open an account by burning a DegenNFT // And opening an account for another address is forbidden if (whitelisted && msg.sender != onBehalfOf) revert NotAllowedInWhitelistedMode(); // F:[FA-4B] IDegenNFT(degenNFT).burn(onBehalfOf, 1); // F:[FA-4B] } _revertIfActionOnAccountNotAllowed(onBehalfOf); } /// @dev Checks if the message sender is allowed to do an action on a CA /// @param onBehalfOf The account which owns the target CA function _revertIfActionOnAccountNotAllowed(address onBehalfOf) internal view { // msg.sender must either be the account owner themselves, // or be approved for transfers if ( msg.sender != onBehalfOf && !transfersAllowed[msg.sender][onBehalfOf] ) revert AccountTransferNotAllowedException(); // F:[FA-04C] } /// @dev Checks that the per-block borrow limit was not violated and updates the /// amount borrowed in current block function _checkAndUpdateBorrowedBlockLimit(uint256 amount) internal { // Skipped in whitelisted mode, since there is a strict limit on the number // of credit accounts that can be opened, which implies a limit on borrowing if (!whitelisted) { uint256 _limitPerBlock = params.maxBorrowedAmountPerBlock; // F:[FA-18] // If the limit is unit128.max, the check is disabled // F:[FA-36] test case when _limitPerBlock == type(uint128).max if (_limitPerBlock != type(uint128).max) { ( uint64 lastBlock, uint128 lastLimit ) = getTotalBorrowedInBlock(); // F:[FA-18, 37] uint256 newLimit = (lastBlock == block.number) ? amount + lastLimit // F:[FA-37] : amount; // F:[FA-18, 37] if (newLimit > _limitPerBlock) revert BorrowedBlockLimitException(); // F:[FA-18] _updateTotalBorrowedInBlock(newLimit.toUint128()); // F:[FA-37] } } } /// @dev Checks that the borrowed principal is within borrowing limits /// @param borrowedAmount The current principal of a Credit Account function _revertIfOutOfBorrowedLimits(uint256 borrowedAmount) internal view { // Checks that amount is in limits if ( borrowedAmount < uint256(limits.minBorrowedAmount) || borrowedAmount > uint256(limits.maxBorrowedAmount) ) revert BorrowAmountOutOfLimitsException(); // F: } function _checkIfEmergencyLiquidator(bool state) internal returns (bool) { return creditManager.checkEmergencyPausable(msg.sender, state); } /// @dev Updates total debt and checks that it does not exceed the limit function _checkAndUpdateTotalDebt(uint256 delta, bool isIncrease) internal { if (delta > 0) { TotalDebt memory td = totalDebt; if (isIncrease) { td.currentTotalDebt += delta.toUint128(); if (td.currentTotalDebt > td.totalDebtLimit) { revert BorrowAmountOutOfLimitsException(); } } else { td.currentTotalDebt -= delta.toUint128(); } totalDebt = td; } } /// @dev Returns the last block where debt was taken, /// and the total amount borrowed in that block function getTotalBorrowedInBlock() public view returns (uint64 blockLastUpdate, uint128 borrowedInBlock) { blockLastUpdate = uint64(totalBorrowedInBlock >> 128); // F:[FA-37] borrowedInBlock = uint128(totalBorrowedInBlock & type(uint128).max); // F:[FA-37] } /// @dev Saves the total amount borrowed in the current block for future checks /// @param borrowedInBlock Updated total borrowed amount function _updateTotalBorrowedInBlock(uint128 borrowedInBlock) internal { totalBorrowedInBlock = uint256(block.number << 128) | borrowedInBlock; // F:[FA-37] } /// @dev Approves account transfer from another user to msg.sender /// @param from Address for which account transfers are allowed/forbidden /// @param state True is transfer is allowed, false if forbidden function approveAccountTransfer(address from, bool state) external override nonReentrant { transfersAllowed[from][msg.sender] = state; // F:[FA-38] // Emits event emit TransferAccountAllowed(from, msg.sender, state); // F:[FA-38] } /// @dev Enables token in enabledTokenMask for a Credit Account /// @param creditAccount Account for which the token is enabled /// @param token Collateral token to enabled function _enableToken( address borrower, address creditAccount, address token ) internal { // Will revert if the token is not known or forbidden, // If the token is disabled, adds the respective bit to the mask, otherwise does nothing creditManager.checkAndEnableToken(creditAccount, token); // F:[FA-39] // Emits event emit TokenEnabled(borrower, token); } /// @dev Disable a token for a Credit Account /// @param borrower Owner of the account /// @param token Token to disable function _disableToken( address borrower, address creditAccount, address token ) internal { // If the token is enabled, removes a respective bit from the mask, // otherwise does nothing if (creditManager.disableToken(creditAccount, token)) { // Emits event emit TokenDisabled(borrower, token); } // F: [FA-54] } /// @dev Pauses the Credit Manager function _pauseCreditManager() internal { IPausable(address(creditManager)).pause(); } // // GETTERS // /// @dev Returns true if token is a collateral token and is not forbidden, /// otherwise returns false /// @param token Token to check function isTokenAllowed(address token) public view override returns (bool allowed) { uint256 tokenMask = creditManager.tokenMasksMap(token); // F:[FA-40] allowed = (tokenMask != 0) && (creditManager.forbiddenTokenMask() & tokenMask == 0); // F:[FA-40] } /// @dev Calculates total value for provided Credit Account in underlying /// More: https://dev.gearbox.fi/developers/credit/economy#totalUSD-value /// /// @param creditAccount Credit Account address /// @return total Total value in underlying /// @return twv Total weighted (discounted by liquidation thresholds) value in underlying function calcTotalValue(address creditAccount) public view override returns (uint256 total, uint256 twv) { IPriceOracleV2 priceOracle = IPriceOracleV2( creditManager.priceOracle() ); // F:[FA-41] (uint256 totalUSD, uint256 twvUSD) = _calcTotalValueUSD( priceOracle, creditAccount ); total = priceOracle.convertFromUSD(totalUSD, underlying); // F:[FA-41] twv = priceOracle.convertFromUSD(twvUSD, underlying) / PERCENTAGE_FACTOR; // F:[FA-41] } /// @dev Calculates total value for provided Credit Account in USD /// @param priceOracle Oracle used to convert assets to USD /// @param creditAccount Address of the Credit Account /// @return totalUSD Total value of the account in USD /// @return twvUSD Total weighted (discounted by liquidation thresholds) value in USD function _calcTotalValueUSD( IPriceOracleV2 priceOracle, address creditAccount ) internal view returns (uint256 totalUSD, uint256 twvUSD) { uint256 tokenMask = 1; uint256 enabledTokensMask = creditManager.enabledTokensMap( creditAccount ); // F:[FA-41] while (tokenMask <= enabledTokensMask) { if (enabledTokensMask & tokenMask != 0) { (address token, uint16 liquidationThreshold) = creditManager .collateralTokensByMask(tokenMask); uint256 balance = IERC20(token).balanceOf(creditAccount); // F:[FA-41] if (balance > 1) { uint256 value = priceOracle.convertToUSD(balance, token); // F:[FA-41] unchecked { totalUSD += value; // F:[FA-41] } twvUSD += value * liquidationThreshold; // F:[FA-41] } } // T:[FA-41] tokenMask = tokenMask << 1; // F:[FA-41] } } /** * @dev Calculates health factor for the credit account * * sum(asset[i] * liquidation threshold[i]) * Hf = -------------------------------------------- * borrowed amount + interest accrued + fees * * * More info: https://dev.gearbox.fi/developers/credit/economy#health-factor * * @param creditAccount Credit account address * @return hf = Health factor in bp (see PERCENTAGE FACTOR in PercentageMath.sol) */ function calcCreditAccountHealthFactor(address creditAccount) public view override returns (uint256 hf) { (, uint256 twv) = calcTotalValue(creditAccount); // F:[FA-42] (, , uint256 borrowAmountWithInterestAndFees) = creditManager .calcCreditAccountAccruedInterest(creditAccount); // F:[FA-42] hf = (twv * PERCENTAGE_FACTOR) / borrowAmountWithInterestAndFees; // F:[FA-42] } /// @dev Returns true if the borrower has an open Credit Account /// @param borrower Borrower address function hasOpenedCreditAccount(address borrower) public view override returns (bool) { return creditManager.creditAccounts(borrower) != address(0); // F:[FA-43] } /// @dev Wraps ETH into WETH and sends it back to msg.sender function _wrapETH() internal { if (msg.value > 0) { IWETH(wethAddress).deposit{ value: msg.value }(); // F:[FA-3] IWETH(wethAddress).transfer(msg.sender, msg.value); // F:[FA-3] } } /// @dev Checks if account is liquidatable (i.e., hf < 1) /// @param creditAccount Address of credit account to check /// @return isLiquidatable True if account can be liquidated /// @return totalValue Total value of the Credit Account in underlying function _isAccountLiquidatable(address creditAccount) internal view returns (bool isLiquidatable, uint256 totalValue) { IPriceOracleV2 priceOracle = IPriceOracleV2( creditManager.priceOracle() ); // F:[FA-14] (uint256 totalUSD, uint256 twvUSD) = _calcTotalValueUSD( priceOracle, creditAccount ); // Computes total value in underlying totalValue = priceOracle.convertFromUSD(totalUSD, underlying); // F:[FA-14] (, , uint256 borrowAmountWithInterestAndFees) = creditManager .calcCreditAccountAccruedInterest(creditAccount); // F:[FA-14] // borrowAmountPlusInterestRateUSD x 10000 to be compared with USD values multiplied by LTs uint256 borrowAmountPlusInterestRateUSD = priceOracle.convertToUSD( borrowAmountWithInterestAndFees, underlying ) * PERCENTAGE_FACTOR; // Checks that current Hf < 1 isLiquidatable = twvUSD < borrowAmountPlusInterestRateUSD; } /// @dev Returns whether the Credit Facade is expired function _isExpired() internal view returns (bool isExpired) { isExpired = (expirable) && (block.timestamp >= params.expirationDate); // F: [FA-46,47,48] } /// @dev Returns the current available liquidity of the pool function _getAvailableLiquidity() internal view returns (uint256) { return IERC20(underlying).balanceOf(pool); } // // CONFIGURATION // /// @dev Sets the increaseDebtForbidden mode /// @notice increaseDebtForbidden can be used to secure pool funds /// without pausing the entire system. E.g., if a bug is reported /// that can potentially lead to loss of funds, but there is no /// immediate threat, new borrowing can be stopped, while other /// functionality (trading, closing/liquidating accounts) is retained function setIncreaseDebtForbidden(bool _mode) external creditConfiguratorOnly // F:[FA-44] { params.isIncreaseDebtForbidden = _mode; } /// @dev Sets borrowing limit per single block /// @notice Borrowing limit per block in conjunction with /// the monitoring system serves to minimize loss from hacks /// While an attacker would be able to steal, in worst case, /// up to (limitPerBlock * n blocks) of funds, the monitoring /// system would pause the contracts after detecting suspicious /// activity function setLimitPerBlock(uint128 newLimit) external creditConfiguratorOnly // F:[FA-44] { params.maxBorrowedAmountPerBlock = newLimit; } /// @dev Sets the total debt limit and the current total debt value (used for Credit Facade migration) function setTotalDebtParams(uint128 newCurrentTotalDebt, uint128 newLimit) external creditConfiguratorOnly { totalDebt.currentTotalDebt = newCurrentTotalDebt; totalDebt.totalDebtLimit = newLimit; } /// @dev Sets Credit Facade expiration date /// @notice See more at https://dev.gearbox.fi/docs/documentation/credit/liquidation#liquidating-accounts-by-expiration function setExpirationDate(uint40 newExpirationDate) external creditConfiguratorOnly { if (!expirable) { revert NotAllowedWhenNotExpirableException(); } params.expirationDate = newExpirationDate; } /// @dev Sets borrowing limits per single Credit Account /// @param _minBorrowedAmount The minimal borrowed amount per Credit Account. Minimal amount can be relevant /// for liquidations, since very small amounts will make liquidations unprofitable for liquidators /// @param _maxBorrowedAmount The maximal borrowed amount per Credit Account. Used to limit exposure per a single /// credit account - especially relevant in whitelisted mode. function setCreditAccountLimits( uint128 _minBorrowedAmount, uint128 _maxBorrowedAmount ) external creditConfiguratorOnly { limits.minBorrowedAmount = _minBorrowedAmount; // F: limits.maxBorrowedAmount = _maxBorrowedAmount; // F: } /// @dev Sets the max cumulative loss that can be accrued before pausing the Credit Manager function setMaxCumulativeLoss(uint128 _maxCumulativeLoss) external creditConfiguratorOnly { lossParams.maxCumulativeLoss = _maxCumulativeLoss; } /// @dev Resets the current cumulative loss value function resetCumulativeLoss() external creditConfiguratorOnly { lossParams.currentCumulativeLoss = 0; } /// @dev Sets the new emergency liquidation discount value function setEmergencyLiquidationDiscount(uint16 newDiscount) external creditConfiguratorOnly { params.emergencyLiquidationDiscount = newDiscount; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.4; interface IWETH { /// @dev Deposits native ETH into the contract and mints WETH function deposit() external payable; /// @dev Transfers WETH to another account function transfer(address to, uint256 value) external returns (bool); /// @dev Burns WETH from msg.sender and send back native ETH function withdraw(uint256) external; }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { IVersion } from "./IVersion.sol"; interface IBlacklistHelperEvents { /// @dev Emitted when a borrower's claimable balance is increased event ClaimableAdded( address indexed underlying, address indexed holder, uint256 amount ); /// @dev Emitted when a borrower claims their tokens event Claimed( address indexed underlying, address indexed holder, address to, uint256 amount ); /// @dev Emitted when a Credit Facade is added to BlacklistHelper event CreditFacadeAdded(address indexed creditFacade); /// @dev Emitted when a Credit Facade is removed from BlacklistHelper event CreditFacadeRemoved(address indexed creditFacade); } interface IBlacklistHelperExceptions { /// @dev Thrown when an access-restricted function is called by non-CreditFacade error CreditFacadeOnlyException(); /// @dev Thrown when attempting to add a Credit Facade that has non-blacklistable underlying error CreditFacadeNonBlacklistable(); /// @dev Thrown when attempting to claim funds without having anything claimable error NothingToClaimException(); } interface IBlacklistHelper is IBlacklistHelperEvents, IBlacklistHelperExceptions, IVersion { /// @dev Returns whether the account is blacklisted for a particular underlying /// @param underlying Underlying token to check /// @param account Account to check function isBlacklisted(address underlying, address account) external view returns (bool); /// @dev Transfers the sender's claimable balance of underlying to the specified address /// @param underlying Underlying to transfer /// @param to Recipient address function claim(address underlying, address to) external; /// @dev Increases the underlying balance available to claim by the account /// @param underlying Underlying to increase claimable for /// @param holder Account to increase claimable for /// @param amount Amount to increase claimable claimable for function addClaimable( address underlying, address holder, uint256 amount ) external; /// @dev Returns the amount claimable by an account /// @param underlying Underlying to get the amount for /// @param holder Acccount to get the amount for function claimable(address underlying, address holder) external view returns (uint256); }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { Balance } from "../libraries/Balances.sol"; import { MultiCall } from "../libraries/MultiCall.sol"; import { ICreditManagerV2, ICreditManagerV2Exceptions } from "./ICreditManagerV2.sol"; import { IVersion } from "./IVersion.sol"; interface ICreditFacadeExtended { /// @dev Stores expected balances (computed as current balance + passed delta) /// and compare with actual balances at the end of a multicall, reverts /// if at least one is less than expected /// @param expected Array of expected balance changes /// @notice This is an extenstion function that does not exist in the Credit Facade /// itself and can only be used within a multicall function revertIfReceivedLessThan(Balance[] memory expected) external; /// @dev Enables token in enabledTokenMask for the Credit Account of msg.sender /// @param token Address of token to enable function enableToken(address token) external; /// @dev Disables a token on the caller's Credit Account /// @param token Token to disable /// @notice This is an extenstion function that does not exist in the Credit Facade /// itself and can only be used within a multicall function disableToken(address token) external; /// @dev Adds collateral to borrower's credit account /// @param token Address of a collateral token /// @param amount Amount to add function addCollateral(address token, uint256 amount) external payable; /// @dev Increases debt for msg.sender's Credit Account /// - Borrows the requested amount from the pool /// - Updates the CA's borrowAmount / cumulativeIndexOpen /// to correctly compute interest going forward /// - Performs a full collateral check /// /// @param amount Amount to borrow function increaseDebt(uint256 amount) external; /// @dev Decrease debt /// - Decreases the debt by paying the requested amount + accrued interest + fees back to the pool /// - It's also include to this payment interest accrued at the moment and fees /// - Updates cunulativeIndex to cumulativeIndex now /// /// @param amount Amount to increase borrowed amount function decreaseDebt(uint256 amount) external; } interface ICreditFacadeEvents { /// @dev Emits when Blacklist Helper is set for the Credit Facade upon creation event BlacklistHelperSet(address indexed blacklistHelper); /// @dev Emits when a new Credit Account is opened through the /// Credit Facade event OpenCreditAccount( address indexed onBehalfOf, address indexed creditAccount, uint256 borrowAmount, uint16 referralCode ); /// @dev Emits when the account owner closes their CA normally event CloseCreditAccount(address indexed borrower, address indexed to); /// @dev Emits when a Credit Account is liquidated due to low health factor event LiquidateCreditAccount( address indexed borrower, address indexed liquidator, address indexed to, uint256 remainingFunds ); /// @dev Emits when a Credit Account is liquidated due to expiry event LiquidateExpiredCreditAccount( address indexed borrower, address indexed liquidator, address indexed to, uint256 remainingFunds ); /// @dev Emits when remaining funds in underlying currency are sent to /// the blacklist helper upon blacklisted borrower liquidation event UnderlyingSentToBlacklistHelper( address indexed borrower, uint256 amount ); /// @dev Emits when the account owner increases CA's debt event IncreaseBorrowedAmount(address indexed borrower, uint256 amount); /// @dev Emits when the account owner reduces CA's debt event DecreaseBorrowedAmount(address indexed borrower, uint256 amount); /// @dev Emits when the account owner add new collateral to a CA event AddCollateral( address indexed onBehalfOf, address indexed token, uint256 value ); /// @dev Emits when a multicall is started event MultiCallStarted(address indexed borrower); /// @dev Emits when a multicall is finished event MultiCallFinished(); /// @dev Emits when Credit Account ownership is transferred event TransferAccount(address indexed oldOwner, address indexed newOwner); /// @dev Emits when the user changes approval for account transfers to itself from another address event TransferAccountAllowed( address indexed from, address indexed to, bool state ); /// @dev Emits when the account owner enables a token on their CA event TokenEnabled(address indexed borrower, address indexed token); /// @dev Emits when the account owner disables a token on their CA event TokenDisabled(address indexed borrower, address indexed token); /// @dev Emits when pool incurs loss on account liquidation and facade forbids borrowing event IncurLossOnLiquidation(uint256 loss); } interface ICreditFacadeExceptions is ICreditManagerV2Exceptions { /// @dev Thrown if the CreditFacade is not expirable, and an aciton is attempted that /// requires expirability error NotAllowedWhenNotExpirableException(); /// @dev Thrown if whitelisted mode is enabled, and an action is attempted that is /// not allowed in whitelisted mode error NotAllowedInWhitelistedMode(); /// @dev Thrown if a user attempts to transfer a CA to an address that didn't allow it error AccountTransferNotAllowedException(); /// @dev Thrown if a liquidator tries to liquidate an account with a health factor above 1 error CantLiquidateWithSuchHealthFactorException(); /// @dev Thrown if a liquidator tries to liquidate an account by expiry while a Credit Facade is not expired error CantLiquidateNonExpiredException(); /// @dev Thrown if call data passed to a multicall is too short error IncorrectCallDataException(); /// @dev Thrown inside account closure multicall if the borrower attempts an action that is forbidden on closing /// an account error ForbiddenDuringClosureException(); /// @dev Thrown if debt increase and decrease are subsequently attempted in one multicall error IncreaseAndDecreaseForbiddenInOneCallException(); /// @dev Thrown if a selector that doesn't match any allowed function is passed to the Credit Facade /// during a multicall error UnknownMethodException(); /// @dev Thrown if a user tries to open an account or increase debt with increaseDebtForbidden mode on error IncreaseDebtForbiddenException(); /// @dev Thrown if the account owner tries to transfer an unhealthy account error CantTransferLiquidatableAccountException(); /// @dev Thrown if too much new debt was taken within a single block error BorrowedBlockLimitException(); /// @dev Thrown if the new debt principal for a CA falls outside of borrowing limits error BorrowAmountOutOfLimitsException(); /// @dev Thrown if one of the balances on a Credit Account is less than expected /// at the end of a multicall, if revertIfReceivedLessThan was called error BalanceLessThanMinimumDesiredException(address); /// @dev Thrown if a user attempts to open an account on a Credit Facade that has expired error OpenAccountNotAllowedAfterExpirationException(); /// @dev Thrown if expected balances are attempted to be set through revertIfReceivedLessThan twice error ExpectedBalancesAlreadySetException(); /// @dev Thrown if a Credit Account has enabled forbidden tokens and the owner attempts to perform an action /// that is not allowed with any forbidden tokens enabled error ActionProhibitedWithForbiddenTokensException(); /// @dev Thrown when attempting to perform an action on behalf of a borrower /// that is blacklisted in the underlying token error NotAllowedForBlacklistedAddressException(); /// @dev Thrown when the pool receives less funds than borrowAmountWithInterest on account closure error LiquiditySanityCheckException(); } interface ICreditFacade is ICreditFacadeEvents, ICreditFacadeExceptions, IVersion { // // CREDIT ACCOUNT MANAGEMENT // /// @dev Opens credit account, borrows funds from the pool and pulls collateral /// without any additional action. /// @param amount The amount of collateral provided by the borrower /// @param onBehalfOf The address to open an account for. Transfers to it have to be allowed if /// msg.sender != obBehalfOf /// @param leverageFactor Percentage of the user's own funds to borrow. 100 is equal to 100% - borrows the same amount /// as the user's own collateral, equivalent to 2x leverage. /// @param referralCode Referral code that is used for potential rewards. 0 if no referral code provided. function openCreditAccount( uint256 amount, address onBehalfOf, uint16 leverageFactor, uint16 referralCode ) external payable; /// @dev Opens a Credit Account and runs a batch of operations in a multicall /// @param borrowedAmount Debt size /// @param onBehalfOf The address to open an account for. Transfers to it have to be allowed if /// msg.sender != obBehalfOf /// @param calls The array of MultiCall structs encoding the required operations. Generally must have /// at least a call to addCollateral, as otherwise the health check at the end will fail. /// @param referralCode Referral code which is used for potential rewards. 0 if no referral code provided function openCreditAccountMulticall( uint256 borrowedAmount, address onBehalfOf, MultiCall[] calldata calls, uint16 referralCode ) external payable; /// @dev Runs a batch of transactions within a multicall and closes the account /// - Wraps ETH to WETH and sends it msg.sender if value > 0 /// - Executes the multicall - the main purpose of a multicall when closing is to convert all assets to underlying /// in order to pay the debt. /// - Closes credit account: /// + Checks the underlying balance: if it is greater than the amount paid to the pool, transfers the underlying /// from the Credit Account and proceeds. If not, tries to transfer the shortfall from msg.sender. /// + Transfers all enabled assets with non-zero balances to the "to" address, unless they are marked /// to be skipped in skipTokenMask /// - Emits a CloseCreditAccount event /// /// @param to Address to send funds to during account closing /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before closing the account. function closeCreditAccount( address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable; /// @dev A version of `closeCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function closeCreditAccount( address to, uint256 skipTokenMask, bool convertWETH, MultiCall[] calldata calls ) external payable; /// @dev Runs a batch of transactions within a multicall and liquidates the account /// - Computes the total value and checks that hf < 1. An account can't be liquidated when hf >= 1. /// Total value has to be computed before the multicall, otherwise the liquidator would be able /// to manipulate it. /// - Wraps ETH to WETH and sends it to msg.sender (liquidator) if value > 0 /// - Executes the multicall - the main purpose of a multicall when liquidating is to convert all assets to underlying /// in order to pay the debt. /// - Liquidate credit account: /// + Computes the amount that needs to be paid to the pool. If totalValue * liquidationDiscount < borrow + interest + fees, /// only totalValue * liquidationDiscount has to be paid. Since liquidationDiscount < 1, the liquidator can take /// totalValue * (1 - liquidationDiscount) as premium. Also computes the remaining funds to be sent to borrower /// as totalValue * liquidationDiscount - amountToPool. /// + Checks the underlying balance: if it is greater than amountToPool + remainingFunds, transfers the underlying /// from the Credit Account and proceeds. If not, tries to transfer the shortfall from the liquidator. /// + Transfers all enabled assets with non-zero balances to the "to" address, unless they are marked /// to be skipped in skipTokenMask. If the liquidator is confident that all assets were converted /// during the multicall, they can set the mask to uint256.max - 1, to only transfer the underlying /// - Emits LiquidateCreditAccount event /// /// @param to Address to send funds to after liquidation /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before liquidating the account. function liquidateCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable; /// @dev A version of `liquidateCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function liquidateCreditAccount( address borrower, address to, uint256 skipTokenMask, bool convertWETH, MultiCall[] calldata calls ) external payable; /// @dev Runs a batch of transactions within a multicall and liquidates the account when /// this Credit Facade is expired /// The general flow of liquidation is nearly the same as normal liquidations, with two main differences: /// - An account can be liquidated on an expired Credit Facade even with hf > 1. However, /// no accounts can be liquidated through this function if the Credit Facade is not expired. /// - Liquidation premiums and fees for liquidating expired accounts are reduced. /// It is still possible to normally liquidate an underwater Credit Account, even when the Credit Facade /// is expired. /// @param to Address to send funds to after liquidation /// @param skipTokenMask Uint-encoded bit mask where 1's mark tokens that shouldn't be transferred /// @param calls The array of MultiCall structs encoding the operations to execute before liquidating the account. /// @notice See more at https://dev.gearbox.fi/docs/documentation/credit/liquidation#liquidating-accounts-by-expiration function liquidateExpiredCreditAccount( address borrower, address to, uint256 skipTokenMask, MultiCall[] calldata calls ) external payable; /// @dev A version of `liquidateExpiredCreditAccount` with `convertWETH` parameter that is ignored. /// Used for backward compatibility. function liquidateExpiredCreditAccount( address borrower, address to, uint256 skipTokenMask, bool convertWETH, MultiCall[] calldata calls ) external payable; /// @dev Adds collateral to borrower's credit account /// @param onBehalfOf Address of the borrower whose account is funded /// @param token Address of a collateral token /// @param amount Amount to add function addCollateral( address onBehalfOf, address token, uint256 amount ) external payable; /// @dev Executes a batch of transactions within a Multicall, to manage an existing account /// - Wraps ETH and sends it back to msg.sender, if value > 0 /// - Executes the Multicall /// - Performs a fullCollateralCheck to verify that hf > 1 after all actions /// @param calls The array of MultiCall structs encoding the operations to execute. function multicall(MultiCall[] calldata calls) external payable; /// @dev Returns true if the borrower has an open Credit Account /// @param borrower Borrower address function hasOpenedCreditAccount(address borrower) external view returns (bool); /// @dev Approves account transfer from another user to msg.sender /// @param from Address for which account transfers are allowed/forbidden /// @param state True is transfer is allowed, false if forbidden function approveAccountTransfer(address from, bool state) external; /// @dev Transfers credit account to another user /// By default, this action is forbidden, and the user has to approve transfers from sender to itself /// by calling approveAccountTransfer. /// This is done to prevent malicious actors from transferring compromised accounts to other users. /// @param to Address to transfer the account to function transferAccountOwnership(address to) external; // // GETTERS // /// @dev Calculates total value for provided Credit Account in underlying /// /// @param creditAccount Credit Account address /// @return total Total value in underlying /// @return twv Total weighted (discounted by liquidation thresholds) value in underlying function calcTotalValue(address creditAccount) external view returns (uint256 total, uint256 twv); /** * @dev Calculates health factor for the credit account * * sum(asset[i] * liquidation threshold[i]) * Hf = -------------------------------------------- * borrowed amount + interest accrued + fees * * * More info: https://dev.gearbox.fi/developers/credit/economy#health-factor * * @param creditAccount Credit account address * @return hf = Health factor in bp (see PERCENTAGE FACTOR in PercentageMath.sol) */ function calcCreditAccountHealthFactor(address creditAccount) external view returns (uint256 hf); /// @dev Returns true if token is a collateral token and is not forbidden, /// otherwise returns false /// @param token Token to check function isTokenAllowed(address token) external view returns (bool); /// @dev Returns the CreditManager connected to this Credit Facade function creditManager() external view returns (ICreditManagerV2); /// @dev Returns true if 'from' is allowed to transfer Credit Accounts to 'to' /// @param from Sender address to check allowance for /// @param to Receiver address to check allowance for function transfersAllowed(address from, address to) external view returns (bool); /// @return maxBorrowedAmountPerBlock Maximal amount of new debt that can be taken per block /// @return isIncreaseDebtForbidden True if increasing debt is forbidden /// @return expirationDate Timestamp of the next expiration (for expirable Credit Facades only) /// @return emergencyLiquidationDiscount Premium for liquidations when the system is paused function params() external view returns ( uint128 maxBorrowedAmountPerBlock, bool isIncreaseDebtForbidden, uint40 expirationDate, uint16 emergencyLiquidationDiscount ); /// @return minBorrowedAmount Minimal borrowed amount per credit account /// @return maxBorrowedAmount Maximal borrowed amount per credit account function limits() external view returns (uint128 minBorrowedAmount, uint128 maxBorrowedAmount); function lossParams() external view returns (uint128 currentCumulativeLoss, uint128 maxCumulativeLoss); function totalDebt() external view returns (uint128 currentTotalDebt, uint128 totalDebtLimit); /// @dev Address of the DegenNFT that gatekeeps account openings in whitelisted mode function degenNFT() external view returns (address); /// @dev Address of the underlying asset function underlying() external view returns (address); /// @dev Address of the blacklist helper or address(0), if underlying is not blacklistable function blacklistHelper() external view returns (address); /// @dev Whether the underlying of connected Credit Manager is blacklistable function isBlacklistableUnderlying() external view returns (bool); } interface ICreditFacadeV2 { /// @return maxBorrowedAmountPerBlock Maximal amount of new debt that can be taken per block /// @return isIncreaseDebtForbidden True if increasing debt is forbidden /// @return expirationDate Timestamp of the next expiration (for expirable Credit Facades only) function params() external view returns ( uint128 maxBorrowedAmountPerBlock, bool isIncreaseDebtForbidden, uint40 expirationDate ); }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { IPriceOracleV2 } from "./IPriceOracle.sol"; import { IVersion } from "./IVersion.sol"; enum ClosureAction { CLOSE_ACCOUNT, LIQUIDATE_ACCOUNT, LIQUIDATE_EXPIRED_ACCOUNT, LIQUIDATE_PAUSED } interface ICreditManagerV2Events { /// @dev Emits when a call to an external contract is made through the Credit Manager event ExecuteOrder(address indexed borrower, address indexed target); /// @dev Emits when a configurator is upgraded event NewConfigurator(address indexed newConfigurator); } interface ICreditManagerV2Exceptions { /// @dev Thrown if an access-restricted function is called by an address that is not /// the connected Credit Facade, or an allowed adapter error AdaptersOrCreditFacadeOnlyException(); /// @dev Thrown if an access-restricted function is called by an address that is not /// the connected Credit Facade error CreditFacadeOnlyException(); /// @dev Thrown if an access-restricted function is called by an address that is not /// the connected Credit Configurator error CreditConfiguratorOnlyException(); /// @dev Thrown on attempting to open a Credit Account for or transfer a Credit Account /// to the zero address or an address that already owns a Credit Account error ZeroAddressOrUserAlreadyHasAccountException(); /// @dev Thrown on attempting to execute an order to an address that is not an allowed /// target contract error TargetContractNotAllowedException(); /// @dev Thrown on failing a full collateral check after an operation error NotEnoughCollateralException(); /// @dev Thrown on attempting to receive a token that is not a collateral token /// or was forbidden error TokenNotAllowedException(); /// @dev Thrown if an attempt to approve a collateral token to a target contract failed error AllowanceFailedException(); /// @dev Thrown on attempting to perform an action for an address that owns no Credit Account error HasNoOpenedAccountException(); /// @dev Thrown on attempting to add a token that is already in a collateral list error TokenAlreadyAddedException(); /// @dev Thrown on configurator attempting to add more than 256 collateral tokens error TooManyTokensException(); /// @dev Thrown if more than the maximal number of tokens were enabled on a Credit Account, /// and there are not enough unused token to disable error TooManyEnabledTokensException(); /// @dev Thrown when a reentrancy into the contract is attempted error ReentrancyLockException(); } /// @notice All Credit Manager functions are access-restricted and can only be called /// by the Credit Facade or allowed adapters. Users are not allowed to /// interact with the Credit Manager directly interface ICreditManagerV2 is ICreditManagerV2Events, ICreditManagerV2Exceptions, IVersion { // // CREDIT ACCOUNT MANAGEMENT // /// @dev Opens credit account and borrows funds from the pool. /// - Takes Credit Account from the factory; /// - Requests the pool to lend underlying to the Credit Account /// /// @param borrowedAmount Amount to be borrowed by the Credit Account /// @param onBehalfOf The owner of the newly opened Credit Account function openCreditAccount(uint256 borrowedAmount, address onBehalfOf) external returns (address); /// @dev Closes a Credit Account - covers both normal closure and liquidation /// - Checks whether the contract is paused, and, if so, if the payer is an emergency liquidator. /// Only emergency liquidators are able to liquidate account while the CM is paused. /// Emergency liquidations do not pay a liquidator premium or liquidation fees. /// - Calculates payments to various recipients on closure: /// + Computes amountToPool, which is the amount to be sent back to the pool. /// This includes the principal, interest and fees, but can't be more than /// total position value /// + Computes remainingFunds during liquidations - these are leftover funds /// after paying the pool and the liquidator, and are sent to the borrower /// + Computes protocol profit, which includes interest and liquidation fees /// + Computes loss if the totalValue is less than borrow amount + interest /// - Checks the underlying token balance: /// + if it is larger than amountToPool, then the pool is paid fully from funds on the Credit Account /// + else tries to transfer the shortfall from the payer - either the borrower during closure, or liquidator during liquidation /// - Send assets to the "to" address, as long as they are not included into skipTokenMask /// - If convertWETH is true, the function converts WETH into ETH before sending /// - Returns the Credit Account back to factory /// /// @param borrower Borrower address /// @param closureActionType Whether the account is closed, liquidated or liquidated due to expiry /// @param totalValue Portfolio value for liqution, 0 for ordinary closure /// @param payer Address which would be charged if credit account has not enough funds to cover amountToPool /// @param to Address to which the leftover funds will be sent /// @param skipTokenMask Tokenmask contains 1 for tokens which needed to be skipped for sending /// @param convertWETH If true converts WETH to ETH function closeCreditAccount( address borrower, ClosureAction closureActionType, uint256 totalValue, address payer, address to, uint256 skipTokenMask, bool convertWETH ) external returns (uint256 remainingFunds); /// @dev Manages debt size for borrower: /// /// - Increase debt: /// + Increases debt by transferring funds from the pool to the credit account /// + Updates the cumulative index to keep interest the same. Since interest /// is always computed dynamically as borrowedAmount * (cumulativeIndexNew / cumulativeIndexOpen - 1), /// cumulativeIndexOpen needs to be updated, as the borrow amount has changed /// /// - Decrease debt: /// + Repays debt partially + all interest and fees accrued thus far /// + Updates cunulativeIndex to cumulativeIndex now /// /// @param creditAccount Address of the Credit Account to change debt for /// @param amount Amount to increase / decrease the principal by /// @param increase True to increase principal, false to decrease /// @return newBorrowedAmount The new debt principal function manageDebt( address creditAccount, uint256 amount, bool increase ) external returns (uint256 newBorrowedAmount); /// @dev Adds collateral to borrower's credit account /// @param payer Address of the account which will be charged to provide additional collateral /// @param creditAccount Address of the Credit Account /// @param token Collateral token to add /// @param amount Amount to add function addCollateral( address payer, address creditAccount, address token, uint256 amount ) external; /// @dev Transfers Credit Account ownership to another address /// @param from Address of previous owner /// @param to Address of new owner function transferAccountOwnership(address from, address to) external; /// @dev Requests the Credit Account to approve a collateral token to another contract. /// @param borrower Borrower's address /// @param targetContract Spender to change allowance for /// @param token Collateral token to approve /// @param amount New allowance amount function approveCreditAccount( address borrower, address targetContract, address token, uint256 amount ) external; /// @dev Requests a Credit Account to make a low-level call with provided data /// This is the intended pathway for state-changing interactions with 3rd-party protocols /// @param borrower Borrower's address /// @param targetContract Contract to be called /// @param data Data to pass with the call function executeOrder( address borrower, address targetContract, bytes memory data ) external returns (bytes memory); // // COLLATERAL VALIDITY AND ACCOUNT HEALTH CHECKS // /// @dev Enables a token on a Credit Account, including it /// into account health and total value calculations /// @param creditAccount Address of a Credit Account to enable the token for /// @param token Address of the token to be enabled function checkAndEnableToken(address creditAccount, address token) external; /// @dev Optimized health check for individual swap-like operations. /// @notice Fast health check assumes that only two tokens (input and output) /// participate in the operation and computes a % change in weighted value between /// inbound and outbound collateral. The cumulative negative change across several /// swaps in sequence cannot be larger than feeLiquidation (a fee that the /// protocol is ready to waive if needed). Since this records a % change /// between just two tokens, the corresponding % change in TWV will always be smaller, /// which makes this check safe. /// More details at https://dev.gearbox.fi/docs/documentation/risk/fast-collateral-check#fast-check-protection /// @param creditAccount Address of the Credit Account /// @param tokenIn Address of the token spent by the swap /// @param tokenOut Address of the token received from the swap /// @param balanceInBefore Balance of tokenIn before the operation /// @param balanceOutBefore Balance of tokenOut before the operation function fastCollateralCheck( address creditAccount, address tokenIn, address tokenOut, uint256 balanceInBefore, uint256 balanceOutBefore ) external; /// @dev Performs a full health check on an account, summing up /// value of all enabled collateral tokens /// @param creditAccount Address of the Credit Account to check function fullCollateralCheck(address creditAccount) external; /// @dev Checks that the number of enabled tokens on a Credit Account /// does not violate the maximal enabled token limit and tries /// to disable unused tokens if it does /// @param creditAccount Account to check enabled tokens for function checkAndOptimizeEnabledTokens(address creditAccount) external; /// @dev Disables a token on a credit account /// @notice Usually called by adapters to disable spent tokens during a multicall, /// but can also be called separately from the Credit Facade to remove /// unwanted tokens /// @return True if token mask was change otherwise False function disableToken(address creditAccount, address token) external returns (bool); // // GETTERS // /// @dev Returns the address of a borrower's Credit Account, or reverts if there is none. /// @param borrower Borrower's address function getCreditAccountOrRevert(address borrower) external view returns (address); /// @dev Computes amounts that must be sent to various addresses before closing an account /// @param totalValue Credit Accounts total value in underlying /// @param closureActionType Type of account closure /// * CLOSE_ACCOUNT: The account is healthy and is closed normally /// * LIQUIDATE_ACCOUNT: The account is unhealthy and is being liquidated to avoid bad debt /// * LIQUIDATE_EXPIRED_ACCOUNT: The account has expired and is being liquidated (lowered liquidation premium) /// * LIQUIDATE_PAUSED: The account is liquidated while the system is paused due to emergency (no liquidation premium) /// @param borrowedAmount Credit Account's debt principal /// @param borrowedAmountWithInterest Credit Account's debt principal + interest /// @return amountToPool Amount of underlying to be sent to the pool /// @return remainingFunds Amount of underlying to be sent to the borrower (only applicable to liquidations) /// @return profit Protocol's profit from fees (if any) /// @return loss Protocol's loss from bad debt (if any) function calcClosePayments( uint256 totalValue, ClosureAction closureActionType, uint256 borrowedAmount, uint256 borrowedAmountWithInterest ) external view returns ( uint256 amountToPool, uint256 remainingFunds, uint256 profit, uint256 loss ); /// @dev Calculates the debt accrued by a Credit Account /// @param creditAccount Address of the Credit Account /// @return borrowedAmount The debt principal /// @return borrowedAmountWithInterest The debt principal + accrued interest /// @return borrowedAmountWithInterestAndFees The debt principal + accrued interest and protocol fees function calcCreditAccountAccruedInterest(address creditAccount) external view returns ( uint256 borrowedAmount, uint256 borrowedAmountWithInterest, uint256 borrowedAmountWithInterestAndFees ); /// @dev Maps Credit Accounts to bit masks encoding their enabled token sets /// Only enabled tokens are counted as collateral for the Credit Account /// @notice An enabled token mask encodes an enabled token by setting /// the bit at the position equal to token's index to 1 function enabledTokensMap(address creditAccount) external view returns (uint256); /// @dev Maps the Credit Account to its current percentage drop across all swaps since /// the last full check, in RAY format function cumulativeDropAtFastCheckRAY(address creditAccount) external view returns (uint256); /// @dev Returns the collateral token at requested index and its liquidation threshold /// @param id The index of token to return function collateralTokens(uint256 id) external view returns (address token, uint16 liquidationThreshold); /// @dev Returns the collateral token with requested mask and its liquidationThreshold /// @param tokenMask Token mask corresponding to the token function collateralTokensByMask(uint256 tokenMask) external view returns (address token, uint16 liquidationThreshold); /// @dev Total number of known collateral tokens. function collateralTokensCount() external view returns (uint256); /// @dev Returns the mask for the provided token /// @param token Token to returns the mask for function tokenMasksMap(address token) external view returns (uint256); /// @dev Bit mask encoding a set of forbidden tokens function forbiddenTokenMask() external view returns (uint256); /// @dev Maps allowed adapters to their respective target contracts. function adapterToContract(address adapter) external view returns (address); /// @dev Maps 3rd party contracts to their respective adapters function contractToAdapter(address targetContract) external view returns (address); /// @dev Address of the underlying asset function underlying() external view returns (address); /// @dev Address of the connected pool function pool() external view returns (address); /// @dev Address of the connected pool /// @notice [DEPRECATED]: use pool() instead. function poolService() external view returns (address); /// @dev A map from borrower addresses to Credit Account addresses function creditAccounts(address borrower) external view returns (address); /// @dev Address of the connected Credit Configurator function creditConfigurator() external view returns (address); /// @dev Address of WETH function wethAddress() external view returns (address); /// @dev Returns the liquidation threshold for the provided token /// @param token Token to retrieve the LT for function liquidationThresholds(address token) external view returns (uint16); /// @dev The maximal number of enabled tokens on a single Credit Account function maxAllowedEnabledTokenLength() external view returns (uint8); /// @dev Maps addresses to their status as emergency liquidator. /// @notice Emergency liquidators are trusted addresses /// that are able to liquidate positions while the contracts are paused, /// e.g. when there is a risk of bad debt while an exploit is being patched. /// In the interest of fairness, emergency liquidators do not receive a premium /// And are compensated by the Gearbox DAO separately. function canLiquidateWhilePaused(address) external view returns (bool); /// @dev Returns the fee parameters of the Credit Manager /// @return feeInterest Percentage of interest taken by the protocol as profit /// @return feeLiquidation Percentage of account value taken by the protocol as profit /// during unhealthy account liquidations /// @return liquidationDiscount Multiplier that reduces the effective totalValue during unhealthy account liquidations, /// allowing the liquidator to take the unaccounted for remainder as premium. Equal to (1 - liquidationPremium) /// @return feeLiquidationExpired Percentage of account value taken by the protocol as profit /// during expired account liquidations /// @return liquidationDiscountExpired Multiplier that reduces the effective totalValue during expired account liquidations, /// allowing the liquidator to take the unaccounted for remainder as premium. Equal to (1 - liquidationPremiumExpired) function fees() external view returns ( uint16 feeInterest, uint16 feeLiquidation, uint16 liquidationDiscount, uint16 feeLiquidationExpired, uint16 liquidationDiscountExpired ); /// @dev Address of the connected Credit Facade function creditFacade() external view returns (address); /// @dev Address of the connected Price Oracle function priceOracle() external view returns (IPriceOracleV2); /// @dev Address of the universal adapter function universalAdapter() external view returns (address); /// @dev Contract's version function version() external view returns (uint256); /// @dev Paused() state function checkEmergencyPausable(address caller, bool state) external returns (bool); }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { IVersion } from "./IVersion.sol"; import { IERC721Metadata } from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol"; interface IDegenNFTExceptions { /// @dev Thrown if an access-restricted function was called by non-CreditFacade error CreditFacadeOrConfiguratorOnlyException(); /// @dev Thrown if an access-restricted function was called by non-minter error MinterOnlyException(); /// @dev Thrown if trying to add a burner address that is not a correct Credit Facade error InvalidCreditFacadeException(); /// @dev Thrown if the account's balance is not sufficient for an action (usually a burn) error InsufficientBalanceException(); } interface IDegenNFTEvents { /// @dev Minted when new minter set event NewMinterSet(address indexed); /// @dev Minted each time when new credit facade added event NewCreditFacadeAdded(address indexed); /// @dev Minted each time when new credit facade added event NewCreditFacadeRemoved(address indexed); } interface IDegenNFT is IDegenNFTExceptions, IDegenNFTEvents, IVersion, IERC721Metadata { /// @dev address of the current minter function minter() external view returns (address); /// @dev Stores the total number of tokens on holder accounts function totalSupply() external view returns (uint256); /// @dev Stores the base URI for NFT metadata function baseURI() external view returns (string memory); /// @dev Mints a specified amount of tokens to the address /// @param to Address the tokens are minted to /// @param amount The number of tokens to mint function mint(address to, uint256 amount) external; /// @dev Burns a number of tokens from a specified address /// @param from The address a token will be burnt from /// @param amount The number of tokens to burn function burn(address from, uint256 amount) external; }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; /// @dev Common contract exceptions /// @dev Thrown on attempting to set an important address to zero address error ZeroAddressException(); /// @dev Thrown on attempting to call a non-implemented function error NotImplementedException(); /// @dev Thrown on attempting to set an EOA as an important contract in the system error AddressIsNotContractException(address); /// @dev Thrown on attempting to use a non-ERC20 contract or an EOA as a token error IncorrectTokenContractException(); /// @dev Thrown on attempting to set a token price feed to an address that is not a /// correct price feed error IncorrectPriceFeedException(); /// @dev Thrown on attempting to call an access restricted function as a non-Configurator error CallerNotConfiguratorException(); /// @dev Thrown on attempting to call an access restricted function as a non-Configurator error CallerNotControllerException(); /// @dev Thrown on attempting to pause a contract as a non-Pausable admin error CallerNotPausableAdminException(); /// @dev Thrown on attempting to pause a contract as a non-Unpausable admin error CallerNotUnPausableAdminException();
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; interface IPausable { function pause() external; }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; import { IVersion } from "./IVersion.sol"; interface IPriceOracleV2Events { /// @dev Emits when a new price feed is added event NewPriceFeed(address indexed token, address indexed priceFeed); } interface IPriceOracleV2Exceptions { /// @dev Thrown if a price feed returns 0 error ZeroPriceException(); /// @dev Thrown if the last recorded result was not updated in the last round error ChainPriceStaleException(); /// @dev Thrown on attempting to get a result for a token that does not have a price feed error PriceOracleNotExistsException(); } /// @title Price oracle interface interface IPriceOracleV2 is IPriceOracleV2Events, IPriceOracleV2Exceptions, IVersion { /// @dev Converts a quantity of an asset to USD (decimals = 8). /// @param amount Amount to convert /// @param token Address of the token to be converted function convertToUSD(uint256 amount, address token) external view returns (uint256); /// @dev Converts a quantity of USD (decimals = 8) to an equivalent amount of an asset /// @param amount Amount to convert /// @param token Address of the token converted to function convertFromUSD(uint256 amount, address token) external view returns (uint256); /// @dev Converts one asset into another /// /// @param amount Amount to convert /// @param tokenFrom Address of the token to convert from /// @param tokenTo Address of the token to convert to function convert( uint256 amount, address tokenFrom, address tokenTo ) external view returns (uint256); /// @dev Returns collateral values for two tokens, required for a fast check /// @param amountFrom Amount of the outbound token /// @param tokenFrom Address of the outbound token /// @param amountTo Amount of the inbound token /// @param tokenTo Address of the inbound token /// @return collateralFrom Value of the outbound token amount in USD /// @return collateralTo Value of the inbound token amount in USD function fastCheck( uint256 amountFrom, address tokenFrom, uint256 amountTo, address tokenTo ) external view returns (uint256 collateralFrom, uint256 collateralTo); /// @dev Returns token's price in USD (8 decimals) /// @param token The token to compute the price for function getPrice(address token) external view returns (uint256); /// @dev Returns the price feed address for the passed token /// @param token Token to get the price feed for function priceFeeds(address token) external view returns (address priceFeed); /// @dev Returns the price feed for the passed token, /// with additional parameters /// @param token Token to get the price feed for function priceFeedsWithFlags(address token) external view returns ( address priceFeed, bool skipCheck, uint256 decimals ); } interface IPriceOracleV2Ext is IPriceOracleV2 { /// @dev Sets a price feed if it doesn't exist, or updates an existing one /// @param token Address of the token to set the price feed for /// @param priceFeed Address of a USD price feed adhering to Chainlink's interface function addPriceFeed(address token, address priceFeed) external; }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; /// @title IVersion /// @dev Declares a version function which returns the contract's version interface IVersion { /// @dev Returns contract version function version() external view returns (uint256); }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; struct Balance { address token; uint256 balance; } library BalanceOps { error UnknownToken(address); function copyBalance(Balance memory b) internal pure returns (Balance memory) { return Balance({ token: b.token, balance: b.balance }); } function addBalance( Balance[] memory b, address token, uint256 amount ) internal pure { b[getIndex(b, token)].balance += amount; } function subBalance( Balance[] memory b, address token, uint256 amount ) internal pure { b[getIndex(b, token)].balance -= amount; } function getBalance(Balance[] memory b, address token) internal pure returns (uint256 amount) { return b[getIndex(b, token)].balance; } function setBalance( Balance[] memory b, address token, uint256 amount ) internal pure { b[getIndex(b, token)].balance = amount; } function getIndex(Balance[] memory b, address token) internal pure returns (uint256 index) { for (uint256 i; i < b.length; ) { if (b[i].token == token) { return i; } unchecked { ++i; } } revert UnknownToken(token); } function copy(Balance[] memory b, uint256 len) internal pure returns (Balance[] memory res) { res = new Balance[](len); for (uint256 i; i < len; ) { res[i] = copyBalance(b[i]); unchecked { ++i; } } } function clone(Balance[] memory b) internal pure returns (Balance[] memory) { return copy(b, b.length); } function getModifiedAfterSwap( Balance[] memory b, address tokenFrom, uint256 amountFrom, address tokenTo, uint256 amountTo ) internal pure returns (Balance[] memory res) { res = copy(b, b.length); setBalance(res, tokenFrom, getBalance(b, tokenFrom) - amountFrom); setBalance(res, tokenTo, getBalance(b, tokenTo) + amountTo); } }
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; // Denominations uint256 constant WAD = 1e18; uint256 constant RAY = 1e27; uint16 constant PERCENTAGE_FACTOR = 1e4; //percentage plus two decimals // 25% of type(uint256).max uint256 constant ALLOWANCE_THRESHOLD = type(uint96).max >> 3; // FEE = 50% uint16 constant DEFAULT_FEE_INTEREST = 50_00; // 50% // LIQUIDATION_FEE 1.5% uint16 constant DEFAULT_FEE_LIQUIDATION = 1_50; // 1.5% // LIQUIDATION PREMIUM 4% uint16 constant DEFAULT_LIQUIDATION_PREMIUM = 4_00; // 4% // LIQUIDATION_FEE_EXPIRED 2% uint16 constant DEFAULT_FEE_LIQUIDATION_EXPIRED = 1_00; // 2% // LIQUIDATION PREMIUM EXPIRED 2% uint16 constant DEFAULT_LIQUIDATION_PREMIUM_EXPIRED = 2_00; // 2% // DEFAULT PROPORTION OF MAX BORROWED PER BLOCK TO MAX BORROWED PER ACCOUNT uint16 constant DEFAULT_LIMIT_PER_BLOCK_MULTIPLIER = 2; // Seconds in a year uint256 constant SECONDS_PER_YEAR = 365 days; uint256 constant SECONDS_PER_ONE_AND_HALF_YEAR = (SECONDS_PER_YEAR * 3) / 2; // OPERATIONS // Leverage decimals - 100 is equal to 2x leverage (100% * collateral amount + 100% * borrowed amount) uint8 constant LEVERAGE_DECIMALS = 100; // Maximum withdraw fee for pool in PERCENTAGE_FACTOR format uint8 constant MAX_WITHDRAW_FEE = 100; uint256 constant EXACT_INPUT = 1; uint256 constant EXACT_OUTPUT = 2; address constant UNIVERSAL_CONTRACT = 0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC;
// SPDX-License-Identifier: MIT // Gearbox Protocol. Generalized leverage for DeFi protocols // (c) Gearbox Holdings, 2022 pragma solidity ^0.8.10; /// @title Errors library library Errors { // // COMMON // string public constant ZERO_ADDRESS_IS_NOT_ALLOWED = "Z0"; string public constant NOT_IMPLEMENTED = "NI"; string public constant INCORRECT_PATH_LENGTH = "PL"; string public constant INCORRECT_ARRAY_LENGTH = "CR"; string public constant REGISTERED_CREDIT_ACCOUNT_MANAGERS_ONLY = "CP"; string public constant REGISTERED_POOLS_ONLY = "RP"; string public constant INCORRECT_PARAMETER = "IP"; // // MATH // string public constant MATH_MULTIPLICATION_OVERFLOW = "M1"; string public constant MATH_ADDITION_OVERFLOW = "M2"; string public constant MATH_DIVISION_BY_ZERO = "M3"; // // POOL // string public constant POOL_CONNECTED_CREDIT_MANAGERS_ONLY = "PS0"; string public constant POOL_INCOMPATIBLE_CREDIT_ACCOUNT_MANAGER = "PS1"; string public constant POOL_MORE_THAN_EXPECTED_LIQUIDITY_LIMIT = "PS2"; string public constant POOL_INCORRECT_WITHDRAW_FEE = "PS3"; string public constant POOL_CANT_ADD_CREDIT_MANAGER_TWICE = "PS4"; // // ACCOUNT FACTORY // string public constant AF_CANT_CLOSE_CREDIT_ACCOUNT_IN_THE_SAME_BLOCK = "AF1"; string public constant AF_MINING_IS_FINISHED = "AF2"; string public constant AF_CREDIT_ACCOUNT_NOT_IN_STOCK = "AF3"; string public constant AF_EXTERNAL_ACCOUNTS_ARE_FORBIDDEN = "AF4"; // // ADDRESS PROVIDER // string public constant AS_ADDRESS_NOT_FOUND = "AP1"; // // CONTRACTS REGISTER // string public constant CR_POOL_ALREADY_ADDED = "CR1"; string public constant CR_CREDIT_MANAGER_ALREADY_ADDED = "CR2"; // // CREDIT ACCOUNT // string public constant CA_CONNECTED_CREDIT_MANAGER_ONLY = "CA1"; string public constant CA_FACTORY_ONLY = "CA2"; // // ACL // string public constant ACL_CALLER_NOT_PAUSABLE_ADMIN = "ACL1"; string public constant ACL_CALLER_NOT_CONFIGURATOR = "ACL2"; // // WETH GATEWAY // string public constant WG_DESTINATION_IS_NOT_WETH_COMPATIBLE = "WG1"; string public constant WG_RECEIVE_IS_NOT_ALLOWED = "WG2"; string public constant WG_NOT_ENOUGH_FUNDS = "WG3"; // // TOKEN DISTRIBUTOR // string public constant TD_WALLET_IS_ALREADY_CONNECTED_TO_VC = "TD1"; string public constant TD_INCORRECT_WEIGHTS = "TD2"; string public constant TD_NON_ZERO_BALANCE_AFTER_DISTRIBUTION = "TD3"; string public constant TD_CONTRIBUTOR_IS_NOT_REGISTERED = "TD4"; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; struct MultiCall { address target; bytes callData; } library MultiCallOps { function copyMulticall(MultiCall memory call) internal pure returns (MultiCall memory) { return MultiCall({ target: call.target, callData: call.callData }); } function trim(MultiCall[] memory calls) internal pure returns (MultiCall[] memory trimmed) { uint256 len = calls.length; if (len == 0) return calls; uint256 foundLen; while (calls[foundLen].target != address(0)) { unchecked { ++foundLen; if (foundLen == len) return calls; } } if (foundLen > 0) return copy(calls, foundLen); } function copy(MultiCall[] memory calls, uint256 len) internal pure returns (MultiCall[] memory res) { res = new MultiCall[](len); for (uint256 i; i < len; ) { res[i] = copyMulticall(calls[i]); unchecked { ++i; } } } function clone(MultiCall[] memory calls) internal pure returns (MultiCall[] memory res) { return copy(calls, calls.length); } function append(MultiCall[] memory calls, MultiCall memory newCall) internal pure returns (MultiCall[] memory res) { uint256 len = calls.length; res = new MultiCall[](len + 1); for (uint256 i; i < len; ) { res[i] = copyMulticall(calls[i]); unchecked { ++i; } } res[len] = copyMulticall(newCall); } function prepend(MultiCall[] memory calls, MultiCall memory newCall) internal pure returns (MultiCall[] memory res) { uint256 len = calls.length; res = new MultiCall[](len + 1); res[0] = copyMulticall(newCall); for (uint256 i = 1; i < len + 1; ) { res[i] = copyMulticall(calls[i]); unchecked { ++i; } } } function concat(MultiCall[] memory calls1, MultiCall[] memory calls2) internal pure returns (MultiCall[] memory res) { uint256 len1 = calls1.length; uint256 lenTotal = len1 + calls2.length; if (lenTotal == calls1.length) return clone(calls1); if (lenTotal == calls2.length) return clone(calls2); res = new MultiCall[](lenTotal); for (uint256 i; i < lenTotal; ) { res[i] = (i < len1) ? copyMulticall(calls1[i]) : copyMulticall(calls2[i - len1]); unchecked { ++i; } } } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity ^0.8.10; import { Errors } from "./Errors.sol"; import { PERCENTAGE_FACTOR } from "./Constants.sol"; uint256 constant HALF_PERCENT = PERCENTAGE_FACTOR / 2; /** * @title PercentageMath library * @author Aave * @notice Provides functions to perform percentage calculations * @dev Percentages are defined by default with 2 decimals of precision (100.00). The precision is indicated by PERCENTAGE_FACTOR * @dev Operations are rounded half up **/ library PercentageMath { /** * @dev Executes a percentage multiplication * @param value The value of which the percentage needs to be calculated * @param percentage The percentage of the value to be calculated * @return The percentage of value **/ function percentMul(uint256 value, uint256 percentage) internal pure returns (uint256) { if (value == 0 || percentage == 0) { return 0; // T:[PM-1] } // require( // value <= (type(uint256).max - HALF_PERCENT) / percentage, // Errors.MATH_MULTIPLICATION_OVERFLOW // ); // T:[PM-1] return (value * percentage + HALF_PERCENT) / PERCENTAGE_FACTOR; // T:[PM-1] } /** * @dev Executes a percentage division * @param value The value of which the percentage needs to be calculated * @param percentage The percentage of the value to be calculated * @return The value divided the percentage **/ function percentDiv(uint256 value, uint256 percentage) internal pure returns (uint256) { require(percentage != 0, Errors.MATH_DIVISION_BY_ZERO); // T:[PM-2] uint256 halfPercentage = percentage / 2; // T:[PM-2] // require( // value <= (type(uint256).max - halfPercentage) / PERCENTAGE_FACTOR, // Errors.MATH_MULTIPLICATION_OVERFLOW // ); // T:[PM-2] return (value * PERCENTAGE_FACTOR + halfPercentage) / percentage; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
{ "optimizer": { "enabled": true, "runs": 2000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_creditManager","type":"address"},{"internalType":"address","name":"_degenNFT","type":"address"},{"internalType":"address","name":"_blacklistHelper","type":"address"},{"internalType":"bool","name":"_expirable","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccountTransferNotAllowedException","type":"error"},{"inputs":[],"name":"ActionProhibitedWithForbiddenTokensException","type":"error"},{"inputs":[],"name":"AdaptersOrCreditFacadeOnlyException","type":"error"},{"inputs":[],"name":"AllowanceFailedException","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"BalanceLessThanMinimumDesiredException","type":"error"},{"inputs":[],"name":"BorrowAmountOutOfLimitsException","type":"error"},{"inputs":[],"name":"BorrowedBlockLimitException","type":"error"},{"inputs":[],"name":"CantLiquidateNonExpiredException","type":"error"},{"inputs":[],"name":"CantLiquidateWithSuchHealthFactorException","type":"error"},{"inputs":[],"name":"CantTransferLiquidatableAccountException","type":"error"},{"inputs":[],"name":"CreditConfiguratorOnlyException","type":"error"},{"inputs":[],"name":"CreditFacadeOnlyException","type":"error"},{"inputs":[],"name":"ExpectedBalancesAlreadySetException","type":"error"},{"inputs":[],"name":"ForbiddenDuringClosureException","type":"error"},{"inputs":[],"name":"HasNoOpenedAccountException","type":"error"},{"inputs":[],"name":"IncorrectCallDataException","type":"error"},{"inputs":[],"name":"IncreaseAndDecreaseForbiddenInOneCallException","type":"error"},{"inputs":[],"name":"IncreaseDebtForbiddenException","type":"error"},{"inputs":[],"name":"LiquiditySanityCheckException","type":"error"},{"inputs":[],"name":"NotAllowedForBlacklistedAddressException","type":"error"},{"inputs":[],"name":"NotAllowedInWhitelistedMode","type":"error"},{"inputs":[],"name":"NotAllowedWhenNotExpirableException","type":"error"},{"inputs":[],"name":"NotEnoughCollateralException","type":"error"},{"inputs":[],"name":"OpenAccountNotAllowedAfterExpirationException","type":"error"},{"inputs":[],"name":"ReentrancyLockException","type":"error"},{"inputs":[],"name":"TargetContractNotAllowedException","type":"error"},{"inputs":[],"name":"TokenAlreadyAddedException","type":"error"},{"inputs":[],"name":"TokenNotAllowedException","type":"error"},{"inputs":[],"name":"TooManyEnabledTokensException","type":"error"},{"inputs":[],"name":"TooManyTokensException","type":"error"},{"inputs":[],"name":"UnknownMethodException","type":"error"},{"inputs":[],"name":"ZeroAddressException","type":"error"},{"inputs":[],"name":"ZeroAddressOrUserAlreadyHasAccountException","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"onBehalfOf","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"AddCollateral","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"blacklistHelper","type":"address"}],"name":"BlacklistHelperSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"CloseCreditAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DecreaseBorrowedAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncreaseBorrowedAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"loss","type":"uint256"}],"name":"IncurLossOnLiquidation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"remainingFunds","type":"uint256"}],"name":"LiquidateCreditAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"remainingFunds","type":"uint256"}],"name":"LiquidateExpiredCreditAccount","type":"event"},{"anonymous":false,"inputs":[],"name":"MultiCallFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"}],"name":"MultiCallStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"onBehalfOf","type":"address"},{"indexed":true,"internalType":"address","name":"creditAccount","type":"address"},{"indexed":false,"internalType":"uint256","name":"borrowAmount","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"referralCode","type":"uint16"}],"name":"OpenCreditAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"TokenDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"TokenEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"TransferAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"bool","name":"state","type":"bool"}],"name":"TransferAccountAllowed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UnderlyingSentToBlacklistHelper","type":"event"},{"inputs":[{"internalType":"address","name":"onBehalfOf","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"addCollateral","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"approveAccountTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"blacklistHelper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"creditAccount","type":"address"}],"name":"calcCreditAccountHealthFactor","outputs":[{"internalType":"uint256","name":"hf","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"creditAccount","type":"address"}],"name":"calcTotalValue","outputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"twv","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"closeCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"internalType":"bool","name":"","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"closeCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"creditManager","outputs":[{"internalType":"contract ICreditManagerV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"degenNFT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expirable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBorrowedInBlock","outputs":[{"internalType":"uint64","name":"blockLastUpdate","type":"uint64"},{"internalType":"uint128","name":"borrowedInBlock","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"}],"name":"hasOpenedCreditAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBlacklistableUnderlying","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isTokenAllowed","outputs":[{"internalType":"bool","name":"allowed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limits","outputs":[{"internalType":"uint128","name":"minBorrowedAmount","type":"uint128"},{"internalType":"uint128","name":"maxBorrowedAmount","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"liquidateCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"internalType":"bool","name":"","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"liquidateCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"liquidateExpiredCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"skipTokenMask","type":"uint256"},{"internalType":"bool","name":"","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"liquidateExpiredCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"lossParams","outputs":[{"internalType":"uint128","name":"currentCumulativeLoss","type":"uint128"},{"internalType":"uint128","name":"maxCumulativeLoss","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"}],"name":"multicall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"onBehalfOf","type":"address"},{"internalType":"uint16","name":"leverageFactor","type":"uint16"},{"internalType":"uint16","name":"referralCode","type":"uint16"}],"name":"openCreditAccount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"borrowedAmount","type":"uint256"},{"internalType":"address","name":"onBehalfOf","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct MultiCall[]","name":"calls","type":"tuple[]"},{"internalType":"uint16","name":"referralCode","type":"uint16"}],"name":"openCreditAccountMulticall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"params","outputs":[{"internalType":"uint128","name":"maxBorrowedAmountPerBlock","type":"uint128"},{"internalType":"bool","name":"isIncreaseDebtForbidden","type":"bool"},{"internalType":"uint40","name":"expirationDate","type":"uint40"},{"internalType":"uint16","name":"emergencyLiquidationDiscount","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"resetCumulativeLoss","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_minBorrowedAmount","type":"uint128"},{"internalType":"uint128","name":"_maxBorrowedAmount","type":"uint128"}],"name":"setCreditAccountLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"newDiscount","type":"uint16"}],"name":"setEmergencyLiquidationDiscount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint40","name":"newExpirationDate","type":"uint40"}],"name":"setExpirationDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_mode","type":"bool"}],"name":"setIncreaseDebtForbidden","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"newLimit","type":"uint128"}],"name":"setLimitPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"_maxCumulativeLoss","type":"uint128"}],"name":"setMaxCumulativeLoss","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"newCurrentTotalDebt","type":"uint128"},{"internalType":"uint128","name":"newLimit","type":"uint128"}],"name":"setTotalDebtParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalDebt","outputs":[{"internalType":"uint128","name":"currentTotalDebt","type":"uint128"},{"internalType":"uint128","name":"totalDebtLimit","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"transferAccountOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"transfersAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wethAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.