Source Code
Overview
ETH Balance
0 ETH
ETH Value
$0.00View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Cross-Chain Transactions
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
LSPRouter
Compiler Version
v0.8.26+commit.8a97fa7a
Optimization Enabled:
Yes with 100 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
import {PriceLib} from "../libraries/PriceLib.sol";
import {IMetaCore} from "../interfaces/core/IMetaCore.sol";
import {TokenValidationLib} from "../libraries/TokenValidationLib.sol";
import {ILiquidStabilityPool} from "../interfaces/core/ILiquidStabilityPool.sol";
import {ILiquidStabilityPoolGetters} from "../interfaces/core/helpers/ILSPGetters.sol";
import {ILSTCollateralVault} from "../interfaces/core/vaults/ILSTCollateralVault.sol";
import {IPriceFeed} from "../interfaces/core/IPriceFeed.sol";
import {IAsset} from "../interfaces/utils/tokens/IAsset.sol";
import {ICollVaultRouter} from "../interfaces/periphery/ICollVaultRouter.sol";
import {ILSPRouter} from "../interfaces/periphery/ILSPRouter.sol";
import {IWNative} from "../interfaces/utils/tokens/IWNATIVE.sol";
import {UtilsLib} from "../libraries/UtilsLib.sol";
import {SwappersLib} from "../libraries/SwappersLib.sol";
import {FeeLib} from "../libraries/FeeLib.sol";
/// @dev Doesn't have DelegatedOps functionality
contract LSPRouter is ILSPRouter {
using SwappersLib for SwappersLib.SwapperData;
using SafeERC20 for IERC20;
using PriceLib for uint;
using TokenValidationLib for address;
using TokenValidationLib for ILSTCollateralVault;
using TokenValidationLib for address[];
using DynamicArrayLib for DynamicArrayLib.DynamicArray;
using DynamicArrayLib for address[];
using DynamicArrayLib for uint[];
using UtilsLib for bytes;
using FeeLib for uint;
uint16 constant BP = 1e4;
SwappersLib.SwapperData internal swapperData;
IWNative immutable wNative;
ILiquidStabilityPool immutable lsp;
ILiquidStabilityPoolGetters immutable lspGetters;
ICollVaultRouter immutable collVaultRouter;
address immutable debtToken;
ILSTCollateralVault immutable mainRewardTokenVault;
uint8 immutable debtTokenDecimals;
IPriceFeed immutable priceFeed;
IMetaCore immutable metaCore;
modifier onlyOwner() {
require(msg.sender == metaCore.owner(), "LSPRouter: Only owner");
_;
}
constructor(address _lsp, address _lspGetters, address _collVaultRouter, address _priceFeed, address _metaCore, address _wNative, address _mainRewardTokenVault, address[] memory routers) {
if (_lsp == address(0) || _lspGetters == address(0) || _collVaultRouter == address(0) || _priceFeed == address(0) || _metaCore == address(0) || _wNative == address(0)) {
revert("LSPRouter: 0 address");
}
lsp = ILiquidStabilityPool(_lsp);
lspGetters = ILiquidStabilityPoolGetters(_lspGetters);
collVaultRouter = ICollVaultRouter(_collVaultRouter);
priceFeed = IPriceFeed(_priceFeed);
metaCore = IMetaCore(_metaCore);
wNative = IWNative(_wNative);
mainRewardTokenVault = ILSTCollateralVault(_mainRewardTokenVault);
debtToken = lsp.asset();
debtTokenDecimals = IAsset(debtToken).decimals();
// add routers on constructor
for (uint i; i < routers.length; i++) {
SwappersLib.addWhitelistedSwapper(swapperData, routers[i], true);
}
}
function redeemToOne(
ILSPRouter.RedeemToOneParams calldata params
) external returns (uint assets, uint totalAmountOut) {
address[] memory tokensToClaim = lspUnderlyingTokens();
Arr memory arr = _initArr(tokensToClaim, address(this));
(, address[] memory tokens,) = previewRedeem(params.shares, params.caller);
uint[] memory underlyingCurrAmounts = tokens.underlyingAmounts(arr.receiver);
assets = lsp.redeem(params.shares, arr.receiver, msg.sender);
require(assets >= params.minAssetsWithdrawn, "LSPRouter: assetsWithdrawn < minAssetsWithdrawn");
totalAmountOut = _unwrapAndSwapToOne(
UnwrapSwapToOneParams({
tokens: tokens,
tokensToClaim: tokensToClaim,
arr: arr,
targetToken: params.targetToken,
receiver: params.receiver,
minTargetTokenAmount: params.minTargetTokenAmount,
swapRouter: params.swapRouter,
tokensSwapCalldatas: params.tokensSwapCalldatas,
underlyingCurrAmounts: underlyingCurrAmounts
})
);
}
/**
* @notice Redeems sDEBT_TOKEN for preferred underlying tokens, features unwrapping and multiple levels of slippage protection
* @dev If no unwrapping, tokens are directly sent to the receiver, if unwrapping, tokens are sent to the receiver after unwrapping
* @dev If any token does calls, a griefer could get control of the transaction flow and potentially withdraw locked tokens by increasing the amount received when not unwrapping
*
* @param params Struct containing the following parameters:
* - shares: Amount of sDEBT_TOKEN to burn
* - redeemedTokensLength: In case collateral or extraAsset lsp balance is 0, omit it
* - preferredUnderlyingTokens: Array sorted by preference of withdrawal
* - receiver: Address to receive the underlying tokens
* - _owner: Address of the sDEBT_TOKEN owner
* - minAssetsWithdrawn: Minimum expected of assets denominated in $DEBT_TOKEN to be withdrawn
* - unwrap: Whether to unwrap collVaults underlying tokens
*/
function redeemPreferredUnderlying(
ILSPRouter.RedeemPreferredUnderlyingParams calldata params
) external returns (uint assets, address[] memory tokens, uint[] memory amounts) {
Arr memory arr = _initArr(params.preferredUnderlyingTokens, params.unwrap ? address(this) : params.receiver);
uint[] memory underlyingCurrAmounts;
if (params.unwrap) {
/// @dev List of tokens we expect to receive after unwrapping all collVaults
(, tokens,) = previewRedeemPreferredUnderlying(params.shares, params.preferredUnderlyingTokens, params.caller, params.unwrap);
underlyingCurrAmounts = tokens.underlyingAmounts(arr.receiver);
} else {
tokens = params.preferredUnderlyingTokens;
}
assets = lsp.redeem(params.shares, params.preferredUnderlyingTokens, arr.receiver, msg.sender);
require(assets >= params.minAssetsWithdrawn, "LSPRouter: assetsWithdrawn < minAssetsWithdrawn");
amounts = _processUnderlyingTokens(arr, tokens, params.preferredUnderlyingTokens, underlyingCurrAmounts, params.receiver, params.unwrap);
}
/// @dev Auto unwraps and swaps all to the target token
function redeemPreferredUnderlyingToOne(
ILSPRouter.RedeemPreferredUnderlyingToOneParams calldata params
) external returns (uint assets, uint totalAmountOut) {
require(params.preferredUnderlyingTokens.length != 0, "tokens length is zero");
Arr memory arr = _initArr(params.preferredUnderlyingTokens, address(this));
/// @dev List of tokens we expect to receive after unwrapping all collVaults
(, address[] memory tokens,) = previewRedeemPreferredUnderlying(params.shares, params.preferredUnderlyingTokens, params.caller, true);
uint[] memory underlyingCurrAmounts = tokens.underlyingAmounts(arr.receiver);
assets = lsp.redeem(params.shares, params.preferredUnderlyingTokens, arr.receiver, msg.sender);
require(assets >= params.minAssetsWithdrawn, "LSPRouter: assetsWithdrawn < minAssetsWithdrawn");
totalAmountOut = _unwrapAndSwapToOne(
UnwrapSwapToOneParams({
tokens: tokens,
tokensToClaim: params.preferredUnderlyingTokens,
arr: arr,
targetToken: params.targetToken,
receiver: params.receiver,
minTargetTokenAmount: params.minTargetTokenAmount,
swapRouter: params.swapRouter,
tokensSwapCalldatas: params.tokensSwapCalldatas,
underlyingCurrAmounts: underlyingCurrAmounts
})
);
}
function _unwrapAndSwapToOne(
UnwrapSwapToOneParams memory params
) internal returns (uint totalAmountOut) {
address[] memory _tokens = new address[](params.tokens.length);
bool firstCollVaultFound;
uint[] memory currAmounts = params.tokensToClaim.underlyingAmounts(address(this));
for (uint i; i < params.tokensToClaim.length; i++) {
uint amount = currAmounts[i] - params.arr.prevAmounts[i];
if (amount > 0) {
if (priceFeed.isCollVault(params.tokensToClaim[i])) {
if (!firstCollVaultFound && address(mainRewardTokenVault) != address(0)) {
_addMainRewardTokenVaultRewardTokens(_tokens);
firstCollVaultFound = true;
}
ILSTCollateralVault collVault = ILSTCollateralVault(params.tokensToClaim[i]);
_withdrawUnderlyingCollVaultAssets(
collVault,
amount,
_tokens
);
} else {
_aggregateIfNotExistentWithoutAmounts(_tokens, params.tokensToClaim[i]);
}
}
}
uint[] memory swapAmounts = new uint[](params.tokens.length);
for (uint i; i < params.tokens.length; i++) {
if (params.tokens[i] != _tokens[i]) revert TokenPreviewMismatch(i, _tokens[i], params.tokens[i]);
swapAmounts[i] = IERC20(_tokens[i]).balanceOf(address(this)) - params.underlyingCurrAmounts[i];
}
totalAmountOut = _swapToTargetToken(
params.targetToken,
ILSPRouter.SwapAllTokensToOneParams({
receiver: params.receiver,
minTargetTokenAmount: params.minTargetTokenAmount,
swapRouter: params.swapRouter,
tokensSwapCalldatas: params.tokensSwapCalldatas
}),
_tokens,
swapAmounts
);
}
function redeem(
ILSPRouter.RedeemWithoutPrederredUnderlyingParams calldata params
) external returns (uint assets, address[] memory tokens, uint[] memory amounts) {
address[] memory tokensToClaim = lspUnderlyingTokens();
Arr memory arr = _initArr(tokensToClaim, params.unwrap ? address(this) : params.receiver);
uint[] memory underlyingCurrAmounts;
if (params.unwrap) {
/// @dev List of tokens we expect to receive after unwrapping all collVaults
(, tokens,) = previewRedeem(params.shares, params.caller);
underlyingCurrAmounts = tokens.underlyingAmounts(arr.receiver);
} else {
tokens = tokensToClaim;
}
// Call redeem without preferred tokens
assets = lsp.redeem(params.shares, arr.receiver, msg.sender);
require(assets >= params.minAssetsWithdrawn, "LSPRouter: assetsWithdrawn < minAssetsWithdrawn");
amounts = _processUnderlyingTokens(arr, tokens, tokensToClaim, underlyingCurrAmounts, params.receiver, params.unwrap);
}
function withdraw(
ILSPRouter.WithdrawFromLSPParams calldata params
) external returns (uint shares, address[] memory tokens, uint[] memory amounts) {
address[] memory tokensToClaim = lspUnderlyingTokens();
Arr memory arr = _initArr(tokensToClaim, params.unwrap ? address(this) : params.receiver);
uint[] memory underlyingCurrAmounts;
if (params.unwrap) {
/// @dev Amount passed is not important since we're only using returned tokens, but for being precise we convert to shares
shares = lsp.previewWithdraw(params.assets);
/// @dev List of tokens we expect to receive after unwrapping all collVaults
(, tokens,) = previewRedeem(shares, params.caller);
underlyingCurrAmounts = tokens.underlyingAmounts(arr.receiver);
} else {
tokens = tokensToClaim;
}
// Call redeem without preferred tokens
shares = lsp.withdraw(params.assets, arr.receiver, msg.sender);
require(shares <= params.maxSharesWithdrawn, "LSPRouter: sharesWithdrawn > maxSharesWithdrawn");
amounts = _processUnderlyingTokens(arr, tokens, tokensToClaim, underlyingCurrAmounts, params.receiver, params.unwrap);
}
function _processUnderlyingTokens(
Arr memory arr,
address[] memory tokens,
address[] memory tokensToClaim,
uint[] memory underlyingCurrAmounts,
address receiver,
bool unwrap
) internal returns (uint[] memory amounts) {
address[] memory _tokens = new address[](tokens.length);
uint[] memory _amounts = new uint[](tokens.length);
uint[] memory currAmounts = tokensToClaim.underlyingAmounts(arr.receiver);
bool firstCollVaultFound;
if (unwrap) {
for (uint i; i < tokensToClaim.length; i++) {
uint amount = currAmounts[i] - arr.prevAmounts[i];
if (amount > 0) {
if (priceFeed.isCollVault(tokensToClaim[i])) {
if (!firstCollVaultFound && address(mainRewardTokenVault) != address(0)) {
_addMainRewardTokenVaultRewardTokens(_tokens);
firstCollVaultFound = true;
}
ILSTCollateralVault collVault = ILSTCollateralVault(tokensToClaim[i]);
_withdrawUnderlyingCollVaultAssets(
collVault,
amount,
_tokens
);
} else {
_aggregateIfNotExistentWithoutAmounts(_tokens, tokensToClaim[i]);
}
}
}
for (uint i; i < tokens.length; i++) {
if (tokens[i] != _tokens[i]) revert TokenPreviewMismatch(i, _tokens[i], tokens[i]);
_amounts[i] = IERC20(_tokens[i]).balanceOf(address(this)) - underlyingCurrAmounts[i];
IERC20(_tokens[i]).safeTransfer(receiver, _amounts[i]);
}
amounts = _amounts;
} else {
amounts = new uint[](tokens.length);
for (uint i; i < tokens.length; i++) {
amounts[i] = currAmounts[i] - arr.prevAmounts[i];
}
}
}
function deposit(
DepositTokenParams calldata params
) external payable returns (uint shares) {
address assetToken = debtToken;
uint assets;
if (msg.value != 0) {
require(params.inputToken == address(wNative), "Passed msg.value with non-WNATIVE");
require(msg.value == params.inputAmount, "msg.value != inputAmount");
wNative.deposit{value: params.inputAmount}();
} else {
IERC20(params.inputToken).safeTransferFrom(msg.sender, address(this), params.inputAmount);
}
// If input token is not debtToken, swap it to debtToken
if (params.inputToken != assetToken) {
IERC20(params.inputToken).safeIncreaseAllowance(address(params.swapRouter), params.inputAmount);
uint prevBalance = IERC20(assetToken).balanceOf(address(this));
SwappersLib.executeSwap(swapperData, params.swapRouter, params.dexCalldata);
assets = IERC20(assetToken).balanceOf(address(this)) - prevBalance;
} else {
assets = params.inputAmount;
}
IERC20(assetToken).approve(address(lsp), assets);
shares = lsp.deposit(assets, params.receiver);
require(shares >= params.minSharesReceived, "LSPRouter: received shares less than minimum");
}
function _swapToTargetToken(
address targetToken,
ILSPRouter.SwapAllTokensToOneParams memory params,
address[] memory _tokens,
uint[] memory _amounts
) private returns (uint targetTokenAmountOut) {
uint tokensLength = _tokens.length;
uint prevTargetTokenAmount = IERC20(targetToken).balanceOf(params.receiver);
for (uint i; i < tokensLength; i++) {
uint amount = _amounts[i];
address _token = _tokens[i];
if (_token != targetToken) {
if (amount > 0 && params.tokensSwapCalldatas[i].length > 0) {
IERC20(_token).safeIncreaseAllowance(address(params.swapRouter), amount);
SwappersLib.executeSwap(swapperData, params.swapRouter, params.tokensSwapCalldatas[i]);
}
} else {
IERC20(targetToken).safeTransfer(params.receiver, amount);
}
}
targetTokenAmountOut = IERC20(targetToken).balanceOf(params.receiver) - prevTargetTokenAmount;
require(targetTokenAmountOut >= params.minTargetTokenAmount, "LSPRouter: targetTokenAmountOut < minTargetTokenAmount");
}
function _withdrawUnderlyingCollVaultAssets(
ILSTCollateralVault collVault,
uint amount,
address[] memory tokens
) private {
// Note: We acknowledge that it may not have track of newly added tokens to the underlying LSTVault
address[] memory underlyingTokens = collVault.tryGetRewardedTokens();
(address[] memory rewardTokens, uint length) = underlyingTokens.pushIfNotIncluded(collVault.asset());
for (uint i; i < length; i++) {
// if token is mainRewardTokenvault continue as it is unwrapped at vault lvl
if (rewardTokens[i] == address(mainRewardTokenVault)) continue;
// ignore tokens with 0 balance, without accounting `lstVault.earned()`
if (collVault.getBalance(rewardTokens[i]) * amount / collVault.totalSupply() == 0) continue;
_aggregateIfNotExistentWithoutAmounts(tokens, rewardTokens[i]);
}
collVault.redeem(amount, address(this), address(this));
}
function previewRedeemedAssetsByCaller(uint shares, address caller) public view returns (uint) {
uint defaultFeeBP = metaCore.lspExitFee();
uint callerFeeBP = metaCore.getLspExitFee(caller);
uint adjustedShares = shares * (BP - callerFeeBP) / (BP - defaultFeeBP);
return lsp.previewRedeem(adjustedShares);
}
function previewRedeem(uint shares, address caller)
public
view
returns (uint assets, address[] memory tokens, uint[] memory amounts)
{
// Use all underlying tokens for pro-rata redemption
address[] memory underlyingTokens = lspUnderlyingTokens();
uint length = underlyingTokens.length;
// Simulate total assets redeemed based on shares
assets = previewRedeemedAssetsByCaller(shares, caller);
// Simulate expected withdrawal amounts for each underlying token
uint[] memory expectedAmounts = _simulateWithdraw(shares, underlyingTokens, caller);
DynamicArrayLib.DynamicArray memory _tokens;
DynamicArrayLib.DynamicArray memory _amounts;
bool firstCollVaultFound;
for (uint i; i < length; i++) {
if (expectedAmounts[i] > 0) {
// If the token is from a collateral vault, simulate withdrawal and add any reward tokens once
if (priceFeed.isCollVault(underlyingTokens[i])) {
if (!firstCollVaultFound && address(mainRewardTokenVault) != address(0)) {
address[] memory mainRewardTokenVaultRewardedTokens = mainRewardTokenVault.tryGetRewardedTokens();
uint mainRewardTokenVaultRewardedLength = mainRewardTokenVaultRewardedTokens.length;
for (uint j; j < mainRewardTokenVaultRewardedLength; j++) {
if (mainRewardTokenVault.getBalance(mainRewardTokenVaultRewardedTokens[j]) == 0) continue;
TokenValidationLib.aggregateIfNotExistent(mainRewardTokenVaultRewardedTokens[j], 0, _tokens, _amounts);
}
firstCollVaultFound = true;
}
ILSTCollateralVault collVault = ILSTCollateralVault(underlyingTokens[i]);
_previewWithdrawUnderlyingCollVaultAssets(collVault, expectedAmounts[i], _tokens, _amounts);
} else {
TokenValidationLib.aggregateIfNotExistent(underlyingTokens[i], expectedAmounts[i], _tokens, _amounts);
}
}
}
tokens = _tokens.asAddressArray();
amounts = _amounts.asUint256Array();
}
function previewRedeemPreferredUnderlying(uint shares, address[] calldata preferredUnderlyingTokens, address caller, bool unwrap) public view returns (uint assets, address[] memory tokens, uint[] memory amounts) {
uint length = preferredUnderlyingTokens.length;
// Get sDEBT_TOKEN collateral + extra assets + DEBT_TOKEN withdraw amounts based on share amount
assets = previewRedeemedAssetsByCaller(shares, caller);
uint[] memory expectedAmounts = _simulateWithdrawPreferredUnderlying(assets, preferredUnderlyingTokens);
DynamicArrayLib.DynamicArray memory _tokens;
DynamicArrayLib.DynamicArray memory _amounts;
bool firstCollVaultFound;
if (unwrap) {
for (uint i; i < length; i++) {
address token = preferredUnderlyingTokens[i];
if (expectedAmounts[i] > 0) {
if (priceFeed.isCollVault(token)) {
// If first collVault found, add mainRewardTokenVault reward tokens, since all collVaults deposit mainRewardToken into mainRewardTokenVault
if (!firstCollVaultFound && address(mainRewardTokenVault) != address(0)) {
address[] memory mainRewardTokenVaultRewardedTokens = mainRewardTokenVault.tryGetRewardedTokens();
uint mainRewardTokenVaultRewardedLength = mainRewardTokenVaultRewardedTokens.length;
for (uint j; j < mainRewardTokenVaultRewardedLength; j++) {
if (mainRewardTokenVault.getBalance(mainRewardTokenVaultRewardedTokens[j]) == 0) continue;
TokenValidationLib.aggregateIfNotExistent(mainRewardTokenVaultRewardedTokens[j], 0, _tokens, _amounts);
}
firstCollVaultFound = true;
}
ILSTCollateralVault collVault = ILSTCollateralVault(token);
_previewWithdrawUnderlyingCollVaultAssets(
collVault,
expectedAmounts[i],
_tokens,
_amounts
);
} else {
TokenValidationLib.aggregateIfNotExistent(token, expectedAmounts[i], _tokens, _amounts);
}
}
}
tokens = _tokens.asAddressArray();
amounts = _amounts.asUint256Array();
} else {
for (uint i; i < length; i++) {
if (expectedAmounts[i] > 0) {
TokenValidationLib.aggregateIfNotExistent(preferredUnderlyingTokens[i], expectedAmounts[i], _tokens, _amounts);
}
}
tokens = _tokens.asAddressArray();
amounts = _amounts.asUint256Array();
}
}
function _simulateWithdraw(uint shares, address[] memory tokens, address caller)
internal
view
returns (uint[] memory expectedAmounts)
{
expectedAmounts = new uint[](tokens.length);
uint fee = shares.feeOnRaw(metaCore.getLspExitFee(caller));
shares -= fee;
uint totalSupply = lsp.totalSupply();
require(totalSupply > 0, "No total supply");
for (uint i; i < tokens.length; i++) {
uint tokenVirtualBalance = lspGetters.getTokenVirtualBalance(tokens[i]);
expectedAmounts[i] = shares * tokenVirtualBalance / totalSupply;
}
}
/// @dev Reproduces the internal function `LSP::_withdrawPreferredUnderlying`
/// @dev Remaining assets should always be 0 after the loop
function _simulateWithdrawPreferredUnderlying(uint assets, address[] memory preferredUnderlyingTokens) private view returns (uint[] memory amounts) {
address[] memory collaterals = lsp.getCollateralTokens();
address[] memory extraAssets = lspGetters.extraAssets();
uint collateralsLength = collaterals.length;
uint length = preferredUnderlyingTokens.length;
amounts = new uint[](length);
require(length == collateralsLength + extraAssets.length + 1, "LSPRouter: preferredUnderlyingTokens length mismatch");
require(preferredUnderlyingTokens[length - 1] == debtToken, "LSPRouter: Last token must be DEBT_TOKEN");
preferredUnderlyingTokens.checkForDuplicates(length);
uint remainingAssets = assets;
uint debtTokenPrice = priceFeed.fetchPrice(debtToken);
for (uint i; i < length && remainingAssets != 0; i++) {
address token = preferredUnderlyingTokens[i];
token.checkValidToken(collaterals, collateralsLength, debtToken, lspGetters.containsExtraAsset(token));
uint unlockedBalance = lspGetters.getTokenVirtualBalance(token);
if (unlockedBalance == 0) continue;
uint tokenPrice = priceFeed.fetchPrice(token);
if (tokenPrice == 0) continue;
uint8 tokenDecimals = IAsset(token).decimals();
uint amount = remainingAssets.convertAssetsToCollAmount(
tokenPrice,
debtTokenPrice,
debtTokenDecimals,
tokenDecimals,
Math.Rounding.Down
);
if (unlockedBalance >= amount) {
remainingAssets = 0;
} else {
uint remainingColl = amount - unlockedBalance;
remainingAssets = remainingColl.convertCollAmountToAssets(
tokenPrice,
debtTokenPrice,
debtTokenDecimals,
tokenDecimals
);
amount = unlockedBalance;
}
if (amount > 0) {
amounts[i] = amount;
}
}
}
function _previewWithdrawUnderlyingCollVaultAssets(
ILSTCollateralVault collVault,
uint amount,
DynamicArrayLib.DynamicArray memory tokens,
DynamicArrayLib.DynamicArray memory amounts
) private view {
(address[] memory _expectedTokens, uint[] memory _expectedAmounts) = collVaultRouter.previewRedeemUnderlying(collVault, amount);
uint length = _expectedTokens.length;
for (uint i; i < length; i++) {
uint vaultUnderlyingAmount = _expectedAmounts[i];
address token = _expectedTokens[i];
if (vaultUnderlyingAmount > 0) {
TokenValidationLib.aggregateIfNotExistent(token, vaultUnderlyingAmount, tokens, amounts);
}
}
}
function lspUnderlyingTokens() public view returns (address[] memory tokens) {
address[] memory collaterals = lspGetters.collateralTokens();
address[] memory extraAssets = lspGetters.extraAssets();
uint collateralsLength = collaterals.length;
uint extraAssetsLength = extraAssets.length;
uint length = collateralsLength + extraAssetsLength + 1;
tokens = new address[](length);
for (uint i; i < collateralsLength; i++) {
tokens[i] = collaterals[i];
}
for (uint i = collateralsLength; i < length - 1; i++) {
tokens[i] = extraAssets[i - collateralsLength];
}
tokens[length - 1] = debtToken;
}
function claimLockedTokens(IERC20[] calldata tokens, uint[] calldata amounts) external {
require(msg.sender == metaCore.owner(), "Only owner");
uint length = tokens.length;
for (uint i; i < length; i++) {
if (address(tokens[i]) == address(0)) {
(bool success,) = metaCore.feeReceiver().call{value: amounts[i]}("");
require(success, "ETH transfer failed");
} else {
tokens[i].safeTransfer(metaCore.feeReceiver(), amounts[i]);
}
}
}
/// @notice Aggregates token if not in the array
/// @dev Warning, modifies memory references
function _aggregateIfNotExistentWithoutAmounts(
address[] memory tokens,
address token
) internal pure {
uint length = tokens.length;
for (uint i; i < length; i++) {
if (tokens[i] == token) {
return;
}
if (tokens[i] == address(0)) {
tokens[i] = token;
return;
}
}
revert("LSPRouter: array full");
}
function _addMainRewardTokenVaultRewardTokens(address[] memory tokens) internal view {
address[] memory mainRewardTokenVaultRewardedTokens = mainRewardTokenVault.tryGetRewardedTokens();
for (uint i; i < mainRewardTokenVaultRewardedTokens.length; i++) {
if (mainRewardTokenVault.getBalance(mainRewardTokenVaultRewardedTokens[i]) == 0) continue;
_aggregateIfNotExistentWithoutAmounts(tokens, mainRewardTokenVaultRewardedTokens[i]);
}
}
function addWhitelistedSwapper(address _swapRouter, bool status) external onlyOwner {
SwappersLib.addWhitelistedSwapper(swapperData,_swapRouter, status);
}
function _initArr(address[] memory preferredUnderlyingTokens, address account) private view returns (Arr memory arr) {
arr.prevAmounts = preferredUnderlyingTokens.underlyingAmounts(account);
arr.receiver = account;
}
}// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol) pragma solidity ^0.8.0; import "../token/ERC20/IERC20.sol";
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return 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 up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev 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^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 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.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
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^256 / 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^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
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^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// 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^256. Since the preconditions guarantee that the outcome is
// less than 2^256, 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;
}
}
/**
* @notice 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) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* 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;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
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 log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Library for memory arrays with automatic capacity resizing.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/DynamicArrayLib.sol)
library DynamicArrayLib {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRUCTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Type to represent a dynamic array in memory.
/// You can directly assign to `data`, and the `p` function will
/// take care of the memory allocation.
struct DynamicArray {
uint256[] data;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The constant returned when the element is not found in the array.
uint256 internal constant NOT_FOUND = type(uint256).max;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* UINT256 ARRAY OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// Low level minimalist uint256 array operations.
// If you don't need syntax sugar, it's recommended to use these.
// Some of these functions returns the same array for function chaining.
// `e.g. `array.set(0, 1).set(1, 2)`.
/// @dev Returns a uint256 array with `n` elements. The elements are not zeroized.
function malloc(uint256 n) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := or(sub(0, shr(32, n)), mload(0x40))
mstore(result, n)
mstore(0x40, add(add(result, 0x20), shl(5, n)))
}
}
/// @dev Zeroizes all the elements of `a`.
function zeroize(uint256[] memory a) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
codecopy(add(result, 0x20), codesize(), shl(5, mload(result)))
}
}
/// @dev Returns the element at `a[i]`, without bounds checking.
function get(uint256[] memory a, uint256 i) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a[i]`, without bounds checking.
function getUint256(uint256[] memory a, uint256 i) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a[i]`, without bounds checking.
function getAddress(uint256[] memory a, uint256 i) internal pure returns (address result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a[i]`, without bounds checking.
function getBool(uint256[] memory a, uint256 i) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a[i]`, without bounds checking.
function getBytes32(uint256[] memory a, uint256 i) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(uint256[] memory a, uint256 i, uint256 data)
internal
pure
returns (uint256[] memory result)
{
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(result, 0x20), shl(5, i)), data)
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(uint256[] memory a, uint256 i, address data)
internal
pure
returns (uint256[] memory result)
{
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(result, 0x20), shl(5, i)), shr(96, shl(96, data)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(uint256[] memory a, uint256 i, bool data)
internal
pure
returns (uint256[] memory result)
{
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(result, 0x20), shl(5, i)), iszero(iszero(data)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(uint256[] memory a, uint256 i, bytes32 data)
internal
pure
returns (uint256[] memory result)
{
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(result, 0x20), shl(5, i)), data)
}
}
/// @dev Casts `a` to `address[]`.
function asAddressArray(uint256[] memory a) internal pure returns (address[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Casts `a` to `bool[]`.
function asBoolArray(uint256[] memory a) internal pure returns (bool[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Casts `a` to `bytes32[]`.
function asBytes32Array(uint256[] memory a) internal pure returns (bytes32[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Casts `a` to `uint256[]`.
function toUint256Array(address[] memory a) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Casts `a` to `uint256[]`.
function toUint256Array(bool[] memory a) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Casts `a` to `uint256[]`.
function toUint256Array(bytes32[] memory a) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
}
}
/// @dev Reduces the size of `a` to `n`.
/// If `n` is greater than the size of `a`, this will be a no-op.
function truncate(uint256[] memory a, uint256 n)
internal
pure
returns (uint256[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
result := a
mstore(mul(lt(n, mload(result)), result), n)
}
}
/// @dev Clears the array and attempts to free the memory if possible.
function free(uint256[] memory a) internal pure returns (uint256[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := a
let n := mload(result)
mstore(shl(6, lt(iszero(n), eq(add(shl(5, add(1, n)), result), mload(0x40)))), result)
mstore(result, 0)
}
}
/// @dev Equivalent to `keccak256(abi.encodePacked(a))`.
function hash(uint256[] memory a) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
result := keccak256(add(a, 0x20), shl(5, mload(a)))
}
}
/// @dev Returns a copy of `a` sliced from `start` to `end` (exclusive).
function slice(uint256[] memory a, uint256 start, uint256 end)
internal
pure
returns (uint256[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
let arrayLen := mload(a)
if iszero(gt(arrayLen, end)) { end := arrayLen }
if iszero(gt(arrayLen, start)) { start := arrayLen }
if lt(start, end) {
result := mload(0x40)
let resultLen := sub(end, start)
mstore(result, resultLen)
a := add(a, shl(5, start))
// Copy the `a` one word at a time, backwards.
let o := add(shl(5, resultLen), 0x20)
mstore(0x40, add(result, o)) // Allocate memory.
for {} 1 {} {
mstore(add(result, o), mload(add(a, o)))
o := sub(o, 0x20)
if iszero(o) { break }
}
}
}
}
/// @dev Returns if `needle` is in `a`.
function contains(uint256[] memory a, uint256 needle) internal pure returns (bool) {
return ~indexOf(a, needle, 0) != 0;
}
/// @dev Returns the first index of `needle`, scanning forward from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(uint256[] memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
result := not(0)
if lt(from, mload(a)) {
let o := add(a, shl(5, from))
let end := add(shl(5, add(1, mload(a))), a)
let c := mload(end) // Cache the word after the array.
for { mstore(end, needle) } 1 {} {
o := add(o, 0x20)
if eq(mload(o), needle) { break }
}
mstore(end, c) // Restore the word after the array.
if iszero(eq(o, end)) { result := shr(5, sub(o, add(0x20, a))) }
}
}
}
/// @dev Returns the first index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(uint256[] memory a, uint256 needle) internal pure returns (uint256 result) {
result = indexOf(a, needle, 0);
}
/// @dev Returns the last index of `needle`, scanning backwards from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(uint256[] memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
result := not(0)
let n := mload(a)
if n {
if iszero(lt(from, n)) { from := sub(n, 1) }
let o := add(shl(5, add(2, from)), a)
for { mstore(a, needle) } 1 {} {
o := sub(o, 0x20)
if eq(mload(o), needle) { break }
}
mstore(a, n) // Restore the length.
if iszero(eq(o, a)) { result := shr(5, sub(o, add(0x20, a))) }
}
}
}
/// @dev Returns the first index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(uint256[] memory a, uint256 needle)
internal
pure
returns (uint256 result)
{
result = lastIndexOf(a, needle, NOT_FOUND);
}
/// @dev Directly returns `a` without copying.
function directReturn(uint256[] memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
mstore(retStart, 0x20)
return(retStart, add(0x40, shl(5, mload(a))))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DYNAMIC ARRAY OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// Some of these functions returns the same array for function chaining.
// `e.g. `a.p("1").p("2")`.
/// @dev Shorthand for `a.data.length`.
function length(DynamicArray memory a) internal pure returns (uint256) {
return a.data.length;
}
/// @dev Wraps `a` in a dynamic array struct.
function wrap(uint256[] memory a) internal pure returns (DynamicArray memory result) {
result.data = a;
}
/// @dev Wraps `a` in a dynamic array struct.
function wrap(address[] memory a) internal pure returns (DynamicArray memory result) {
/// @solidity memory-safe-assembly
assembly {
mstore(result, a)
}
}
/// @dev Wraps `a` in a dynamic array struct.
function wrap(bool[] memory a) internal pure returns (DynamicArray memory result) {
/// @solidity memory-safe-assembly
assembly {
mstore(result, a)
}
}
/// @dev Wraps `a` in a dynamic array struct.
function wrap(bytes32[] memory a) internal pure returns (DynamicArray memory result) {
/// @solidity memory-safe-assembly
assembly {
mstore(result, a)
}
}
/// @dev Clears the array without deallocating the memory.
function clear(DynamicArray memory a) internal pure returns (DynamicArray memory result) {
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(mload(result), 0)
}
}
/// @dev Clears the array and attempts to free the memory if possible.
function free(DynamicArray memory a) internal pure returns (DynamicArray memory result) {
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
let arrData := mload(result)
if iszero(eq(arrData, 0x60)) {
let prime := 8188386068317523
let cap := mload(sub(arrData, 0x20))
// Extract `cap`, initializing it to zero if it is not a multiple of `prime`.
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
// If `cap` is non-zero and the memory is contiguous, we can free it.
if lt(iszero(cap), eq(mload(0x40), add(arrData, add(0x20, cap)))) {
mstore(0x40, sub(arrData, 0x20))
}
mstore(result, 0x60)
}
}
}
/// @dev Resizes the array to contain `n` elements. New elements will be zeroized.
function resize(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
reserve(result, n);
/// @solidity memory-safe-assembly
assembly {
let arrData := mload(result)
let arrLen := mload(arrData)
if iszero(lt(n, arrLen)) {
codecopy(add(arrData, shl(5, add(1, arrLen))), codesize(), shl(5, sub(n, arrLen)))
}
mstore(arrData, n)
}
}
/// @dev Increases the size of `a` to `n`.
/// If `n` is less than the size of `a`, this will be a no-op.
/// This method does not zeroize any newly created elements.
function expand(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
if (n >= a.data.length) {
reserve(result, n);
/// @solidity memory-safe-assembly
assembly {
mstore(mload(result), n)
}
}
}
/// @dev Reduces the size of `a` to `n`.
/// If `n` is greater than the size of `a`, this will be a no-op.
function truncate(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(mul(lt(n, mload(mload(result))), mload(result)), n)
}
}
/// @dev Reserves at least `minimum` amount of contiguous memory.
function reserve(DynamicArray memory a, uint256 minimum)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
if iszero(lt(minimum, 0xffffffff)) { invalid() } // For extra safety.
for { let arrData := mload(a) } 1 {} {
// Some random prime number to multiply `cap`, so that
// we know that the `cap` is for a dynamic array.
// Selected to be larger than any memory pointer realistically.
let prime := 8188386068317523
// Special case for `arrData` pointing to zero pointer.
if eq(arrData, 0x60) {
let newCap := shl(5, add(1, minimum))
let capSlot := mload(0x40)
mstore(capSlot, mul(prime, newCap)) // Store the capacity.
let newArrData := add(0x20, capSlot)
mstore(newArrData, 0) // Store the length.
mstore(0x40, add(newArrData, add(0x20, newCap))) // Allocate memory.
mstore(a, newArrData)
break
}
let w := not(0x1f)
let cap := mload(add(arrData, w)) // `mload(sub(arrData, w))`.
// Extract `cap`, initializing it to zero if it is not a multiple of `prime`.
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
let newCap := shl(5, minimum)
// If we don't need to grow the memory.
if iszero(and(gt(minimum, mload(arrData)), gt(newCap, cap))) { break }
// If the memory is contiguous, we can simply expand it.
if eq(mload(0x40), add(arrData, add(0x20, cap))) {
mstore(add(arrData, w), mul(prime, newCap)) // Store the capacity.
mstore(0x40, add(arrData, add(0x20, newCap))) // Expand the memory allocation.
break
}
let capSlot := mload(0x40)
let newArrData := add(capSlot, 0x20)
mstore(0x40, add(newArrData, add(0x20, newCap))) // Reallocate the memory.
mstore(a, newArrData) // Store the `newArrData`.
// Copy `arrData` one word at a time, backwards.
for { let o := add(0x20, shl(5, mload(arrData))) } 1 {} {
mstore(add(newArrData, o), mload(add(arrData, o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
mstore(capSlot, mul(prime, newCap)) // Store the capacity.
mstore(newArrData, mload(arrData)) // Store the length.
break
}
}
}
/// @dev Appends `data` to `a`.
function p(DynamicArray memory a, uint256 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
let arrData := mload(a)
let newArrLen := add(mload(arrData), 1)
let newArrBytesLen := shl(5, newArrLen)
// Some random prime number to multiply `cap`, so that
// we know that the `cap` is for a dynamic array.
// Selected to be larger than any memory pointer realistically.
let prime := 8188386068317523
let cap := mload(sub(arrData, 0x20))
// Extract `cap`, initializing it to zero if it is not a multiple of `prime`.
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
// Expand / Reallocate memory if required.
// Note that we need to allocate an extra word for the length.
for {} iszero(lt(newArrBytesLen, cap)) {} {
// Approximately more than double the capacity to ensure more than enough space.
let newCap := add(cap, or(cap, newArrBytesLen))
// If the memory is contiguous, we can simply expand it.
if iszero(or(xor(mload(0x40), add(arrData, add(0x20, cap))), eq(arrData, 0x60))) {
mstore(sub(arrData, 0x20), mul(prime, newCap)) // Store the capacity.
mstore(0x40, add(arrData, add(0x20, newCap))) // Expand the memory allocation.
break
}
// Set the `newArrData` to point to the word after `cap`.
let newArrData := add(mload(0x40), 0x20)
mstore(0x40, add(newArrData, add(0x20, newCap))) // Reallocate the memory.
mstore(a, newArrData) // Store the `newArrData`.
let w := not(0x1f)
// Copy `arrData` one word at a time, backwards.
for { let o := newArrBytesLen } 1 {} {
mstore(add(newArrData, o), mload(add(arrData, o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
mstore(add(newArrData, w), mul(prime, newCap)) // Store the memory.
arrData := newArrData // Assign `newArrData` to `arrData`.
break
}
mstore(add(arrData, newArrBytesLen), data) // Append `data`.
mstore(arrData, newArrLen) // Store the length.
}
}
/// @dev Appends `data` to `a`.
function p(DynamicArray memory a, address data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, uint256(uint160(data)));
}
/// @dev Appends `data` to `a`.
function p(DynamicArray memory a, bool data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, _toUint(data));
}
/// @dev Appends `data` to `a`.
function p(DynamicArray memory a, bytes32 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, uint256(data));
}
/// @dev Shorthand for returning an empty array.
function p() internal pure returns (DynamicArray memory result) {}
/// @dev Shorthand for `p(p(), data)`.
function p(uint256 data) internal pure returns (DynamicArray memory result) {
p(result, uint256(data));
}
/// @dev Shorthand for `p(p(), data)`.
function p(address data) internal pure returns (DynamicArray memory result) {
p(result, uint256(uint160(data)));
}
/// @dev Shorthand for `p(p(), data)`.
function p(bool data) internal pure returns (DynamicArray memory result) {
p(result, _toUint(data));
}
/// @dev Shorthand for `p(p(), data)`.
function p(bytes32 data) internal pure returns (DynamicArray memory result) {
p(result, uint256(data));
}
/// @dev Removes and returns the last element of `a`.
/// Returns 0 and does not pop anything if the array is empty.
function pop(DynamicArray memory a) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
/// @dev Removes and returns the last element of `a`.
/// Returns 0 and does not pop anything if the array is empty.
function popUint256(DynamicArray memory a) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
/// @dev Removes and returns the last element of `a`.
/// Returns 0 and does not pop anything if the array is empty.
function popAddress(DynamicArray memory a) internal pure returns (address result) {
/// @solidity memory-safe-assembly
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
/// @dev Removes and returns the last element of `a`.
/// Returns 0 and does not pop anything if the array is empty.
function popBool(DynamicArray memory a) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
/// @dev Removes and returns the last element of `a`.
/// Returns 0 and does not pop anything if the array is empty.
function popBytes32(DynamicArray memory a) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
/// @dev Returns the element at `a.data[i]`, without bounds checking.
function get(DynamicArray memory a, uint256 i) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a.data[i]`, without bounds checking.
function getUint256(DynamicArray memory a, uint256 i) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a.data[i]`, without bounds checking.
function getAddress(DynamicArray memory a, uint256 i) internal pure returns (address result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a.data[i]`, without bounds checking.
function getBool(DynamicArray memory a, uint256 i) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
/// @dev Returns the element at `a.data[i]`, without bounds checking.
function getBytes32(DynamicArray memory a, uint256 i) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(DynamicArray memory a, uint256 i, uint256 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), data)
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(DynamicArray memory a, uint256 i, address data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), shr(96, shl(96, data)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(DynamicArray memory a, uint256 i, bool data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), iszero(iszero(data)))
}
}
/// @dev Sets `a.data[i]` to `data`, without bounds checking.
function set(DynamicArray memory a, uint256 i, bytes32 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
/// @solidity memory-safe-assembly
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), data)
}
}
/// @dev Returns the underlying array as a `uint256[]`.
function asUint256Array(DynamicArray memory a)
internal
pure
returns (uint256[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
result := mload(a)
}
}
/// @dev Returns the underlying array as a `address[]`.
function asAddressArray(DynamicArray memory a)
internal
pure
returns (address[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
result := mload(a)
}
}
/// @dev Returns the underlying array as a `bool[]`.
function asBoolArray(DynamicArray memory a) internal pure returns (bool[] memory result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(a)
}
}
/// @dev Returns the underlying array as a `bytes32[]`.
function asBytes32Array(DynamicArray memory a)
internal
pure
returns (bytes32[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
result := mload(a)
}
}
/// @dev Returns a copy of `a` sliced from `start` to `end` (exclusive).
function slice(DynamicArray memory a, uint256 start, uint256 end)
internal
pure
returns (DynamicArray memory result)
{
result.data = slice(a.data, start, end);
}
/// @dev Returns a copy of `a` sliced from `start` to the end of the array.
function slice(DynamicArray memory a, uint256 start)
internal
pure
returns (DynamicArray memory result)
{
result.data = slice(a.data, start, type(uint256).max);
}
/// @dev Returns if `needle` is in `a`.
function contains(DynamicArray memory a, uint256 needle) internal pure returns (bool) {
return ~indexOf(a.data, needle, 0) != 0;
}
/// @dev Returns if `needle` is in `a`.
function contains(DynamicArray memory a, address needle) internal pure returns (bool) {
return ~indexOf(a.data, uint160(needle), 0) != 0;
}
/// @dev Returns if `needle` is in `a`.
function contains(DynamicArray memory a, bytes32 needle) internal pure returns (bool) {
return ~indexOf(a.data, uint256(needle), 0) != 0;
}
/// @dev Returns the first index of `needle`, scanning forward from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, needle, from);
}
/// @dev Returns the first index of `needle`, scanning forward from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, address needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, uint160(needle), from);
}
/// @dev Returns the first index of `needle`, scanning forward from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, bytes32 needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, uint256(needle), from);
}
/// @dev Returns the first index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, uint256 needle) internal pure returns (uint256) {
return indexOf(a.data, needle, 0);
}
/// @dev Returns the first index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, address needle) internal pure returns (uint256) {
return indexOf(a.data, uint160(needle), 0);
}
/// @dev Returns the first index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function indexOf(DynamicArray memory a, bytes32 needle) internal pure returns (uint256) {
return indexOf(a.data, uint256(needle), 0);
}
/// @dev Returns the last index of `needle`, scanning backwards from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, needle, from);
}
/// @dev Returns the last index of `needle`, scanning backwards from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, address needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, uint160(needle), from);
}
/// @dev Returns the last index of `needle`, scanning backwards from `from`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, bytes32 needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, uint256(needle), from);
}
/// @dev Returns the last index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, uint256 needle) internal pure returns (uint256) {
return lastIndexOf(a.data, needle, NOT_FOUND);
}
/// @dev Returns the last index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, address needle) internal pure returns (uint256) {
return lastIndexOf(a.data, uint160(needle), NOT_FOUND);
}
/// @dev Returns the last index of `needle`.
/// If `needle` is not in `a`, returns `NOT_FOUND`.
function lastIndexOf(DynamicArray memory a, bytes32 needle) internal pure returns (uint256) {
return lastIndexOf(a.data, uint256(needle), NOT_FOUND);
}
/// @dev Equivalent to `keccak256(abi.encodePacked(a.data))`.
function hash(DynamicArray memory a) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
result := keccak256(add(mload(a), 0x20), shl(5, mload(mload(a))))
}
}
/// @dev Directly returns `a` without copying.
function directReturn(DynamicArray memory a) internal pure {
assembly {
let arrData := mload(a)
let retStart := sub(arrData, 0x20)
mstore(retStart, 0x20)
return(retStart, add(0x40, shl(5, mload(arrData))))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* PRIVATE HELPERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Helper for deallocating a automatically allocated array pointer.
function _deallocate(DynamicArray memory result) private pure {
/// @solidity memory-safe-assembly
assembly {
mstore(0x40, result) // Deallocate, as we have already allocated.
}
}
/// @dev Casts the bool into a uint256.
function _toUint(bool b) private pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := iszero(iszero(b))
}
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
library PriceLib {
using Math for uint;
// WAD adjusted result
function convertToValue(uint amount, uint price, uint8 decimals) internal pure returns (uint) {
return amount * price / 10 ** decimals;
}
function convertToAmount(uint amountInUsd, uint collPrice, uint8 collDecimals, Math.Rounding rounding) internal pure returns (uint) {
if (collPrice == 0 || amountInUsd == 0) {
return 0;
}
return amountInUsd.mulDiv(10 ** collDecimals, collPrice, rounding);
}
// Coll decimal adjust amount result
function convertAssetsToCollAmount(uint assets, uint collPrice, uint debtTokenPrice, uint8 vaultDecimals, uint8 collDecimals, Math.Rounding rounding) internal pure returns (uint) {
uint assetsUsdValue = assets.mulDiv(debtTokenPrice, 10 ** vaultDecimals, rounding);
if (collPrice != 0) {
return convertToAmount(assetsUsdValue, collPrice, collDecimals, rounding);
} else {
return 0;
}
}
function convertCollAmountToAssets(uint collAmount, uint collPrice, uint debtTokenPrice, uint8 vaultDecimals, uint8 collDecimals) internal pure returns (uint) {
uint collUsdValue = collAmount * collPrice / 10 ** collDecimals;
if (debtTokenPrice != 0) {
return collUsdValue * 10 ** vaultDecimals / debtTokenPrice;
} else {
return 0;
}
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
interface IMetaCore {
// ---------------------------------
// Structures
// ---------------------------------
struct FeeInfo {
bool existsForDebtToken;
uint16 debtTokenFee;
}
struct RebalancerFeeInfo {
bool exists;
uint16 entryFee;
uint16 exitFee;
}
// ---------------------------------
// Public constants
// ---------------------------------
function OWNERSHIP_TRANSFER_DELAY() external view returns (uint256);
function DEFAULT_FLASH_LOAN_FEE() external view returns (uint16);
// ---------------------------------
// Public state variables
// ---------------------------------
function debtToken() external view returns (address);
function lspEntryFee() external view returns (uint16);
function lspExitFee() external view returns (uint16);
function interestProtocolShare() external view returns (uint16);
/// @dev Default interest receiver for all PositionManagers, unless overriden in the respective PM
function defaultInterestReceiver() external view returns (address);
function feeReceiver() external view returns (address);
function priceFeed() external view returns (address);
function owner() external view returns (address);
function pendingOwner() external view returns (address);
function ownershipTransferDeadline() external view returns (uint256);
function guardian() external view returns (address);
function paused() external view returns (bool);
function lspBootstrapPeriod() external view returns (uint64);
// ---------------------------------
// External functions
// ---------------------------------
function setFeeReceiver(address _feeReceiver) external;
function setPriceFeed(address _priceFeed) external;
function setGuardian(address _guardian) external;
/**
* @notice Global pause/unpause
* Pausing halts new deposits/borrowing across the protocol
*/
function setPaused(bool _paused) external;
/**
* @notice Extend or change the LSP bootstrap period,
* after which certain protocol mechanics change
*/
function setLspBootstrapPeriod(uint64 _bootstrapPeriod) external;
/**
* @notice Set a custom flash-loan fee for a given periphery contract
* @param _periphery Target contract that will get this custom fee
* @param _debtTokenFee Fee in basis points (bp)
* @param _existsForDebtToken Whether this custom fee is used when the caller = `debtToken`
*/
function setPeripheryFlashLoanFee(address _periphery, uint16 _debtTokenFee, bool _existsForDebtToken) external;
/**
* @notice Begin the ownership transfer process
* @param newOwner The address proposed to be the new owner
*/
function commitTransferOwnership(address newOwner) external;
/**
* @notice Finish the ownership transfer, after the mandatory delay
*/
function acceptTransferOwnership() external;
/**
* @notice Revoke a pending ownership transfer
*/
function revokeTransferOwnership() external;
/**
* @notice Look up a custom flash-loan fee for a specific periphery contract
* @param peripheryContract The contract that might have a custom fee
* @return The flash-loan fee in basis points
*/
function getPeripheryFlashLoanFee(address peripheryContract) external view returns (uint16);
/**
* @notice Set / override entry & exit fees for a special rebalancer contract
*/
function setRebalancerFee(address _rebalancer, uint16 _entryFee, uint16 _exitFee) external;
/**
* @notice Set the LSP entry fee globally
* @param _fee Fee in basis points
*/
function setEntryFee(uint16 _fee) external;
/**
* @notice Set the LSP exit fee globally
* @param _fee Fee in basis points
*/
function setExitFee(uint16 _fee) external;
/**
* @notice Set the interest protocol share globally to all PositionManagers
* @param _interestProtocolShare Share in basis points
*/
function setInterestProtocolShare(uint16 _interestProtocolShare) external;
/**
* @notice Look up the LSP entry fee for a rebalancer
* @param rebalancer Possibly has a special fee
* @return The entry fee in basis points
*/
function getLspEntryFee(address rebalancer) external view returns (uint16);
/**
* @notice Look up the LSP exit fee for a rebalancer
* @param rebalancer Possibly has a special fee
* @return The exit fee in basis points
*/
function getLspExitFee(address rebalancer) external view returns (uint16);
// ---------------------------------
// Events
// ---------------------------------
event NewOwnerCommitted(address indexed owner, address indexed pendingOwner, uint256 deadline);
event NewOwnerAccepted(address indexed oldOwner, address indexed newOwner);
event NewOwnerRevoked(address indexed owner, address indexed revokedOwner);
event FeeReceiverSet(address indexed feeReceiver);
event PriceFeedSet(address indexed priceFeed);
event GuardianSet(address indexed guardian);
event PeripheryFlashLoanFee(address indexed periphery, uint16 debtTokenFee);
event LSPBootstrapPeriodSet(uint64 bootstrapPeriod);
event RebalancerFees(address indexed rebalancer, uint16 entryFee, uint16 exitFee);
event EntryFeeSet(uint16 fee);
event ExitFeeSet(uint16 fee);
event InterestProtocolShareSet(uint16 interestProtocolShare);
event DefaultInterestReceiverSet(address indexed defaultInterestReceiver);
event Paused();
event Unpaused();
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
import {ILSTCollateralVault} from "src/interfaces/core/vaults/ILSTCollateralVault.sol";
library TokenValidationLib {
using DynamicArrayLib for DynamicArrayLib.DynamicArray;
using DynamicArrayLib for address[];
using DynamicArrayLib for uint[];
error DuplicateToken();
error InvalidToken();
function checkForDuplicates(address[] memory tokens, uint length) internal pure {
for (uint i; i < length; i++) {
for (uint j = i + 1; j < length; j++) {
if (tokens[i] == tokens[j]) revert DuplicateToken();
}
}
}
function checkValidToken(address token, address[] memory collaterals, uint collateralsLength, address debtToken, bool isExtraAsset) internal pure {
if (isExtraAsset || token == debtToken) {
return;
}
bool isCollateral;
for (uint j; j < collateralsLength; j++) {
if (collaterals[j] == token) {
isCollateral = true;
break;
}
}
if (!isCollateral) revert InvalidToken();
}
function aggregateIfNotExistent(
address token,
uint amount,
DynamicArrayLib.DynamicArray memory tokens,
DynamicArrayLib.DynamicArray memory amounts
) internal pure {
uint index = tokens.indexOf(token);
if (index != DynamicArrayLib.NOT_FOUND) {
uint existingAmount = amounts.getUint256(index);
amounts.set(index, existingAmount + amount);
} else {
tokens.p(token);
amounts.p(amount);
}
}
function contains(address[] memory tokenArray, address targetToken) internal pure returns (uint256) {
uint256 length = tokenArray.length;
for (uint256 i; i < length; ++i) {
if (tokenArray[i] == targetToken) {
return i + 1;
}
}
return 0;
}
/// @dev If the mainRewardTokenVault is included in the rewardTokens list, it returns a new reward array that includes the rewardToken list from the mainRewardTokenVault.
function tryGetRewardedTokensIncludingMainRewardTokenVault(
address[] memory rewardTokens,
address collVaultAsset,
ILSTCollateralVault mainRewardTokenVault
) internal view returns (address[] memory, uint256) {
// Gets a new rewardToken array that includes collVaultAsset.
(address[] memory newRewardTokens, uint256 length) = pushIfNotIncluded(rewardTokens, collVaultAsset);
uint256 mainRewardTokenVaultIdx = contains(newRewardTokens, address(mainRewardTokenVault));
// returns when mainRewardTokenVault is not included in rewardTokens array
if(mainRewardTokenVaultIdx == 0) {
return (newRewardTokens, length);
}
// replace mainRewardTokenVault with mainRewardToken
newRewardTokens[mainRewardTokenVaultIdx - 1] = mainRewardTokenVault.asset();
address[] memory mainRewardTokenVaultRewardTokens = tryGetRewardedTokens(mainRewardTokenVault);
if(mainRewardTokenVaultRewardTokens.length == 0) {
return (newRewardTokens, length);
}
// finalRewardTokens length shouldn't be bigger than (length + mainRewardTokenVaultLength)
uint256 mainRewardTokenVaultLength = mainRewardTokenVaultRewardTokens.length;
address[] memory finalRewardTokens = new address[](length + mainRewardTokenVaultLength);
uint256 finalLength;
// Merge two arrays using the union set method
for(uint256 i; i < length; ++i) {
if(contains(mainRewardTokenVaultRewardTokens, newRewardTokens[i]) == 0) {
finalRewardTokens[finalLength] = newRewardTokens[i];
++finalLength;
}
}
for(uint256 i; i < mainRewardTokenVaultLength; ++i) {
finalRewardTokens[finalLength] = mainRewardTokenVaultRewardTokens[i];
++finalLength;
}
assembly {
mstore(finalRewardTokens, finalLength)
}
return (finalRewardTokens, finalLength);
}
/// @dev Checks if asset is included in reward tokens array
/// @dev CollVault main asset goes at index (len - 1), if it is not included in reward tokens
/// @dev The ordering is inlined with the `CollVaultRouter::previewRedeemUnderlying()` function
function pushIfNotIncluded(address[] memory rewardTokens, address collVaultAsset)
internal
pure
returns (address[] memory, uint256)
{
uint256 originalLength = rewardTokens.length;
if (contains(rewardTokens, collVaultAsset) > 0) {
return (rewardTokens, originalLength);
}
address[] memory _rewardTokens = new address[](originalLength + 1);
for (uint i; i < originalLength; ++i) {
_rewardTokens[i] = rewardTokens[i];
}
_rewardTokens[originalLength] = collVaultAsset;
return (_rewardTokens, originalLength + 1);
}
/// @dev Vaults in LSP could still not have been upgrade to LSTCollateralVault if there is no LSTVault to earn PoL deployed yet
function tryGetRewardedTokens(ILSTCollateralVault collVault) internal view returns (address[] memory) {
address[] memory rewardedTokens;
try collVault.rewardedTokens() returns (address[] memory _rewardedTokens) {
rewardedTokens = _rewardedTokens;
} catch {}
return rewardedTokens;
}
function underlyingAmounts(address[] memory tokens, address account) internal view returns (uint[] memory amounts) {
amounts = new uint[](tokens.length);
for (uint i; i < tokens.length; i++) {
amounts[i] = IERC20(tokens[i]).balanceOf(account);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol";
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {IMetaCore} from "./IMetaCore.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {EmissionsLib} from "src/libraries/EmissionsLib.sol";
interface ILiquidStabilityPool is IERC4626, IERC1822Proxiable {
struct LSPStorage {
IMetaCore metaCore;
address feeReceiver;
/// @notice Array of tokens that have been emitted to the LiquidStabilityPool
/// @notice Used to track which tokens can be withdrawn to LSP share holders
/// @dev Doesn't include tokens that are already collaterals
EnumerableSet.AddressSet extraAssets;
Queue queue;
address[] collateralTokens;
mapping(uint16 => SunsetIndex) _sunsetIndexes;
mapping(address collateral => uint256 index) indexByCollateral;
mapping(bytes32 => uint) threshold;
EmissionsLib.BalanceData balanceData;
mapping(address => bool) factoryProtocol;
mapping(address => bool) liquidationManagerProtocol;
mapping(address => bool) privilegedDebtRedeemers;
}
struct InitParams {
IERC20 _asset;
string _sharesName;
string _sharesSymbol;
IMetaCore _metaCore;
address _liquidationManager;
address _factory;
address _feeReceiver;
}
struct RebalanceParams {
address sentCurrency;
uint sentAmount;
address receivedCurrency;
address swapper;
bytes payload;
}
struct SunsetIndex {
uint128 idx;
uint128 expiry;
}
struct Queue {
uint16 firstSunsetIndexKey;
uint16 nextSunsetIndexKey;
}
event CollAndEmissionsWithdraw(
address indexed receiver,
uint shares,
uint[] amounts
);
struct Arrays {
uint length;
address[] collaterals;
uint collateralsLength;
uint[] amounts;
}
event EmissionTokenAdded(address token);
event EmissionTokenRemoved(address token);
event StabilityPoolDebtBalanceUpdated(uint256 newBalance);
event UserDepositChanged(address indexed depositor, uint256 newDeposit);
event CollateralOverwritten(address oldCollateral, address newCollateral);
// PROXY
function upgradeToAndCall(address newImplementation, bytes calldata data) external;
function getCurrentImplementation() external view returns (address);
function SUNSET_DURATION() external view returns (uint128);
function totalDebtTokenDeposits() external view returns (uint256);
function enableCollateral(address _collateral, uint64 _unlockRatePerSecond, bool forceThroughBalanceCheck) external;
function startCollateralSunset(address collateral) external;
function getTotalDebtTokenDeposits() external view returns (uint256);
function getCollateralTokens() external view returns (address[] memory);
function offset(address collateral, uint256 _debtToOffset, uint256 _collToAdd) external;
function initialize(InitParams calldata params) external;
function rebalance(RebalanceParams calldata p) external;
function linearVestingExtraAssets(address token, int amount, address recipient) external;
function withdraw(
uint assets,
address[] calldata preferredUnderlyingTokens,
address receiver,
address _owner
) external returns (uint shares);
function redeem(
uint shares,
address[] calldata preferredUnderlyingTokens,
address receiver,
address _owner
) external returns (uint assets);
function updateProtocol(
address _liquidationManager,
address _factory,
bool _register
) external;
function redeem(
uint assets,
address receiver
) external returns (uint shares);
function addNewExtraAsset(address token, uint64 _unlockRatePerSecond) external;
function removeEmitedTokens(address token) external;
function setPairThreshold(address tokenIn, address tokenOut, uint thresholdInBP) external;
function setUnlockRatePerSecond(address token, uint64 _unlockRatePerSecond) external;
function getPrice(address token) external view returns (uint);
function getLockedEmissions(address token) external view returns (uint);
function extSloads(bytes32[] calldata slots) external view returns (bytes32[] memory res);
function unlockRatePerSecond(address token) external view returns (uint);
function removeExtraAsset(address token) external;
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
interface ILiquidStabilityPoolGetters {
function metaCore() external view returns (address);
function isLiquidationManager(address liquidatioManager) external view returns (bool);
function isFactory(address factory) external view returns (bool);
function feeReceiver() external view returns (address);
function extraAssets() external view returns (address[] memory);
function extraAssetsIndex(address asset) external view returns (uint256);
function firstSunsetIndexKey() external view returns (uint16);
function nextSunsetIndexKey() external view returns (uint16);
function collateralTokens() external view returns (address[] memory);
function sunsetIndexIdx(uint16 index) external view returns (uint128);
function sunsetIndexExpiry(uint16 index) external view returns (uint128);
function indexByCollateral(address collateral) external view returns (uint256);
function balance(address account) external view returns (uint256);
function threshold(bytes32 key) external view returns (uint256);
function emissionScheduleEmissions(address token) external view returns (uint128);
function emissionScheduleLockTimestamp(address token) external view returns (uint64);
function emissionScheduleUnlockRatePerSecond(address token) external view returns (uint64);
function getFullProfitUnlockTimestamp(address token) external view returns (uint);
function unlockedEmissions(address token) external view returns (uint);
function getBalanceOfWithFutureEmissions(address token) external view returns (uint);
function getThreshold(address tokenIn, address tokenOut) external view returns (uint);
function getTokenVirtualBalance(address token) external view returns (uint);
function containsExtraAsset(address token) external view returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {IBaseCollateralVault} from "./IBaseCollateralVault.sol";
import {ILSTWrapper} from "./ILSTWrapper.sol";
import {ILSTVault} from "../../utils/integrations/ILSTVault.sol";
import {EmissionsLib} from "src/libraries/EmissionsLib.sol";
interface ILSTCollateralVault is IBaseCollateralVault {
struct LSTCollVaultStorage {
uint16 minPerformanceFee;
uint16 maxPerformanceFee;
uint16 performanceFee; // over yield, in basis points
/// @dev We currently don't know the lstVault implementation, but if it were to be possible for them to remove tokens from the rewardTokens
/// There would be no need to remove it from here since the amounts should continue being accounted for in the virtual balance
EnumerableSet.AddressSet rewardedTokens;
ILSTVault _lstVault;
address mainRewardTokenVault;
address mainRewardToken;
ILSTWrapper lstWrapper;
uint96 lastUpdate;
mapping(address tokenIn => uint) threshold;
}
struct LSTInitParams {
BaseInitParams _baseParams;
uint16 _minPerformanceFee;
uint16 _maxPerformanceFee;
uint16 _performanceFee; // over yield, in basis points
ILSTVault _lstVault;
address _mainRewardTokenVault;
address _lstWrapper;
}
struct RebalanceParams {
address sentCurrency;
uint sentAmount;
address swapper;
bytes payload;
}
function rebalance(RebalanceParams calldata p) external;
function pullRewards() external;
function setUnlockRatePerSecond(address token, uint64 _unlockRatePerSecond) external;
function internalizeDonations(address[] memory tokens, uint128[] memory amounts) external;
function setPairThreshold(address tokenIn, uint thresholdInBP) external;
function setPerformanceFee(uint16 _performanceFee) external;
function setWithdrawFee(uint16 _withdrawFee) external;
function getBalance(address token) external view returns (uint);
function getBalanceOfWithFutureEmissions(address token) external view returns (uint);
function getFullProfitUnlockTimestamp(address token) external view returns (uint);
function unlockRatePerSecond(address token) external view returns (uint);
function getLockedEmissions(address token) external view returns (uint);
function getPerformanceFee() external view returns (uint16);
function rewardedTokens() external view returns (address[] memory);
function lstVault() external view returns (ILSTVault);
function mainRewardToken() external view returns (address);
function mainRewardTokenVault() external view returns (address);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IPriceFeed {
struct FeedType {
address spotOracle;
bool isCollVault;
}
event NewOracleRegistered(address token, address chainlinkAggregator, address underlyingDerivative);
event PriceFeedStatusUpdated(address token, address oracle, bool isWorking);
event PriceRecordUpdated(address indexed token, uint256 _price);
event NewCollVaultRegistered(address collVault, bool enable);
event NewSpotOracleRegistered(address token, address spotOracle);
function fetchPrice(address _token) external view returns (uint256);
function getMultiplePrices(address[] memory _tokens) external view returns (uint256[] memory prices);
function setOracle(
address _token,
address _chainlinkOracle,
uint32 _heartbeat,
uint16 _staleThreshold,
address underlyingDerivative
) external;
function whitelistCollateralVault(address _collateralVaultShareToken, bool enable) external;
function setSpotOracle(address _token, address _spotOracle) external;
function MAX_PRICE_DEVIATION_FROM_PREVIOUS_ROUND() external view returns (uint256);
function CORE() external view returns (address);
function RESPONSE_TIMEOUT() external view returns (uint256);
function TARGET_DIGITS() external view returns (uint256);
function guardian() external view returns (address);
function oracleRecords(
address
)
external
view
returns (
address chainLinkOracle,
uint8 decimals,
uint32 heartbeat,
uint16 staleThreshold,
address underlyingDerivative
);
function isCollVault(address _collateralVaultShareToken) external view returns (bool);
function isStableBPT(address _oracle) external view returns (bool);
function isWeightedBPT(address _oracle) external view returns (bool);
function getSpotOracle(address _token) external view returns (address);
function feedType(address _token) external view returns (FeedType memory);
function owner() external view returns (address);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
interface IAsset is IERC20 {
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPositionManager} from "src/interfaces/core/IPositionManager.sol";
import {ILSTCollateralVault} from "src/interfaces/core/vaults/ILSTCollateralVault.sol";
import {ILSTVault} from "src/interfaces/utils/integrations/ILSTVault.sol";
interface ICollVaultRouter {
struct OpenPositionVaultParams {
IPositionManager positionManager;
ILSTCollateralVault collVault;
uint256 _maxFeePercentage;
uint256 _debtAmount;
uint256 _collAssetToDeposit;
address _upperHint;
address _lowerHint;
uint256 _minSharesMinted;
uint256 _collIndex;
bytes _preDeposit;
}
/// @dev Avoid stack too deep
struct AdjustPositionVaultParams {
IPositionManager positionManager;
ILSTCollateralVault collVault;
uint256 _maxFeePercentage;
uint256 _collAssetToDeposit;
uint256 _collWithdrawal;
uint256 _debtChange;
bool _isDebtIncrease;
address _upperHint;
address _lowerHint;
bool unwrap;
uint256 _minSharesMinted;
uint256 _minAssetsWithdrawn;
uint256 _collIndex;
bytes _preDeposit;
}
/// @dev Avoid stack too deep
struct RedeemCollateralVaultParams {
IPositionManager positionManager;
ILSTCollateralVault collVault;
uint256 _debtAmount;
address _firstRedemptionHint;
address _upperPartialRedemptionHint;
address _lowerPartialRedemptionHint;
uint256 _partialRedemptionHintNICR;
uint256 _maxIterations;
uint256 _maxFeePercentage;
uint256 _minSharesWithdrawn;
uint256 minAssetsWithdrawn;
uint256 collIndex;
bool unwrap;
}
struct RedeemToOneParams {
uint shares;
address receiver;
address swapRouter;
ILSTCollateralVault collVault;
address targetToken;
uint minTargetTokenAmount;
bytes[] tokensSwapCalldatas;
}
struct SimRedeemVars {
uint256 netShares;
uint256 totalSupply;
address asset;
address mainRewardToken;
uint256 earned;
uint256 assetAmount;
uint256 performanceFee;
}
function openPositionVault(
OpenPositionVaultParams memory params
) external payable;
function adjustPositionVault(AdjustPositionVaultParams calldata params) external payable;
function closePositionVault(
IPositionManager positionManager,
ILSTCollateralVault collVault,
uint256 minAssetsWithdrawn,
uint256 collIndex,
bool unwrap
) external;
function redeemCollateralVault(
RedeemCollateralVaultParams calldata params
) external;
function claimLockedTokens(IERC20[] memory tokens, uint[] memory amounts) external;
function redeemToOne(
RedeemToOneParams calldata params
) external;
function previewRedeemUnderlying(ILSTCollateralVault collVault, uint shares) external view returns (address[] memory tokens, uint[] memory amounts);
function claimCollateralRouter(
IPositionManager positionManager,
ILSTCollateralVault collVault,
address receiver,
uint _collIndex,
uint minAssetsWithdrawn
) external;
function getOrderedRedeemedTokens(
ILSTCollateralVault vault
) external view returns (address[] memory rewardTokens, ILSTVault lstVault);
function addWhitelistedSwapper(
address swapper,
bool status
) external;
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
interface ILSPRouter {
struct RedeemToOneParams {
uint shares;
uint minAssetsWithdrawn;
address targetToken;
address receiver;
address caller;
bytes[] tokensSwapCalldatas;
uint minTargetTokenAmount;
address swapRouter;
}
struct RedeemPreferredUnderlyingParams {
uint shares;
address[] preferredUnderlyingTokens;
address receiver;
address caller;
uint minAssetsWithdrawn;
bool unwrap;
}
struct RedeemPreferredUnderlyingToOneParams {
uint shares;
address[] preferredUnderlyingTokens;
address swapRouter;
address receiver;
address caller;
address targetToken;
uint minAssetsWithdrawn;
bytes[] tokensSwapCalldatas;
uint minTargetTokenAmount;
}
struct RedeemWithoutPrederredUnderlyingParams {
uint shares;
address receiver;
address caller;
uint minAssetsWithdrawn;
bool unwrap;
}
struct WithdrawFromLSPParams {
uint assets;
address receiver;
address caller;
uint maxSharesWithdrawn;
bool unwrap;
}
struct Arr {
uint[] prevAmounts;
address receiver;
}
struct UnwrapSwapToOneParams {
address[] tokens;
address[] tokensToClaim;
Arr arr;
address targetToken;
address receiver;
uint minTargetTokenAmount;
address swapRouter;
bytes[] tokensSwapCalldatas;
uint[] underlyingCurrAmounts;
}
struct SwapAllTokensToOneParams {
address receiver;
address swapRouter;
bytes[] tokensSwapCalldatas;
uint minTargetTokenAmount;
}
struct DepositTokenParams {
address inputToken;
uint inputAmount;
uint minSharesReceived;
address receiver;
address swapRouter;
bytes dexCalldata;
}
error TokenPreviewMismatch(uint idx, address token, address expectedToken);
function redeemPreferredUnderlying(
RedeemPreferredUnderlyingParams calldata p
) external returns (uint assets, address[] memory tokens, uint[] memory amounts);
function redeemPreferredUnderlyingToOne(
RedeemPreferredUnderlyingToOneParams calldata params
) external returns (uint assets, uint totalAmountOut);
function redeem(
RedeemWithoutPrederredUnderlyingParams calldata params
) external returns (uint assets, address[] memory tokens, uint[] memory amounts);
function withdraw(
WithdrawFromLSPParams calldata params
) external returns (uint shares, address[] memory tokens, uint[] memory amounts);
function deposit(
DepositTokenParams calldata params
) external payable returns (uint shares);
function previewRedeemPreferredUnderlying(uint shares, address[] calldata preferredUnderlyingTokens, address caller, bool unwrap) external view returns (uint assets, address[] memory tokens, uint[] memory amounts);
function previewRedeem(uint shares, address caller) external view returns (uint assets, address[] memory tokens, uint[] memory amounts);
function redeemToOne(
RedeemToOneParams calldata params
) external returns (uint assets, uint totalAmountOut);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
interface IWNative {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address dst, uint256 wad) external returns (bool);
function approve(address to, uint amount) external returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
library UtilsLib {
function getSelector(bytes memory data) internal pure returns (bytes4 selector) {
require(data.length >= 4, "Dex calldata too short");
selector = bytes4(data);
}
function bubbleUpRevert(bytes memory reason) internal pure {
assembly {
revert(add(reason, 0x20), mload(reason))
}
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {UtilsLib} from "src/libraries/UtilsLib.sol";
library SwappersLib {
using UtilsLib for bytes;
event SwapperAdded(address indexed swapRouter, bool status);
struct SwapperData {
mapping(address => bool) whitelistedSwappers;
}
function addWhitelistedSwapper(SwapperData storage self, address _swapRouter, bool status) internal {
self.whitelistedSwappers[_swapRouter] = status;
emit SwapperAdded(_swapRouter, status);
}
function executeSwap(SwapperData storage self, address swapRouter, bytes memory dexCalldata) internal {
require(self.whitelistedSwappers[swapRouter], "SwappersLib: swapper not whitelisted");
(bool success, bytes memory retData) = swapRouter.call(dexCalldata);
if (!success) {
retData.bubbleUpRevert();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
library FeeLib {
using Math for uint;
uint private constant BP = 1e4;
/// @dev Calculates the fees that should be added to an amount `shares` that does already include fees.
/// Used in {IERC4626-deposit}, {IERC4626-mint}, {IERC4626-withdraw} and {IERC4626-previewRedeem} operations.
function feeOnRaw(
uint shares,
uint feeBP
) internal pure returns (uint) {
return shares.mulDiv(feeBP, BP, Math.Rounding.Up);
}
/// @dev Calculates the fee part of an amount `shares` that deoes not includes fees.
/// Used in {IERC4626-previewDeposit} and {IERC4626-previewRedeem} operations.
function feeOnTotal(
uint shares,
uint feeBP
) internal pure returns (uint) {
return shares.mulDiv(feeBP, feeBP + BP, Math.Rounding.Up);
}
}// 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/ERC20/extensions/draft-IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// 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 (last updated v4.8.0) (interfaces/IERC4626.sol)
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20.sol";
import "../token/ERC20/extensions/IERC20Metadata.sol";
/**
* @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
* https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
*
* _Available since v4.7._
*/
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822Proxiable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}// 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;
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC3156FlashBorrower } from "@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol";
import "./ICore.sol";
interface IDebtToken is IERC20 {
// --- Events ---
event FlashLoanFeeUpdated(uint256 newFee);
// --- Public constants ---
function version() external view returns (string memory);
function permitTypeHash() external view returns (bytes32);
// --- Public immutables ---
function gasPool() external view returns (address);
function DEBT_GAS_COMPENSATION() external view returns (uint256);
// --- Public mappings ---
function liquidStabilityPools(address) external view returns (bool);
function borrowerOperations(address) external view returns (bool);
function factories(address) external view returns (bool);
function peripheries(address) external view returns (bool);
function positionManagers(address) external view returns (bool);
// --- External functions ---
function enablePositionManager(address _positionManager) external;
function mintWithGasCompensation(address _account, uint256 _amount) external returns (bool);
function burnWithGasCompensation(address _account, uint256 _amount) external returns (bool);
function mint(address _account, uint256 _amount) external;
function burn(address _account, uint256 _amount) external;
function decimals() external view returns (uint8);
function sendToPeriphery(address _sender, uint256 _amount) external;
function sendToSP(address _sender, uint256 _amount) external;
function returnFromPool(address _poolAddress, address _receiver, uint256 _amount) external;
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function maxFlashLoan(address token) external view returns (uint256);
function flashFee(address token, uint256 amount) external view returns (uint256);
function flashLoan(
IERC3156FlashBorrower receiver,
address token,
uint256 amount,
bytes calldata data
) external returns (bool);
function whitelistLiquidStabilityPoolAddress(address _liquidStabilityPool, bool active) external;
function whitelistBorrowerOperationsAddress(address _borrowerOperations, bool active) external;
function whitelistFactoryAddress(address _factory, bool active) external;
function whitelistPeripheryAddress(address _periphery, bool active) external;
function whitelistPSM(address, bool) external;
function setDebtGasCompensation(uint256 _gasCompensation, bool _isFinalValue) external;
function setFlashLoanFee(uint256 _fee) external;
function DOMAIN_SEPARATOR() external view returns (bytes32);
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
library EmissionsLib {
using SafeCast for uint256;
uint64 constant internal DEFAULT_UNLOCK_RATE = 1e11; // 10% per second
uint64 constant internal MAX_UNLOCK_RATE = 1e12; // 100%
struct BalanceData {
mapping(address token => uint) balance;
mapping(address token => EmissionSchedule) emissionSchedule;
}
struct EmissionSchedule {
uint128 emissions;
uint64 lockTimestamp;
uint64 _unlockRatePerSecond; // rate points
}
error AmountCannotBeZero();
error EmissionRateExceedsMax();
// error UnsupportedEmissionConfig();
event EmissionsAdded(address indexed token, uint128 amount);
event EmissionsSub(address indexed token, uint128 amount);
event NewUnlockRatePerSecond(address indexed token, uint64 unlockRatePerSecond);
/// @dev zero _unlockRatePerSecond parameter resets rate back to DEFAULT_UNLOCK_RATE
function setUnlockRatePerSecond(BalanceData storage $, address token, uint64 _unlockRatePerSecond) internal {
if (_unlockRatePerSecond > MAX_UNLOCK_RATE) revert EmissionRateExceedsMax();
_addEmissions($, token, 0); // update lockTimestamp and emissions
$.emissionSchedule[token]._unlockRatePerSecond = _unlockRatePerSecond;
emit NewUnlockRatePerSecond(token, _unlockRatePerSecond);
}
function addEmissions(BalanceData storage $, address token, uint128 amount) internal {
if (amount == 0) revert AmountCannotBeZero();
_addEmissions($, token, amount);
emit EmissionsAdded(token, amount);
}
function _addEmissions(BalanceData storage $, address token, uint128 amount) private {
EmissionSchedule memory schedule = $.emissionSchedule[token];
uint256 _unlockTimestamp = unlockTimestamp(schedule);
uint128 nextEmissions = (lockedEmissions(schedule, _unlockTimestamp) + amount).toUint128();
schedule.emissions = nextEmissions;
schedule.lockTimestamp = block.timestamp.toUint64();
$.balance[token] += amount;
$.emissionSchedule[token] = schedule;
}
function subEmissions(BalanceData storage $, address token, uint128 amount) internal {
if (amount == 0) revert AmountCannotBeZero();
_subEmissions($, token, amount);
emit EmissionsSub(token, amount);
}
function _subEmissions(BalanceData storage $, address token, uint128 amount) private {
EmissionSchedule memory schedule = $.emissionSchedule[token];
uint256 _unlockTimestamp = unlockTimestamp(schedule);
uint128 nextEmissions = (lockedEmissions(schedule, _unlockTimestamp) - amount).toUint128();
schedule.emissions = nextEmissions;
schedule.lockTimestamp = block.timestamp.toUint64();
$.balance[token] -= amount;
$.emissionSchedule[token] = schedule;
}
/// @dev Doesn't include locked emissions
function unlockedEmissions(EmissionSchedule memory schedule) internal view returns (uint256) {
return schedule.emissions - lockedEmissions(schedule, unlockTimestamp(schedule));
}
function balanceOfWithFutureEmissions(BalanceData storage $, address token) internal view returns (uint256) {
return $.balance[token];
}
/**
* @notice Returns the unlocked token emissions
*/
function balanceOf(BalanceData storage $, address token) internal view returns (uint256) {
EmissionSchedule memory schedule = $.emissionSchedule[token];
return $.balance[token] - lockedEmissions(schedule, unlockTimestamp(schedule));
}
/**
* @notice Returns locked emissions
*/
function lockedEmissions(EmissionSchedule memory schedule, uint256 _unlockTimestamp) internal view returns (uint256) {
if (block.timestamp >= _unlockTimestamp) {
// all emissions were unlocked
return 0;
} else {
// emissions are still unlocking, calculate the amount of already unlocked emissions
uint256 secondsSinceLockup = block.timestamp - schedule.lockTimestamp;
// design decision - use dimensionless 'unlock rate units' to unlock emissions over a fixed time window
uint256 ratePointsUnlocked = unlockRatePerSecond(schedule) * secondsSinceLockup;
// emissions remainder is designed to be added to balance in unlockTimestamp
return schedule.emissions - ratePointsUnlocked * schedule.emissions / MAX_UNLOCK_RATE;
}
}
// timestamp at which all emissions are fully unlocked
function unlockTimestamp(EmissionSchedule memory schedule) internal pure returns (uint256) {
// ceil to account for remainder seconds left after integer division
return divRoundUp(MAX_UNLOCK_RATE, unlockRatePerSecond(schedule)) + schedule.lockTimestamp;
}
function unlockRatePerSecond(EmissionSchedule memory schedule) internal pure returns (uint256) {
return schedule._unlockRatePerSecond == 0 ? DEFAULT_UNLOCK_RATE : schedule._unlockRatePerSecond;
}
function divRoundUp(uint256 dividend, uint256 divisor) internal pure returns (uint256) {
return (dividend + divisor - 1) / divisor;
}
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC4626, IERC20} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol";
import {IPositionManager} from "../IPositionManager.sol";
import {IMetaCore} from "../IMetaCore.sol";
import {IPriceFeed} from "../IPriceFeed.sol";
import {EmissionsLib} from "src/libraries/EmissionsLib.sol";
interface IBaseCollateralVault is IERC4626, IERC1822Proxiable {
struct BaseInitParams {
uint16 _minWithdrawFee;
uint16 _maxWithdrawFee;
uint16 _withdrawFee;
IMetaCore _metaCore;
// ERC4626
IERC20 _asset;
// ERC20
string _sharesName;
string _sharesSymbol;
}
struct BaseCollVaultStorage {
uint16 minWithdrawFee;
uint16 maxWithdrawFee;
uint16 withdrawFee; // over rewarded tokens, in basis points
uint8 assetDecimals;
IMetaCore _metaCore;
// Second mapping of this struct is usless, but it's for retrocompatibility with LSTCollateralVault
EmissionsLib.BalanceData balanceData;
}
function totalAssets() external view returns (uint); // todo: maybe remove this
function fetchPrice() external view returns (uint);
function getPrice(address token) external view returns (uint);
function receiveDonations(address[] memory tokens, uint[] memory amounts, address receiver) external;
function setWithdrawFee(uint16 _withdrawFee) external;
function getBalance(address token) external view returns (uint);
function getWithdrawFee() external view returns (uint16);
function getMetaCore() external view returns (IMetaCore);
function getPriceFeed() external view returns (IPriceFeed);
function assetDecimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
interface ILSTWrapper is IERC20 {
function metaCore() external view returns (address);
function lstCollVault() external view returns (address);
function decimals() external view returns (uint8);
function depositFor(address account, uint256 amount) external returns (bool);
function withdrawTo(address account, uint256 amount) external returns (bool);
function recover(address account) external returns (uint256);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
interface ILSTVault {
function stakingToken() external view returns (address);
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function getRewardForUser(address account) external;
function rewardTokens(uint) external view returns (address);
function getAllRewardTokens() external view returns (address[] memory);
function earned(address account, address _rewardsToken) external view returns (uint256);
function registerVault(address stakingToken) external returns (address);
function balanceOf(address account) external view returns (uint256);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {IERC3156FlashBorrower} from "@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IFactory} from "./IFactory.sol";
interface IPositionManager {
event BaseRateUpdated(uint256 _baseRate);
event CollateralSent(address _to, uint256 _amount);
event LTermsUpdated(uint256 _L_collateral, uint256 _L_debt);
event LastFeeOpTimeUpdated(uint256 _lastFeeOpTime);
event Redemption(
address indexed _redeemer,
uint256 _attemptedDebtAmount,
uint256 _actualDebtAmount,
uint256 _collateralSent,
uint256 _collateralFee
);
event SystemSnapshotsUpdated(uint256 _totalStakesSnapshot, uint256 _totalCollateralSnapshot);
event TotalStakesUpdated(uint256 _newTotalStakes);
event PositionIndexUpdated(address _borrower, uint256 _newIndex);
event PositionSnapshotsUpdated(uint256 _L_collateral, uint256 _L_debt);
event PositionUpdated(address indexed _borrower, uint256 _debt, uint256 _coll, uint256 _stake, uint8 _operation);
function addCollateralSurplus(address borrower, uint256 collSurplus) external;
function applyPendingRewards(address _borrower) external returns (uint256 coll, uint256 debt);
function claimCollateral(address borrower, address _receiver) external;
function closePosition(address _borrower, address _receiver, uint256 collAmount, uint256 debtAmount) external;
function closePositionByLiquidation(address _borrower) external;
function setCollVaultRouter(address _collVaultRouter) external;
function collectInterests() external;
function decayBaseRateAndGetBorrowingFee(uint256 _debt) external returns (uint256);
function decreaseDebtAndSendCollateral(address account, uint256 debt, uint256 coll) external;
function fetchPrice() external view returns (uint256);
function finalizeLiquidation(
address _liquidator,
uint256 _debt,
uint256 _coll,
uint256 _collSurplus,
uint256 _debtGasComp,
uint256 _collGasComp
) external;
function getEntireSystemBalances() external view returns (uint256, uint256, uint256);
function movePendingPositionRewardsToActiveBalances(uint256 _debt, uint256 _collateral) external;
function openPosition(
address _borrower,
uint256 _collateralAmount,
uint256 _compositeDebt,
uint256 NICR,
address _upperHint,
address _lowerHint
) external returns (uint256 stake, uint256 arrayIndex);
function redeemCollateral(
uint256 _debtAmount,
address _firstRedemptionHint,
address _upperPartialRedemptionHint,
address _lowerPartialRedemptionHint,
uint256 _partialRedemptionHintNICR,
uint256 _maxIterations,
uint256 _maxFeePercentage
) external;
function setAddresses(address _priceFeedAddress, address _sortedPositionsAddress, address _collateralToken) external;
function setParameters(
IFactory.DeploymentParams calldata _params
) external;
function setPaused(bool _paused) external;
function setPriceFeed(address _priceFeedAddress) external;
function startSunset() external;
function updateBalances() external;
function updatePositionFromAdjustment(
bool _isDebtIncrease,
uint256 _debtChange,
uint256 _netDebtChange,
bool _isCollIncrease,
uint256 _collChange,
address _upperHint,
address _lowerHint,
address _borrower,
address _receiver
) external returns (uint256, uint256, uint256);
function DEBT_GAS_COMPENSATION() external view returns (uint256);
function DECIMAL_PRECISION() external view returns (uint256);
function L_collateral() external view returns (uint256);
function L_debt() external view returns (uint256);
function MCR() external view returns (uint256);
function PERCENT_DIVISOR() external view returns (uint256);
function CORE() external view returns (address);
function SUNSETTING_INTEREST_RATE() external view returns (uint256);
function Positions(
address
)
external
view
returns (
uint256 debt,
uint256 coll,
uint256 stake,
uint8 status,
uint128 arrayIndex,
uint256 activeInterestIndex
);
function activeInterestIndex() external view returns (uint256);
function baseRate() external view returns (uint256);
function borrowerOperations() external view returns (address);
function borrowingFeeFloor() external view returns (uint256);
function collateralToken() external view returns (address);
function debtToken() external view returns (address);
function collVaultRouter() external view returns (address);
function defaultedCollateral() external view returns (uint256);
function defaultedDebt() external view returns (uint256);
function getBorrowingFee(uint256 _debt) external view returns (uint256);
function getBorrowingFeeWithDecay(uint256 _debt) external view returns (uint256);
function getBorrowingRate() external view returns (uint256);
function getBorrowingRateWithDecay() external view returns (uint256);
function getCurrentICR(address _borrower, uint256 _price) external view returns (uint256);
function getEntireDebtAndColl(
address _borrower
) external view returns (uint256 debt, uint256 coll, uint256 pendingDebtReward, uint256 pendingCollateralReward);
function getEntireSystemColl() external view returns (uint256);
function getEntireSystemDebt() external view returns (uint256);
function getNominalICR(address _borrower) external view returns (uint256);
function getPendingCollAndDebtRewards(address _borrower) external view returns (uint256, uint256);
function getRedemptionFeeWithDecay(uint256 _collateralDrawn) external view returns (uint256);
function getRedemptionRate() external view returns (uint256);
function getRedemptionRateWithDecay() external view returns (uint256);
function getTotalActiveCollateral() external view returns (uint256);
function getTotalActiveDebt() external view returns (uint256);
function getPositionCollAndDebt(address _borrower) external view returns (uint256 coll, uint256 debt);
function getPositionFromPositionOwnersArray(uint256 _index) external view returns (address);
function getPositionOwnersCount() external view returns (uint256);
function getPositionStake(address _borrower) external view returns (uint256);
function getPositionStatus(address _borrower) external view returns (uint256);
function guardian() external view returns (address);
function hasPendingRewards(address _borrower) external view returns (bool);
function interestPayable() external view returns (uint256);
function interestRate() external view returns (uint256);
function lastActiveIndexUpdate() external view returns (uint256);
function lastCollateralError_Redistribution() external view returns (uint256);
function lastDebtError_Redistribution() external view returns (uint256);
function lastFeeOperationTime() external view returns (uint256);
function liquidationManager() external view returns (address);
function maxBorrowingFee() external view returns (uint256);
function maxRedemptionFee() external view returns (uint256);
function maxSystemDebt() external view returns (uint256);
function minuteDecayFactor() external view returns (uint256);
function owner() external view returns (address);
function paused() external view returns (bool);
function priceFeed() external view returns (address);
function redemptionFeeFloor() external view returns (uint256);
function rewardSnapshots(address) external view returns (uint256 collateral, uint256 debt);
function sortedPositions() external view returns (address);
function sunsetting() external view returns (bool);
function surplusBalances(address) external view returns (uint256);
function systemDeploymentTime() external view returns (uint256);
function totalCollateralSnapshot() external view returns (uint256);
function totalStakes() external view returns (uint256);
function totalStakesSnapshot() external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC3156FlashBorrower.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC3156 FlashBorrower, as defined in
* https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
*
* _Available since v4.1._
*/
interface IERC3156FlashBorrower {
/**
* @dev Receive a flash loan.
* @param initiator The initiator of the loan.
* @param token The loan currency.
* @param amount The amount of tokens lent.
* @param fee The additional amount of tokens to repay.
* @param data Arbitrary data structure, intended to contain user-defined parameters.
* @return The keccak256 hash of "IERC3156FlashBorrower.onFlashLoan"
*/
function onFlashLoan(
address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data
) external returns (bytes32);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {IMetaCore} from "src/interfaces/core/IMetaCore.sol";
interface ICore {
// --- Public variables ---
function metaCore() external view returns (IMetaCore);
function startTime() external view returns (uint256);
function CCR() external view returns (uint256);
function dmBootstrapPeriod() external view returns (uint64);
function isPeriphery(address peripheryContract) external view returns (bool);
// --- External functions ---
function setPeripheryEnabled(address _periphery, bool _enabled) external;
function setPMBootstrapPeriod(address dm, uint64 _bootstrapPeriod) external;
function setNewCCR(uint256 _CCR) external;
function priceFeed() external view returns (address);
function owner() external view returns (address);
function pendingOwner() external view returns (address);
function guardian() external view returns (address);
function feeReceiver() external view returns (address);
function paused() external view returns (bool);
function lspBootstrapPeriod() external view returns (uint64);
function getLspEntryFee(address rebalancer) external view returns (uint16);
function getLspExitFee(address rebalancer) external view returns (uint16);
function interestProtocolShare() external view returns (uint16);
function defaultInterestReceiver() external view returns (address);
// --- Events ---
event CCRSet(uint256 initialCCR);
event PMBootstrapPeriodSet(address dm, uint64 bootstrapPeriod);
event PeripheryEnabled(address indexed periphery, bool enabled);
}// 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
pragma solidity 0.8.26;
interface IFactory {
// commented values are suggested default parameters
struct DeploymentParams {
uint256 minuteDecayFactor; // 999037758833783000 (half life of 12 hours)
uint256 redemptionFeeFloor; // 1e18 / 1000 * 5 (0.5%)
uint256 maxRedemptionFee; // 1e18 (100%)
uint256 borrowingFeeFloor; // 1e18 / 1000 * 5 (0.5%)
uint256 maxBorrowingFee; // 1e18 / 100 * 5 (5%)
uint256 interestRateInBps; // 100 (1%)
uint256 maxDebt;
uint256 MCR; // 12 * 1e17 (120%)
address collVaultRouter; // set to address(0) if PositionManager coll is not CollateralVault
}
event NewDeployment(address collateral, address priceFeed, address positionManager, address sortedPositions);
function deployNewInstance(
address collateral,
address priceFeed,
address customPositionManagerImpl,
address customSortedPositionsImpl,
DeploymentParams calldata params,
uint64 unlockRatePerSecond,
bool forceThroughLspBalanceCheck
) external;
function setImplementations(address _positionManagerImpl, address _sortedPositionsImpl) external;
function CORE() external view returns (address);
function borrowerOperations() external view returns (address);
function debtToken() external view returns (address);
function guardian() external view returns (address);
function liquidationManager() external view returns (address);
function owner() external view returns (address);
function sortedPositionsImpl() external view returns (address);
function liquidStabilityPool() external view returns (address);
function positionManagerCount() external view returns (uint256);
function positionManagerImpl() external view returns (address);
function positionManagers(uint256) external view returns (address);
}{
"remappings": [
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
"@openzeppelin-upgradeable/contracts/=lib/openzeppelin-contracts-upgradeable/contracts/",
"solady/=lib/solady/src/",
"@solmate/=lib/solmate/src/",
"@chimera/=lib/chimera/src/",
"forge-std/=lib/forge-std/src/",
"@uniswap/v3-core/=lib/v3-core/",
"@uniswap/v3-periphery/=lib/v3-periphery/",
"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"chimera/=lib/chimera/src/",
"ds-test/=lib/solmate/lib/ds-test/src/",
"erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
"halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/",
"rewards/=lib/rewards/",
"solmate/=lib/solmate/src/",
"v3-core/=lib/v3-core/contracts/",
"v3-periphery/=lib/v3-periphery/contracts/"
],
"optimizer": {
"enabled": true,
"runs": 100
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"evmVersion": "cancun",
"viaIR": false
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"_lsp","type":"address"},{"internalType":"address","name":"_lspGetters","type":"address"},{"internalType":"address","name":"_collVaultRouter","type":"address"},{"internalType":"address","name":"_priceFeed","type":"address"},{"internalType":"address","name":"_metaCore","type":"address"},{"internalType":"address","name":"_wNative","type":"address"},{"internalType":"address","name":"_mainRewardTokenVault","type":"address"},{"internalType":"address[]","name":"routers","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DuplicateToken","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[{"internalType":"uint256","name":"idx","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"expectedToken","type":"address"}],"name":"TokenPreviewMismatch","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"swapRouter","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SwapperAdded","type":"event"},{"inputs":[{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"addWhitelistedSwapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"claimLockedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"internalType":"uint256","name":"minSharesReceived","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"swapRouter","type":"address"},{"internalType":"bytes","name":"dexCalldata","type":"bytes"}],"internalType":"struct ILSPRouter.DepositTokenParams","name":"params","type":"tuple"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"lspUnderlyingTokens","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"caller","type":"address"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address[]","name":"preferredUnderlyingTokens","type":"address[]"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"bool","name":"unwrap","type":"bool"}],"name":"previewRedeemPreferredUnderlying","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"caller","type":"address"}],"name":"previewRedeemedAssetsByCaller","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint256","name":"minAssetsWithdrawn","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"}],"internalType":"struct ILSPRouter.RedeemWithoutPrederredUnderlyingParams","name":"params","type":"tuple"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address[]","name":"preferredUnderlyingTokens","type":"address[]"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint256","name":"minAssetsWithdrawn","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"}],"internalType":"struct ILSPRouter.RedeemPreferredUnderlyingParams","name":"params","type":"tuple"}],"name":"redeemPreferredUnderlying","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address[]","name":"preferredUnderlyingTokens","type":"address[]"},{"internalType":"address","name":"swapRouter","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"address","name":"targetToken","type":"address"},{"internalType":"uint256","name":"minAssetsWithdrawn","type":"uint256"},{"internalType":"bytes[]","name":"tokensSwapCalldatas","type":"bytes[]"},{"internalType":"uint256","name":"minTargetTokenAmount","type":"uint256"}],"internalType":"struct ILSPRouter.RedeemPreferredUnderlyingToOneParams","name":"params","type":"tuple"}],"name":"redeemPreferredUnderlyingToOne","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"totalAmountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"minAssetsWithdrawn","type":"uint256"},{"internalType":"address","name":"targetToken","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"bytes[]","name":"tokensSwapCalldatas","type":"bytes[]"},{"internalType":"uint256","name":"minTargetTokenAmount","type":"uint256"},{"internalType":"address","name":"swapRouter","type":"address"}],"internalType":"struct ILSPRouter.RedeemToOneParams","name":"params","type":"tuple"}],"name":"redeemToOne","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"totalAmountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint256","name":"maxSharesWithdrawn","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"}],"internalType":"struct ILSPRouter.WithdrawFromLSPParams","name":"params","type":"tuple"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000044bc1c218d3ee787ca222c09a5b30e090bf9621700000000000000000000000012ed60319e247b8a86163435fde9987f1207baf600000000000000000000000067e6a96b0f4c1b5465498c22105895685157d622000000000000000000000000d9069e3f3eeb45d4e05b765142ba28f3beb96f7a0000000000000000000000008700af942be2a6e5566306d0ee7bcc5a3a6e0ce8000000000000000000000000ee7d8bcfb72bc1880d0cf19822eb0a2e6577ab62000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000ac4c6e212a361c968f1725b4d055b47e63f80b75
-----Decoded View---------------
Arg [0] : _lsp (address): 0x44bc1C218d3eE787Ca222C09a5B30E090bf96217
Arg [1] : _lspGetters (address): 0x12Ed60319e247B8a86163435fDE9987F1207Baf6
Arg [2] : _collVaultRouter (address): 0x67E6A96B0f4c1b5465498c22105895685157d622
Arg [3] : _priceFeed (address): 0xD9069E3F3EEb45d4E05b765142ba28f3BeB96F7a
Arg [4] : _metaCore (address): 0x8700AF942BE2A6E5566306D0eE7Bcc5a3A6E0ce8
Arg [5] : _wNative (address): 0xEE7D8BCFb72bC1880D0Cf19822eB0A2e6577aB62
Arg [6] : _mainRewardTokenVault (address): 0x0000000000000000000000000000000000000000
Arg [7] : routers (address[]): 0xAC4c6e212A361c968F1725b4d055b47E63F80b75
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000044bc1c218d3ee787ca222c09a5b30e090bf96217
Arg [1] : 00000000000000000000000012ed60319e247b8a86163435fde9987f1207baf6
Arg [2] : 00000000000000000000000067e6a96b0f4c1b5465498c22105895685157d622
Arg [3] : 000000000000000000000000d9069e3f3eeb45d4e05b765142ba28f3beb96f7a
Arg [4] : 0000000000000000000000008700af942be2a6e5566306d0ee7bcc5a3a6e0ce8
Arg [5] : 000000000000000000000000ee7d8bcfb72bc1880d0cf19822eb0a2e6577ab62
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [9] : 000000000000000000000000ac4c6e212a361c968f1725b4d055b47e63f80b75
Loading...
Loading
Loading...
Loading
0x15B9953e5F6aD5Bb7F5F3Bc6438ee85bADC09bd8
Multichain Portfolio | 34 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
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.