Description:
Proxy contract enabling upgradeable smart contract patterns. Delegates calls to an implementation contract.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"src/periphery/PricingAdapter.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
// Internal imports
import {IAggregatorV2V3Interface} from "../interfaces/periphery/IAggregatorV2V3Interface.sol";
import {ILeverageToken} from "../interfaces/ILeverageToken.sol";
import {ILeverageManager} from "../interfaces/ILeverageManager.sol";
import {IPricingAdapter} from "../interfaces/periphery/IPricingAdapter.sol";
/**
* @dev This contract is used to get the price of a LeverageToken in the collateral asset of the LeverageToken, debt asset
* of the LeverageToken, or the price using a Chainlink oracle.
* The decimal precision of the price using a Chainlink oracle is equal to the decimals of the base asset of the Chainlink
* oracle.
* Integrators using this PricingAdapter should carefully evaluate and understand the risks of using this contract before
* using it. Some points to consider are the rounding direction and precision used by the logic in this contract.
*
* @custom:contact security@seamlessprotocol.com
*/
contract PricingAdapter is IPricingAdapter {
uint256 internal constant WAD = 1e18;
/// @inheritdoc IPricingAdapter
ILeverageManager public immutable leverageManager;
/// @notice Constructor
/// @param _leverageManager The LeverageManager contract
constructor(ILeverageManager _leverageManager) {
leverageManager = _leverageManager;
}
/// @inheritdoc IPricingAdapter
function getLeverageTokenPriceInCollateral(ILeverageToken leverageToken) public view returns (uint256) {
uint256 totalSupply = leverageManager.getFeeAdjustedTotalSupply(leverageToken);
if (totalSupply == 0) {
return 0;
}
uint256 totalEquityInCollateralAsset =
leverageManager.getLeverageTokenLendingAdapter(leverageToken).getEquityInCollateralAsset();
// LT is on 18 decimals, so 1 LT is WAD wei
return (WAD * totalEquityInCollateralAsset) / totalSupply;
}
/// @inheritdoc IPricingAdapter
function getLeverageTokenPriceInDebt(ILeverageToken leverageToken) public view returns (uint256) {
uint256 totalSupply = leverageManager.getFeeAdjustedTotalSupply(leverageToken);
if (totalSupply == 0) {
return 0;
}
uint256 totalEquityInDebtAsset =
leverageManager.getLeverageTokenLendingAdapter(leverageToken).getEquityInDebtAsset();
// LT is on 18 decimals, so 1 LT is WAD wei
return (WAD * totalEquityInDebtAsset) / totalSupply;
}
/// @inheritdoc IPricingAdapter
function getLeverageTokenPriceAdjusted(
ILeverageToken leverageToken,
IAggregatorV2V3Interface chainlinkOracle,
bool isBaseDebtAsset
) public view returns (int256) {
uint256 priceInBaseAsset = isBaseDebtAsset
? getLeverageTokenPriceInDebt(leverageToken)
: getLeverageTokenPriceInCollateral(leverageToken);
int256 oraclePrice = chainlinkOracle.latestAnswer();
uint256 oracleDecimals = chainlinkOracle.decimals();
int256 adjustedPrice = (oraclePrice * int256(priceInBaseAsset)) / int256(10 ** oracleDecimals);
return adjustedPrice;
}
}
"
},
"src/interfaces/periphery/IAggregatorV2V3Interface.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
/// @notice Interface for Chainlink Aggregator
interface IAggregatorV2V3Interface {
function decimals() external view returns (uint8);
function latestAnswer() external view returns (int256);
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
"
},
"src/interfaces/ILeverageToken.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
// Dependency imports
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface ILeverageToken is IERC20 {
/// @notice Event emitted when the leverage token is initialized
/// @param name The name of the LeverageToken
/// @param symbol The symbol of the LeverageToken
event LeverageTokenInitialized(string name, string symbol);
/// @notice Converts an amount of LeverageToken shares to an amount of equity in collateral asset, based on the
/// price oracle used by the underlying lending adapter and state of the LeverageToken.
/// @notice Equity in collateral asset is equal to the difference between collateral and debt denominated
/// in the collateral asset.
/// @param shares The number of shares to convert to equity in collateral asset
/// @return assets Amount of equity in collateral asset that correspond to the shares
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/// @notice Converts an amount of equity in collateral asset to an amount of LeverageToken shares, based on the
/// price oracle used by the underlying lending adapter and state of the LeverageToken.
/// @notice Equity in collateral asset is equal to the difference between collateral and debt denominated
/// in the collateral asset.
/// @param assets The amount of equity in collateral asset to convert to shares
/// @return shares The number of shares that correspond to the equity in collateral asset
function convertToShares(uint256 assets) external view returns (uint256 shares);
/// @notice Mints new tokens to the specified address
/// @param to The address to mint tokens to
/// @param amount The amount of tokens to mint
/// @dev Only the owner can call this function. Owner should be the LeverageManager contract
function mint(address to, uint256 amount) external;
/// @notice Burns tokens from the specified address
/// @param from The address to burn tokens from
/// @param amount The amount of tokens to burn
/// @dev Only the owner can call this function. Owner should be the LeverageManager contract
function burn(address from, uint256 amount) external;
}
"
},
"src/interfaces/ILeverageManager.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
// Dependency imports
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
// Internal imports
import {IFeeManager} from "./IFeeManager.sol";
import {IRebalanceAdapterBase} from "./IRebalanceAdapterBase.sol";
import {ILeverageToken} from "./ILeverageToken.sol";
import {IBeaconProxyFactory} from "./IBeaconProxyFactory.sol";
import {ILendingAdapter} from "./ILendingAdapter.sol";
import {ActionData, LeverageTokenState, RebalanceAction, LeverageTokenConfig} from "src/types/DataTypes.sol";
interface ILeverageManager is IFeeManager {
/// @notice Error thrown when someone tries to set zero address for collateral or debt asset when creating a LeverageToken
error InvalidLeverageTokenAssets();
/// @notice Error thrown when collateral ratios are invalid for an action
error InvalidCollateralRatios();
/// @notice Error thrown when slippage is too high during mint/redeem
/// @param actual The actual amount of tokens received
/// @param expected The expected amount of tokens to receive
error SlippageTooHigh(uint256 actual, uint256 expected);
/// @notice Error thrown when caller is not authorized to rebalance
/// @param token The LeverageToken to rebalance
/// @param caller The caller of the rebalance function
error NotRebalancer(ILeverageToken token, address caller);
/// @notice Error thrown when a LeverageToken's initial collateral ratio is invalid (must be greater than the base ratio)
/// @param initialCollateralRatio The initial collateral ratio that is invalid
error InvalidLeverageTokenInitialCollateralRatio(uint256 initialCollateralRatio);
/// @notice Error thrown when a LeverageToken's state after rebalance is invalid
/// @param token The LeverageToken that has invalid state after rebalance
error InvalidLeverageTokenStateAfterRebalance(ILeverageToken token);
/// @notice Event emitted when the LeverageManager is initialized
/// @param leverageTokenFactory The factory for creating new LeverageTokens
event LeverageManagerInitialized(IBeaconProxyFactory leverageTokenFactory);
/// @notice Error thrown when attempting to rebalance a LeverageToken that is not eligible for rebalance
error LeverageTokenNotEligibleForRebalance();
/// @notice Event emitted when a new LeverageToken is created
/// @param token The new LeverageToken
/// @param collateralAsset The collateral asset of the LeverageToken
/// @param debtAsset The debt asset of the LeverageToken
/// @param config The config of the LeverageToken
event LeverageTokenCreated(
ILeverageToken indexed token, IERC20 collateralAsset, IERC20 debtAsset, LeverageTokenConfig config
);
/// @notice Event emitted when a user mints LeverageToken shares
/// @param token The LeverageToken
/// @param sender The sender of the mint
/// @param actionData The action data of the mint
event Mint(ILeverageToken indexed token, address indexed sender, ActionData actionData);
/// @notice Event emitted when a user rebalances a LeverageToken
/// @param token The LeverageToken
/// @param sender The sender of the rebalance
/// @param stateBefore The state of the LeverageToken before the rebalance
/// @param stateAfter The state of the LeverageToken after the rebalance
/// @param actions The actions that were taken
event Rebalance(
ILeverageToken indexed token,
address indexed sender,
LeverageTokenState stateBefore,
LeverageTokenState stateAfter,
RebalanceAction[] actions
);
/// @notice Event emitted when a user redeems LeverageToken shares
/// @param token The LeverageToken
/// @param sender The sender of the redeem
/// @param actionData The action data of the redeem
event Redeem(ILeverageToken indexed token, address indexed sender, ActionData actionData);
/// @notice Returns the base collateral ratio
/// @return baseRatio Base collateral ratio
function BASE_RATIO() external view returns (uint256);
/// @notice Converts an amount of collateral to an amount of debt for a LeverageToken, based on the current
/// collateral ratio of the LeverageToken
/// @param token LeverageToken to convert collateral to debt for
/// @param collateral Amount of collateral to convert to debt
/// @param rounding Rounding mode to use for the conversion
/// @return debt Amount of debt that correspond to the collateral
/// @dev For deposits/mints, Math.Rounding.Floor should be used. For withdraws/redeems, Math.Rounding.Ceil should be used.
function convertCollateralToDebt(ILeverageToken token, uint256 collateral, Math.Rounding rounding)
external
view
returns (uint256 debt);
/// @notice Converts an amount of collateral to an amount of shares for a LeverageToken, based on the current
/// collateral ratio of the LeverageToken
/// @param token LeverageToken to convert collateral to shares for
/// @param collateral Amount of collateral to convert to shares
/// @param rounding Rounding mode to use for the conversion
/// @return shares Amount of shares that correspond to the collateral
/// @dev For deposits/mints, Math.Rounding.Floor should be used. For withdraws/redeems, Math.Rounding.Ceil should be used.
function convertCollateralToShares(ILeverageToken token, uint256 collateral, Math.Rounding rounding)
external
view
returns (uint256 shares);
/// @notice Converts an amount of debt to an amount of collateral for a LeverageToken, based on the current
/// collateral ratio of the LeverageToken
/// @param token LeverageToken to convert debt to collateral for
/// @param debt Amount of debt to convert to collateral
/// @param rounding Rounding mode to use for the conversion
/// @return collateral Amount of collateral that correspond to the debt amount
/// @dev For deposits/mints, Math.Rounding.Ceil should be used. For withdraws/redeems, Math.Rounding.Floor should be used.
function convertDebtToCollateral(ILeverageToken token, uint256 debt, Math.Rounding rounding)
external
view
returns (uint256 collateral);
/// @notice Converts an amount of shares to an amount of collateral for a LeverageToken, based on the current
/// collateral ratio of the LeverageToken
/// @param token LeverageToken to convert shares to collateral for
/// @param shares Amount of shares to convert to collateral
/// @param rounding Rounding mode to use for the conversion
/// @return collateral Amount of collateral that correspond to the shares
/// @dev For deposits/mints, Math.Rounding.Ceil should be used. For withdraws/redeems, Math.Rounding.Floor should be used.
function convertSharesToCollateral(ILeverageToken token, uint256 shares, Math.Rounding rounding)
external
view
returns (uint256 collateral);
/// @notice Converts an amount of shares to an amount of debt for a LeverageToken, based on the current
/// collateral ratio of the LeverageToken
/// @param token LeverageToken to convert shares to debt for
/// @param shares Amount of shares to convert to debt
/// @param rounding Rounding mode to use for the conversion
/// @return debt Amount of debt that correspond to the shares
/// @dev For deposits/mints, Math.Rounding.Floor should be used. For withdraws/redeems, Math.Rounding.Ceil should be used.
function convertSharesToDebt(ILeverageToken token, uint256 shares, Math.Rounding rounding)
external
view
returns (uint256 debt);
/// @notice Converts an amount of shares to an amount of equity in collateral asset for a LeverageToken, based on the
/// price oracle used by the underlying lending adapter and state of the LeverageToken
/// @param token LeverageToken to convert shares to equity in collateral asset for
/// @param shares Amount of shares to convert to equity in collateral asset
/// @return equityInCollateralAsset Amount of equity in collateral asset that correspond to the shares
function convertToAssets(ILeverageToken token, uint256 shares)
external
view
returns (uint256 equityInCollateralAsset);
/// @notice Converts an amount of equity in collateral asset to an amount of shares for a LeverageToken, based on the
/// price oracle used by the underlying lending adapter and state of the LeverageToken
/// @param token LeverageToken to convert equity in collateral asset to shares for
/// @param equityInCollateralAsset Amount of equity in collateral asset to convert to shares
/// @return shares Amount of shares that correspond to the equity in collateral asset
function convertToShares(ILeverageToken token, uint256 equityInCollateralAsset)
external
view
returns (uint256 shares);
/// @notice Returns the factory for creating new LeverageTokens
/// @return factory Factory for creating new LeverageTokens
function getLeverageTokenFactory() external view returns (IBeaconProxyFactory factory);
/// @notice Returns the lending adapter for a LeverageToken
/// @param token LeverageToken to get lending adapter for
/// @return adapter Lending adapter for the LeverageToken
function getLeverageTokenLendingAdapter(ILeverageToken token) external view returns (ILendingAdapter adapter);
/// @notice Returns the collateral asset for a LeverageToken
/// @param token LeverageToken to get collateral asset for
/// @return collateralAsset Collateral asset for the LeverageToken
function getLeverageTokenCollateralAsset(ILeverageToken token) external view returns (IERC20 collateralAsset);
/// @notice Returns the debt asset for a LeverageToken
/// @param token LeverageToken to get debt asset for
/// @return debtAsset Debt asset for the LeverageToken
function getLeverageTokenDebtAsset(ILeverageToken token) external view returns (IERC20 debtAsset);
/// @notice Returns the rebalance adapter for a LeverageToken
/// @param token LeverageToken to get the rebalance adapter for
/// @return adapter Rebalance adapter for the LeverageToken
function getLeverageTokenRebalanceAdapter(ILeverageToken token)
external
view
returns (IRebalanceAdapterBase adapter);
/// @notice Returns the entire configuration for a LeverageToken
/// @param token LeverageToken to get config for
/// @return config LeverageToken configuration
function getLeverageTokenConfig(ILeverageToken token) external view returns (LeverageTokenConfig memory config);
/// @notice Returns the initial collateral ratio for a LeverageToken
/// @param token LeverageToken to get initial collateral ratio for
/// @return initialCollateralRatio Initial collateral ratio for the LeverageToken
/// @dev Initial collateral ratio is followed when the LeverageToken has no shares and on mints when debt is 0.
function getLeverageTokenInitialCollateralRatio(ILeverageToken token)
external
view
returns (uint256 initialCollateralRatio);
/// @notice Returns all data required to describe current LeverageToken state - collateral, debt, equity and collateral ratio
/// @param token LeverageToken to query state for
/// @return state LeverageToken state
function getLeverageTokenState(ILeverageToken token) external view returns (LeverageTokenState memory state);
/// @notice Previews deposit function call and returns all required data
/// @param token LeverageToken to preview deposit for
/// @param collateral Amount of collateral to deposit
/// @return previewData Preview data for deposit
/// - collateral Amount of collateral that will be added to the LeverageToken and sent to the receiver
/// - debt Amount of debt that will be borrowed and sent to the receiver
/// - shares Amount of shares that will be minted to the receiver
/// - tokenFee Amount of shares that will be charged for the deposit that are given to the LeverageToken
/// - treasuryFee Amount of shares that will be charged for the deposit that are given to the treasury
/// @dev Sender should approve leverage manager to spend collateral amount of collateral asset
function previewDeposit(ILeverageToken token, uint256 collateral) external view returns (ActionData memory);
/// @notice Previews mint function call and returns all required data
/// @param token LeverageToken to preview mint for
/// @param shares Amount of shares to mint
/// @return previewData Preview data for mint
/// - collateral Amount of collateral that will be added to the LeverageToken and sent to the receiver
/// - debt Amount of debt that will be borrowed and sent to the receiver
/// - shares Amount of shares that will be minted to the receiver
/// - tokenFee Amount of shares that will be charged for the mint that are given to the LeverageToken
/// - treasuryFee Amount of shares that will be charged for the mint that are given to the treasury
/// @dev Sender should approve leverage manager to spend collateral amount of collateral asset
function previewMint(ILeverageToken token, uint256 shares) external view returns (ActionData memory);
/// @notice Previews redeem function call and returns all required data
/// @param token LeverageToken to preview redeem for
/// @param shares Amount of shares to redeem
/// @return previewData Preview data for redeem
/// - collateral Amount of collateral that will be removed from the LeverageToken and sent to the sender
/// - debt Amount of debt that will be taken from sender and repaid to the LeverageToken
/// - shares Amount of shares that will be burned from sender
/// - tokenFee Amount of shares that will be charged for the redeem that are given to the LeverageToken
/// - treasuryFee Amount of shares that will be charged for the redeem that are given to the treasury
/// @dev Sender should approve LeverageManager to spend debt amount of debt asset
function previewRedeem(ILeverageToken token, uint256 shares) external view returns (ActionData memory);
/// @notice Previews withdraw function call and returns all required data
/// @param token LeverageToken to preview withdraw for
/// @param collateral Amount of collateral to withdraw
/// @return previewData Preview data for withdraw
/// - collateral Amount of collateral that will be removed from the LeverageToken and sent to the sender
/// - debt Amount of debt that will be taken from sender and repaid to the LeverageToken
/// - shares Amount of shares that will be burned from sender
/// - tokenFee Amount of shares that will be charged for the redeem that are given to the LeverageToken
/// - treasuryFee Amount of shares that will be charged for the redeem that are given to the treasury
/// @dev Sender should approve LeverageManager to spend debt amount of debt asset
function previewWithdraw(ILeverageToken token, uint256 collateral) external view returns (ActionData memory);
/// @notice Creates a new LeverageToken with the given config
/// @param config Configuration of the LeverageToken
/// @param name Name of the LeverageToken
/// @param symbol Symbol of the LeverageToken
/// @return token Address of the new LeverageToken
function createNewLeverageToken(LeverageTokenConfig memory config, string memory name, string memory symbol)
external
returns (ILeverageToken token);
/// @notice Deposits collateral into a LeverageToken and mints shares to the sender
/// @param token LeverageToken to deposit into
/// @param collateral Amount of collateral to deposit
/// @param minShares Minimum number of shares to mint
/// @return depositData Action data for the deposit
/// - collateral Amount of collateral that was added, including any fees
/// - debt Amount of debt that was added
/// - shares Amount of shares minted to the sender
/// - tokenFee Amount of shares that was charged for the deposit that are given to the LeverageToken
/// - treasuryFee Amount of shares that was charged for the deposit that are given to the treasury
/// @dev Sender should approve leverage manager to spend collateral amount of collateral asset
function deposit(ILeverageToken token, uint256 collateral, uint256 minShares)
external
returns (ActionData memory);
/// @notice Mints shares of a LeverageToken to the sender
/// @param token LeverageToken to mint shares for
/// @param shares Amount of shares to mint
/// @param maxCollateral Maximum amount of collateral to use for minting
/// @return mintData Action data for the mint
/// - collateral Amount of collateral that was added, including any fees
/// - debt Amount of debt that was added
/// - shares Amount of shares minted to the sender
/// - tokenFee Amount of shares that was charged for the mint that are given to the LeverageToken
/// - treasuryFee Amount of shares that was charged for the mint that are given to the treasury
/// @dev Sender should approve leverage manager to spend collateral amount of collateral asset, which can be
/// previewed with previewMint
function mint(ILeverageToken token, uint256 shares, uint256 maxCollateral) external returns (ActionData memory);
/// @notice Redeems equity from a LeverageToken and burns shares from sender
/// @param token The LeverageToken to redeem from
/// @param shares The amount of shares to redeem
/// @param minCollateral The minimum amount of collateral to receive
/// @return actionData Data about the redeem
/// - collateral Amount of collateral that was removed from LeverageToken and sent to sender
/// - debt Amount of debt that was repaid to LeverageToken, taken from sender
/// - shares Amount of the sender's shares that were burned for the redeem
/// - tokenFee Amount of shares that was charged for the redeem that are given to the LeverageToken
/// - treasuryFee Amount of shares that was charged for the redeem that are given to the treasury
function redeem(ILeverageToken token, uint256 shares, uint256 minCollateral)
external
returns (ActionData memory actionData);
/// @notice Rebalances a LeverageToken based on provided actions
/// @param leverageToken LeverageToken to rebalance
/// @param actions Rebalance actions to execute (add collateral, remove collateral, borrow or repay)
/// @param tokenIn Token to transfer in. Transfer from caller to the LeverageManager contract
/// @param tokenOut Token to transfer out. Transfer from the LeverageManager contract to caller
/// @param amountIn Amount of tokenIn to transfer in
/// @param amountOut Amount of tokenOut to transfer out
/// @dev Anyone can call this function. At the end function will just check if the affected LeverageToken is in a
/// better state than before rebalance. Caller needs to calculate and to provide tokens for rebalancing and he needs
/// to specify tokens that he wants to receive
/// @dev Note: If the sender specifies less amountOut than the maximum amount they can retrieve for their specified
/// rebalance actions, the rebalance will still be successful. The remaining amount that could have been taken
/// out can be claimed by anyone by executing rebalance with that remaining amount in amountOut.
function rebalance(
ILeverageToken leverageToken,
RebalanceAction[] calldata actions,
IERC20 tokenIn,
IERC20 tokenOut,
uint256 amountIn,
uint256 amountOut
) external;
/// @notice Withdraws collateral from a LeverageToken and burns shares from sender
/// @param token The LeverageToken to withdraw from
/// @param collateral The amount of collateral to withdraw
/// @param maxShares The maximum amount of shares to burn
/// @return actionData Data about the withdraw
/// - collateral Amount of collateral that was removed from LeverageToken and sent to sender
/// - debt Amount of debt that was repaid to LeverageToken, taken from sender
/// - shares Amount of the sender's shares that were burned for the withdraw
/// - tokenFee Amount of shares that was charged for the withdraw that are given to the LeverageToken
/// - treasuryFee Amount of shares that was charged for the withdraw that are given to the treasury
function withdraw(ILeverageToken token, uint256 collateral, uint256 maxShares)
external
returns (ActionData memory actionData);
}
"
},
"src/interfaces/periphery/IPricingAdapter.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
// Internal imports
import {ILeverageManager} from "../ILeverageManager.sol";
import {ILeverageToken} from "../ILeverageToken.sol";
import {IAggregatorV2V3Interface} from "./IAggregatorV2V3Interface.sol";
interface IPricingAdapter {
/// @notice The LeverageManager contract
/// @return _leverageManager The LeverageManager contract
function leverageManager() external view returns (ILeverageManager _leverageManager);
/// @notice Returns the price of one LeverageToken (1e18 wei) denominated in collateral asset of the LeverageToken
/// @param leverageToken The LeverageToken to get the price for
/// @return price The price of one LeverageToken denominated in collateral asset
function getLeverageTokenPriceInCollateral(ILeverageToken leverageToken) external view returns (uint256);
/// @notice Returns the price of one LeverageToken (1e18 wei) denominated in debt asset of the LeverageToken
/// @param leverageToken The LeverageToken to get the price for
/// @return price The price of one LeverageToken denominated in debt asset
function getLeverageTokenPriceInDebt(ILeverageToken leverageToken) external view returns (uint256);
/// @notice Returns the price of one LeverageToken (1e18 wei) adjusted to the price on the Chainlink oracle
/// @param leverageToken The LeverageToken to get the price for
/// @param chainlinkOracle The Chainlink oracle to use for pricing
/// @param isBaseDebtAsset True if the debt asset is the base asset of the Chainlink oracle, false if the
/// collateral asset is the base asset
/// @return price The price of one LeverageToken adjusted to the price on the Chainlink oracle, with decimal
/// precision equal to the base asset decimals
function getLeverageTokenPriceAdjusted(
ILeverageToken leverageToken,
IAggregatorV2V3Interface chainlinkOracle,
bool isBaseDebtAsset
) external view returns (int256);
}
"
},
"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
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 value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` 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 value) external returns (bool);
}
"
},
"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/Math.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2²⁵⁶ + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 1);
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 1);
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
"
},
"src/interfaces/IFeeManager.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {ILeverageToken} from "./ILeverageToken.sol";
import {ExternalAction} from "src/types/DataTypes.sol";
interface IFeeManager {
/// @notice Error emitted when `FEE_MANAGER_ROLE` tries to set fee higher than `MAX_FEE`
/// @param fee The fee that was set
/// @param maxFee The maximum fee that can be set
error FeeTooHigh(uint256 fee, uint256 maxFee);
/// @notice Error emitted when trying to set the treasury address to the zero address
error ZeroAddressTreasury();
/// @notice Emitted when the default management fee for new LeverageTokens is updated
/// @param fee The default management fee for new LeverageTokens, 100_00 is 100%
event DefaultManagementFeeAtCreationSet(uint256 fee);
/// @notice Emitted when a LeverageToken fee is set for a specific action
/// @param leverageToken The LeverageToken that the fee was set for
/// @param action The action that the fee was set for
/// @param fee The fee that was set
event LeverageTokenActionFeeSet(ILeverageToken indexed leverageToken, ExternalAction indexed action, uint256 fee);
/// @notice Emitted when the management fee is charged for a LeverageToken
/// @param leverageToken The LeverageToken that the management fee was charged for
/// @param sharesFee The amount of shares that were minted to the treasury
event ManagementFeeCharged(ILeverageToken indexed leverageToken, uint256 sharesFee);
/// @notice Emitted when the management fee is set
/// @param token The LeverageToken that the management fee was set for
/// @param fee The fee that was set
event ManagementFeeSet(ILeverageToken indexed token, uint256 fee);
/// @notice Emitted when a treasury fee is set for a specific action
/// @param action The action that the fee was set for
/// @param fee The fee that was set
event TreasuryActionFeeSet(ExternalAction indexed action, uint256 fee);
/// @notice Emitted when the treasury address is set
/// @param treasury The address of the treasury
event TreasurySet(address treasury);
/// @notice Function that charges any accrued management fees for the LeverageToken by minting shares to the treasury
/// @param token LeverageToken to charge management fee for
/// @dev If the treasury is not set, the management fee is not charged (shares are not minted to the treasury) but
/// still accrues
function chargeManagementFee(ILeverageToken token) external;
/// @notice Returns the default management fee for new LeverageTokens
/// @return fee The default management fee for new LeverageTokens, 100_00 is 100%
function getDefaultManagementFeeAtCreation() external view returns (uint256 fee);
/// @notice Returns the total supply of the LeverageToken adjusted for any accrued management fees
/// @param token LeverageToken to get fee adjusted total supply for
/// @return totalSupply Fee adjusted total supply of the LeverageToken
function getFeeAdjustedTotalSupply(ILeverageToken token) external view returns (uint256 totalSupply);
/// @notiSubmitted on: 2025-09-30 10:15:38
Comments
Log in to comment.
No comments yet.