Source Code
Overview
HYPE Balance
0 HYPEHYPE Value
$0.00View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Cross-Chain Transactions
Loading...
Loading
Contract Name:
SettersGovernor
Compiler Version
v0.8.28+commit.7893614a
Optimization Enabled:
Yes with 1000 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { ISettersGovernor } from "contracts/interfaces/ISetters.sol";
import { LibManager } from "../libraries/LibManager.sol";
import { LibOracle } from "../libraries/LibOracle.sol";
import { LibSetters } from "../libraries/LibSetters.sol";
import { LibStorage as s } from "../libraries/LibStorage.sol";
import { AccessManagedModifiers } from "./AccessManagedModifiers.sol";
import "../../utils/Constants.sol";
import "../../utils/Errors.sol";
import "../Storage.sol";
/// @title SettersGovernor
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/facets/SettersGovernor.sol
contract SettersGovernor is AccessManagedModifiers, ISettersGovernor {
using SafeERC20 for IERC20;
event Recovered(address indexed token, address indexed to, uint256 amount);
/// @inheritdoc ISettersGovernor
/// @dev No check is made on the collateral that is redeemed: this function could typically be used by a
/// governance during a manual rebalance of the reserves of the system
/// @dev `collateral` is different from `token` only in the case of a managed collateral
function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);
else token.safeTransfer(to, amount);
emit Recovered(address(token), to, amount);
}
/// @inheritdoc ISettersGovernor
function setAccessManager(address _newAccessManager) external restricted {
LibSetters.setAccessManager(IAccessManager(_newAccessManager));
}
/// @inheritdoc ISettersGovernor
/// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call
function setCollateralManager(
address collateral,
bool checkExternalManagerBalance,
ManagerStorage memory managerData
)
external
restricted
{
LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);
}
/// @inheritdoc ISettersGovernor
/// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the
/// funds associated to the collateral it corresponds to
function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < amount) {
token.safeIncreaseAllowance(spender, amount - currentAllowance);
} else if (currentAllowance > amount) {
token.safeDecreaseAllowance(spender, currentAllowance - amount);
}
}
/// @inheritdoc ISettersGovernor
function toggleTrusted(address sender, TrustedType t) external restricted {
LibSetters.toggleTrusted(sender, t);
}
/// @inheritdoc ISettersGovernor
/// @dev Collateral assets with a fee on transfer are not supported by the system
function addCollateral(address collateral) external restricted {
LibSetters.addCollateral(collateral);
}
/// @inheritdoc ISettersGovernor
/// @dev The amount passed here must be an absolute amount
function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {
LibSetters.adjustStablecoins(collateral, amount, increase);
}
/// @inheritdoc ISettersGovernor
/// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral
/// is not used to back stables
/// @dev The system may still have a non null balance of the collateral that is revoked: this should later
/// be handled through a recoverERC20 call
/// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is
/// true
function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {
LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);
}
/// @inheritdoc ISettersGovernor
function setOracle(address collateral, bytes memory oracleConfig) external restricted {
LibSetters.setOracle(collateral, oracleConfig);
}
function updateOracle(address collateral) external {
if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();
LibOracle.updateOracle(collateral);
}
/// @inheritdoc ISettersGovernor
function setWhitelistStatus(
address collateral,
uint8 whitelistStatus,
bytes memory whitelistData
)
external
restricted
{
LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { IManager } from "contracts/interfaces/IManager.sol";
import "../Storage.sol";
/// @title LibManager
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library
/// @dev There is no implementation at this point for a managed collateral handled through this library, and
/// a new specific `ManagerType` would need to be added in this case
/// @dev This library is an authorized fork of Angle's `LibManager` library
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/libraries/LibManager.sol
library LibManager {
/// @notice Checks to which address managed funds must be transferred
function transferRecipient(bytes memory config) internal view returns (address recipient) {
(ManagerType managerType, bytes memory data) = parseManagerConfig(config);
recipient = address(this);
if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));
}
/// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address
/// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated
/// with it
/// @dev Eventually pulls funds from strategies
function release(address token, address to, uint256 amount, bytes memory config) internal {
(ManagerType managerType, bytes memory data) = parseManagerConfig(config);
if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);
}
/// @notice Gets the balances of all the tokens controlled through `managerData`
/// @return balances An array of size `subCollaterals` with current balances of all subCollaterals
/// including the one corresponding to the `managerData` given
/// @return totalValue The value of all the `subCollaterals` in `collateral`
/// @dev `subCollaterals` must always have as first token (index 0) the collateral itself
function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {
(ManagerType managerType, bytes memory data) = parseManagerConfig(config);
if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();
}
/// @notice Calls a hook if needed after new funds have been transfered to a manager
function invest(uint256 amount, bytes memory config) internal {
(ManagerType managerType, bytes memory data) = parseManagerConfig(config);
if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);
}
/// @notice Returns available underlying tokens, for instance if liquidity is fully used and
/// not withdrawable the function will return 0
function maxAvailable(bytes memory config) internal view returns (uint256 available) {
(ManagerType managerType, bytes memory data) = parseManagerConfig(config);
if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();
}
/// @notice Decodes the `managerData` associated to a collateral
function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {
(managerType, data) = abi.decode(config, (ManagerType, bytes));
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { IKeyringGuard } from "contracts/interfaces/external/keyring/IKeyringGuard.sol";
import { LibStorage as s } from "./LibStorage.sol";
import "../../utils/Errors.sol";
import "../Storage.sol";
/// @title LibWhitelist
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This library is an authorized fork of Angle's `LibWhitelist` library
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/libraries/LibWhitelist.sol
library LibWhitelist {
/// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`
function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {
(WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));
if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;
if (data.length != 0) {
if (whitelistType == WhitelistType.BACKED) {
address keyringGuard = abi.decode(data, (address));
if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);
}
}
return false;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title ICbETH
/// @notice Interface for the `cbETH` contract
interface ICbETH {
function exchangeRate() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.28;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/// @title ITokenP
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @notice Interface for the stablecoins `tokenP` contracts
/// @dev This interface is an authorized fork of Angle's `IAgToken` interface
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol
interface ITokenP is IERC20 {
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MINTER ROLE ONLY FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Lets a whitelisted contract mint tokenPs
/// @param account Address to mint to
/// @param amount Amount to mint
function mint(address account, uint256 amount) external;
/// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`
/// @param amount Amount of tokens to burn
/// @param burner Address to burn from
/// @param sender Address which requested the burn from `burner`
/// @dev This method is to be called by a contract with the minter right after being requested
/// to do so by a `sender` address willing to burn tokens from another `burner` address
/// @dev The method checks the allowance between the `sender` and the `burner`
function burnFrom(uint256 amount, address burner, address sender) external;
/// @notice Burns `amount` tokens from a `burner` address
/// @param amount Amount of tokens to burn
/// @param burner Address to burn from
/// @dev This method is to be called by a contract with a minter right on the tokenP after being
/// requested to do so by an address willing to burn tokens from its address
function burnSelf(uint256 amount, address burner) external;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EXTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Amount of decimals of the stablecoin
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { LibManager } from "./LibManager.sol";
import { LibOracle } from "./LibOracle.sol";
import { LibStorage as s } from "./LibStorage.sol";
import { LibDiamond } from "./LibDiamond.sol";
import { LibWhitelist } from "./LibWhitelist.sol";
import "../../utils/Constants.sol";
import "../../utils/Errors.sol";
import "../Storage.sol";
/// @title LibSetters
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This library is an authorized fork of Angle's `LibSetters` library
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/libraries/LibSetters.sol
library LibSetters {
using SafeCast for uint256;
event CollateralAdded(address indexed collateral);
event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);
event CollateralRevoked(address indexed collateral);
event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);
event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);
event OracleSet(address indexed collateral, bytes oracleConfig);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);
event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);
event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);
event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);
event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);
event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ONLY GOVERNOR ACTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Internal version of `setAccessManager`
function setAccessManager(IAccessManager _newAccessManager) internal {
if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();
DiamondStorage storage ds = s.diamondStorage();
address previousAccessManager = address(ds.accessManager);
ds.accessManager = _newAccessManager;
emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));
}
/// @notice Internal version of `setCollateralManager`
function setCollateralManager(
address collateral,
bool checkExternalManagerBalance,
ManagerStorage memory managerData
)
internal
{
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
uint8 isManaged = collatInfo.isManaged;
if (isManaged > 0 && checkExternalManagerBalance) {
(, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);
if (totalValue > 0) revert ManagerHasAssets();
}
if (managerData.config.length != 0) {
// The first subCollateral given should be the actual collateral asset
if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();
// Sanity check on the manager data that is passed
LibManager.parseManagerConfig(managerData.config);
collatInfo.isManaged = 1;
} else {
collatInfo.isManaged = 0;
}
collatInfo.managerData = managerData;
emit CollateralManagerSet(collateral, managerData);
}
/// @notice Internal version of `toggleTrusted`
function toggleTrusted(address sender, TrustedType t) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
uint256 trustedStatus;
if (t == TrustedType.Updater) {
trustedStatus = 1 - ts.isTrusted[sender];
ts.isTrusted[sender] = trustedStatus;
} else {
trustedStatus = 1 - ts.isSellerTrusted[sender];
ts.isSellerTrusted[sender] = trustedStatus;
}
emit TrustedToggled(sender, trustedStatus == 1, t);
}
/// @notice Internal version of `addCollateral`
function addCollateral(address collateral) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
Collateral storage collatInfo = ts.collaterals[collateral];
if (collatInfo.decimals != 0) revert AlreadyAdded();
collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());
ts.collateralList.push(collateral);
emit CollateralAdded(collateral);
}
/// @notice Internal version of `adjustStablecoins`
function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
Collateral storage collatInfo = ts.collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();
if (increase) {
collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);
ts.normalizedStables = ts.normalizedStables + normalizedAmount;
} else {
collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);
ts.normalizedStables = ts.normalizedStables - normalizedAmount;
}
emit ReservesAdjusted(collateral, amount, increase);
}
/// @notice Internal version of `revokeCollateral`
function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
Collateral storage collatInfo = ts.collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
if (collatInfo.normalizedStables > 0) revert CollateralBacked();
uint8 isManaged = collatInfo.isManaged;
if (isManaged > 0 && checkExternalManagerBalance) {
(, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);
if (totalValue > 0) revert ManagerHasAssets();
}
delete ts.collaterals[collateral];
address[] memory collateralListMem = ts.collateralList;
uint256 length = collateralListMem.length;
for (uint256 i; i < length - 1; ++i) {
if (collateralListMem[i] == collateral) {
ts.collateralList[i] = collateralListMem[length - 1];
break;
}
}
ts.collateralList.pop();
emit CollateralRevoked(collateral);
}
/// @notice Internal version of `setOracle`
function setOracle(address collateral, bytes memory oracleConfig) internal {
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
// Checks oracle validity
LibOracle.readMint(oracleConfig);
collatInfo.oracleConfig = oracleConfig;
emit OracleSet(collateral, oracleConfig);
}
/// @notice Internal version of `setWhitelistStatus`
function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
if (whitelistStatus == 1) {
// Sanity check
LibWhitelist.checkWhitelist(whitelistData, address(this));
collatInfo.whitelistData = whitelistData;
} else {
// If whitelist is revoked, clear the whitelist data
collatInfo.whitelistData = "";
}
collatInfo.onlyWhitelisted = whitelistStatus;
emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ONLY GUARDIAN ACTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Internal version of `togglePause`
function togglePause(address collateral, ActionType action) internal {
uint8 isLive;
if (action == ActionType.Mint || action == ActionType.Burn) {
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
if (action == ActionType.Mint) {
isLive = 1 - collatInfo.isMintLive;
collatInfo.isMintLive = isLive;
} else {
isLive = 1 - collatInfo.isBurnLive;
collatInfo.isBurnLive = isLive;
}
} else {
ParallelizerStorage storage ts = s.transmuterStorage();
isLive = 1 - ts.isRedemptionLive;
ts.isRedemptionLive = isLive;
}
emit PauseToggled(collateral, uint256(action), isLive == 0);
}
/// @notice Internal version of `setFees`
function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
Collateral storage collatInfo = ts.collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);
if (mint) {
collatInfo.xFeeMint = xFee;
collatInfo.yFeeMint = yFee;
} else {
collatInfo.xFeeBurn = xFee;
collatInfo.yFeeBurn = yFee;
}
emit FeesSet(collateral, xFee, yFee, mint);
}
/// @notice Internal version of `setRedemptionCurveParams`
function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
LibSetters.checkFees(xFee, yFee, ActionType.Redeem);
ts.xRedemptionCurve = xFee;
ts.yRedemptionCurve = yFee;
emit RedemptionCurveParamsSet(xFee, yFee);
}
/// @notice Internal version of `toggleWhitelist`
function toggleWhitelist(WhitelistType whitelistType, address who) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];
ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;
emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);
}
/// @notice Sets the stablecoin cap that can be issued from a collateral
function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {
Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
if (collatInfo.decimals == 0) revert NotCollateral();
collatInfo.stablecoinCap = stablecoinCap;
emit StablecoinCapSet(collateral, stablecoinCap);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HELPERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions
function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {
uint256 n = xFee.length;
if (n != yFee.length || n == 0) revert InvalidParams();
if (
// Mint inflexion points should be in [0,BASE_9[
// We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9
// Hence we consider BASE_12 as the max value (100% fees) for yFeeMint
// Burn inflexion points should be in [0,BASE_9] but fees should be constant in
// the first segment [BASE_9, x_{n-1}[
// Redemption inflexion points should be in [0,BASE_9]
(action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))
|| (
action == ActionType.Burn
&& (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1])))
) || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))
) {
revert InvalidParams();
}
for (uint256 i; i < n - 1; ++i) {
if (
// xFee strictly increasing and yFee increasing for mints
// xFee strictly decreasing and yFee increasing for burns
// xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions
(action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))
|| (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))
|| (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))
) revert InvalidParams();
}
// If a mint or burn fee is negative, we need to check that accounts atomically minting
// (from any collateral) and then burning cannot get more than their initial value
if (yFee[0] < 0) {
if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees
ParallelizerStorage storage ts = s.transmuterStorage();
address[] memory collateralListMem = ts.collateralList;
uint256 length = collateralListMem.length;
if (action == ActionType.Mint) {
// This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`
for (uint256 i; i < length; ++i) {
int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;
if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();
}
}
if (action == ActionType.Burn) {
// This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`
for (uint256 i; i < length; ++i) {
int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;
if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();
}
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool 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.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @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
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
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
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
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
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
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
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
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
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
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
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
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
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
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
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
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
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
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
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
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
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
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
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
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
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
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
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
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
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
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
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
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
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
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
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
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
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
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
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
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
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
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
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
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
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
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
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
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
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
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
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
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
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
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
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
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
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
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
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
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
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
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
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @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
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @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
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @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
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @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
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @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
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @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
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @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
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @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
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @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
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @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
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @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
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @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
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @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
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @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
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @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
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @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
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @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
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @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
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @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
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @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
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @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
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @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
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @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
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @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
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @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
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @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
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @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
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @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
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @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
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @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
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { ICbETH } from "contracts/interfaces/external/coinbase/ICbETH.sol";
import { ISfrxETH } from "contracts/interfaces/external/frax/ISfrxETH.sol";
import { IStETH } from "contracts/interfaces/external/lido/IStETH.sol";
import { IRETH } from "contracts/interfaces/external/rocketPool/IRETH.sol";
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
STORAGE SLOTS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @dev Storage position of `DiamondStorage` structure
/// @dev Equals `keccak256("diamond.standard.diamond.storage") - 1`
bytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;
/// @dev Storage position of `ParallelizerStorage` structure
/// @dev Equals `keccak256("diamond.standard.parallelizer.storage") - 1`
bytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;
/// @dev Storage position of `ImplementationStorage` structure
/// @dev Equals `keccak256("eip1967.proxy.implementation") - 1`
bytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MATHS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
uint256 constant BASE_6 = 1e6;
uint256 constant BASE_8 = 1e8;
uint256 constant BASE_9 = 1e9;
uint256 constant BASE_12 = 1e12;
uint256 constant BPS = 1e14;
uint256 constant BASE_18 = 1e18;
uint256 constant HALF_BASE_27 = 1e27 / 2;
uint256 constant BASE_27 = 1e27;
uint256 constant BASE_36 = 1e36;
uint256 constant MAX_BURN_FEE = 999_000_000;
uint256 constant MAX_MINT_FEE = BASE_12 - 1;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
REENTRANT
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint8 constant NOT_ENTERED = 1;
uint8 constant ENTERED = 2;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
REENTRANT
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
// Role IDs for the AccessManager
uint64 constant GOVERNOR_ROLE = 10;
uint64 constant GUARDIAN_ROLE = 20;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
COMMON ADDRESSES
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
address constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
address constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;
address constant AGEUR = 0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8;
ICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);
IRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);
IStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
ISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);
address constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;
address constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;
address constant STEAK_USDC = 0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB;
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.28; error AccessManagedUnauthorized(address caller); error AlreadyAdded(); error CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector); error CannotAddSelectorsToZeroAddress(bytes4[] _selectors); error CannotRemoveFunctionThatDoesNotExist(bytes4 _selector); error CannotRemoveImmutableFunction(bytes4 _selector); error CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors); error CannotReplaceFunctionThatDoesNotExists(bytes4 _selector); error CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector); error CannotReplaceImmutableFunction(bytes4 _selector); error ContractHasNoCode(); error CollateralBacked(); error FunctionNotFound(bytes4 _functionSelector); error IncorrectFacetCutAction(uint8 _action); error InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata); error InvalidChainlinkRate(); error InvalidLengths(); error InvalidNegativeFees(); error InvalidOracleType(); error InvalidParam(); error InvalidParams(); error InvalidRate(); error InvalidSwap(); error InvalidTokens(); error InvalidAccessManager(); error ManagerHasAssets(); error NoSelectorsProvidedForFacetForCut(address _facetAddress); error NotAllowed(); error NotCollateral(); error NotGovernor(); error NotGuardian(); error NotTrusted(); error NotTrustedOrGuardian(); error NotWhitelisted(); error OdosSwapFailed(); error OracleUpdateFailed(); error Paused(); error ReentrantCall(); error RemoveFacetAddressMustBeZeroAddress(address _facetAddress); error TooBigAmountIn(); error TooLate(); error TooSmallAmountOut(); error ZeroAddress(); error ZeroAmount(); error SwapError(); error SlippageTooHigh(); error InsufficientFunds();
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IAccessManager } from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
import { ITokenP } from "contracts/interfaces/ITokenP.sol";
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ENUMS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
enum FacetCutAction {
Add,
Replace,
Remove
}
enum ManagerType {
EXTERNAL
}
enum ActionType {
Mint,
Burn,
Redeem
}
enum TrustedType {
Updater,
Seller
}
enum QuoteType {
MintExactInput,
MintExactOutput,
BurnExactInput,
BurnExactOutput
}
enum OracleReadType {
CHAINLINK_FEEDS,
EXTERNAL,
NO_ORACLE,
STABLE,
WSTETH,
CBETH,
RETH,
SFRXETH,
MAX,
MORPHO_ORACLE
}
enum OracleQuoteType {
UNIT,
TARGET
}
enum WhitelistType {
BACKED
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
struct Permit2Details {
address to; // Address that will receive the funds
uint256 nonce; // Nonce of the transaction
bytes signature; // Permit signature of the user
}
struct FacetCut {
address facetAddress; // Facet contract address
FacetCutAction action; // Can be add, remove or replace
bytes4[] functionSelectors; // Ex. bytes4(keccak256("transfer(address,uint256)"))
}
struct Facet {
address facetAddress; // Facet contract address
bytes4[] functionSelectors; // Ex. bytes4(keccak256("transfer(address,uint256)"))
}
struct FacetInfo {
address facetAddress; // Facet contract address
uint16 selectorPosition; // Position in the list of all selectors
}
struct DiamondStorage {
bytes4[] selectors; // List of all available selectors
mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)
IAccessManager accessManager; // Contract handling access management
}
struct ImplementationStorage {
address implementation; // Dummy implementation address for Etherscan usability
}
struct ManagerStorage {
IERC20[] subCollaterals; // Subtokens handled by the manager or strategies
bytes config; // Additional configuration data
}
struct Collateral {
uint8 isManaged; // If the collateral is managed through external strategies
uint8 isMintLive; // If minting from this asset is unpaused
uint8 isBurnLive; // If burning to this asset is unpaused
uint8 decimals; // IERC20Metadata(collateral).decimals()
uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token
uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral
uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[
int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`
uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]
int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`
bytes oracleConfig; // Data about the oracle used for the collateral
bytes whitelistData; // For whitelisted collateral, data used to verify whitelists
ManagerStorage managerData; // For managed collateral, data used to handle the strategies
uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral
}
struct ParallelizerStorage {
ITokenP tokenP; // tokenP handled by the system
uint8 isRedemptionLive; // If redemption is unpaused
uint8 statusReentrant; // If call is reentrant or not
bool consumingSchedule; // If the contract is consuming a scheduled operation
uint128 normalizedStables; // Normalized amount of stablecoins issued by the system
uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount
address[] collateralList; // List of collateral assets supported by the system
uint64[] xRedemptionCurve; // Increasing collateral ratios > 0
int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`
mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters
mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value
mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run
// keeper jobs on oracles
mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;
}
// Whether an address is whitelisted for a specific whitelist type// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.28; /// @title IParallelizerOracle /// @author Cooper Labs /// @custom:contact [email protected] /// @dev This interface is an authorized fork of Angle's `IParallelizerOracle` interface /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizerOracle.sol interface IParallelizerOracle { /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio function readRedemption() external view returns (uint256); /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the /// deviation from the target price function readMint() external view returns (uint256); /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio /// between the current price and the target price for the asset function readBurn() external view returns (uint256 oracleValue, uint256 ratio); /// @notice Reads the oracle value for asset function read() external view returns (uint256); }
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { LibDiamond } from "../libraries/LibDiamond.sol";
import { LibStorage as s, ParallelizerStorage } from "../libraries/LibStorage.sol";
import "../../utils/Errors.sol";
import "../../utils/Constants.sol";
/// @title AccessManagedModifiers
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/facets/AccessControlModifiers.sol
/// update access logic to use OpenZeppelin's `AccessManaged` logic
contract AccessManagedModifiers {
/// @notice Checks whether the `msg.sender` can call a function with a given selector
modifier restricted() {
if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);
_;
}
/// @notice Prevents a contract from calling itself, directly or indirectly
/// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this
/// Diamond Proxy system. The base implementation can be found here
/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol
modifier nonReentrant() {
ParallelizerStorage storage ts = s.transmuterStorage();
// Reentrant protection
// On the first call, `ts.statusReentrant` will be `NOT_ENTERED`
if (ts.statusReentrant == ENTERED) revert ReentrantCall();
// Any calls to the `nonReentrant` modifier after this point will fail
ts.statusReentrant = ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
ts.statusReentrant = NOT_ENTERED;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 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 {
/**
* @dev An operation with an ERC-20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @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).
*
* This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @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).
*
* This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title IMorphoOracle
/// @notice Interface for the oracle contracts used within Morpho
interface IMorphoOracle {
function price() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title ISfrxETH
/// @notice Interface for the `sfrxETH` contract
interface ISfrxETH {
function pricePerShare() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title IStETH
/// @notice Interface for the `StETH` contract
interface IStETH {
function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);
function submit(address) external payable returns (uint256);
function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard interface for permissioning originally defined in Dappsys.
*/
interface IAuthority {
/**
* @dev Returns true if the caller can invoke on a target the function identified by a function selector.
*/
function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol)
pragma solidity ^0.8.20;
import {IAuthority} from "./IAuthority.sol";
library AuthorityUtils {
/**
* @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility
* for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.
* This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.
*/
function canCallWithDelay(
address authority,
address caller,
address target,
bytes4 selector
) internal view returns (bool immediate, uint32 delay) {
(bool success, bytes memory data) = authority.staticcall(
abi.encodeCall(IAuthority.canCall, (caller, target, selector))
);
if (success) {
if (data.length >= 0x40) {
(immediate, delay) = abi.decode(data, (bool, uint32));
} else if (data.length >= 0x20) {
immediate = abi.decode(data, (bool));
}
}
return (immediate, delay);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/types/Time.sol)
pragma solidity ^0.8.20;
import {Math} from "../math/Math.sol";
import {SafeCast} from "../math/SafeCast.sol";
/**
* @dev This library provides helpers for manipulating time-related objects.
*
* It uses the following types:
* - `uint48` for timepoints
* - `uint32` for durations
*
* While the library doesn't provide specific types for timepoints and duration, it does provide:
* - a `Delay` type to represent duration that can be programmed to change value automatically at a given point
* - additional helper functions
*/
library Time {
using Time for *;
/**
* @dev Get the block timestamp as a Timepoint.
*/
function timestamp() internal view returns (uint48) {
return SafeCast.toUint48(block.timestamp);
}
/**
* @dev Get the block number as a Timepoint.
*/
function blockNumber() internal view returns (uint48) {
return SafeCast.toUint48(block.number);
}
// ==================================================== Delay =====================================================
/**
* @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the
* future. The "effect" timepoint describes when the transitions happens from the "old" value to the "new" value.
* This allows updating the delay applied to some operation while keeping some guarantees.
*
* In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for
* some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set
* the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should
* still apply for some time.
*
*
* The `Delay` type is 112 bits long, and packs the following:
*
* ```
* | [uint48]: effect date (timepoint)
* | | [uint32]: value before (duration)
* ↓ ↓ ↓ [uint32]: value after (duration)
* 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC
* ```
*
* NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently
* supported.
*/
type Delay is uint112;
/**
* @dev Wrap a duration into a Delay to add the one-step "update in the future" feature
*/
function toDelay(uint32 duration) internal pure returns (Delay) {
return Delay.wrap(duration);
}
/**
* @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled
* change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.
*/
function _getFullAt(
Delay self,
uint48 timepoint
) private pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {
(valueBefore, valueAfter, effect) = self.unpack();
return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);
}
/**
* @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the
* effect timepoint is 0, then the pending value should not be considered.
*/
function getFull(Delay self) internal view returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {
return _getFullAt(self, timestamp());
}
/**
* @dev Get the current value.
*/
function get(Delay self) internal view returns (uint32) {
(uint32 delay, , ) = self.getFull();
return delay;
}
/**
* @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to
* enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the
* new delay becomes effective.
*/
function withUpdate(
Delay self,
uint32 newValue,
uint32 minSetback
) internal view returns (Delay updatedDelay, uint48 effect) {
uint32 value = self.get();
uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));
effect = timestamp() + setback;
return (pack(value, newValue, effect), effect);
}
/**
* @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).
*/
function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {
uint112 raw = Delay.unwrap(self);
valueAfter = uint32(raw);
valueBefore = uint32(raw >> 32);
effect = uint48(raw >> 64);
return (valueBefore, valueAfter, effect);
}
/**
* @dev pack the components into a Delay object.
*/
function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {
return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC-20 standard.
*/
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: BUSL-1.1
pragma solidity 0.8.28;
import "../../utils/Constants.sol";
import { DiamondStorage, ImplementationStorage, ParallelizerStorage } from "../Storage.sol";
/// @title LibStorage
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This library is an authorized fork of Angle's `LibStorage` library
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/libraries/LibStorage.sol
library LibStorage {
/// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot
/// @dev This struct handles the logic of the different facets used in the diamond proxy
function diamondStorage() internal pure returns (DiamondStorage storage ds) {
bytes32 position = DIAMOND_STORAGE_POSITION;
assembly ("memory-safe") {
ds.slot := position
}
}
/// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot
/// @dev This struct handles the particular logic of the Parallelizer system
function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {
bytes32 position = TRANSMUTER_STORAGE_POSITION;
assembly ("memory-safe") {
ts.slot := position
}
}
/// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot
/// @dev This struct handles the logic for making the contract easily usable on Etherscan
function implementationStorage() internal pure returns (ImplementationStorage storage ims) {
bytes32 position = IMPLEMENTATION_STORAGE_POSITION;
assembly ("memory-safe") {
ims.slot := position
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title IRETH
/// @notice Interface for the `rETH` contract
interface IRETH {
function getExchangeRate() external view returns (uint256);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import { IParallelizerOracle } from "contracts/interfaces/IParallelizerOracle.sol";
import { AggregatorV3Interface } from "contracts/interfaces/external/chainlink/AggregatorV3Interface.sol";
import { IMorphoOracle } from "contracts/interfaces/external/morpho/IMorphoOracle.sol";
import { LibStorage as s } from "./LibStorage.sol";
import "../../utils/Constants.sol";
import "../../utils/Errors.sol";
import "../Storage.sol";
/// @title LibOracle
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This library is an authorized fork of Angle's `LibOracle` library
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/parallelizer/libraries/LibOracle.sol
library LibOracle {
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ACTIONS SPECIFIC ORACLES
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`
/// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor
function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {
(OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =
_parseOracleConfig(oracleConfig);
if (oracleType == OracleReadType.EXTERNAL) {
IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));
return externalOracle.readRedemption();
} else {
(oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);
return oracleValue;
}
}
/// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`
/// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle
/// value for the asset and its target price
function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {
(
OracleReadType oracleType,
OracleReadType targetType,
bytes memory oracleData,
bytes memory targetData,
bytes memory hyperparameters
) = _parseOracleConfig(oracleConfig);
if (oracleType == OracleReadType.EXTERNAL) {
IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));
return externalOracle.readMint();
}
(uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));
uint256 targetPrice;
(oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);
if (targetPrice < oracleValue) oracleValue = targetPrice;
}
/// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`
/// @return oracleValue The actual oracle value obtained
/// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target
/// price, otherwise `BASE_18`
function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {
(
OracleReadType oracleType,
OracleReadType targetType,
bytes memory oracleData,
bytes memory targetData,
bytes memory hyperparameters
) = _parseOracleConfig(oracleConfig);
if (oracleType == OracleReadType.EXTERNAL) {
IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));
return externalOracle.readBurn();
}
(uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));
uint256 targetPrice;
(oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);
// Firewall in case the oracle value reported is low compared to the target
// If the oracle value is slightly below its target, then no deviation is reported for the oracle and
// the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset
// is set to the target price, to not be open to direct arbitrage
ratio = BASE_18;
if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {
ratio = (oracleValue * BASE_18) / targetPrice;
} else if (oracleValue < targetPrice) {
oracleValue = targetPrice;
}
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
VIEW FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Internal version of the `getOracle` function
function getOracle(address collateral)
internal
view
returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)
{
return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);
}
/// @notice Gets the oracle value and the ratio with respect to the target price when it comes to
/// burning for `collateral`
function getBurnOracle(
address collateral,
bytes memory oracleConfig
)
internal
view
returns (uint256 minRatio, uint256 oracleValue)
{
ParallelizerStorage storage ts = s.transmuterStorage();
minRatio = BASE_18;
address[] memory collateralList = ts.collateralList;
uint256 length = collateralList.length;
for (uint256 i; i < length; ++i) {
uint256 ratioObserved = BASE_18;
if (collateralList[i] != collateral) {
(, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);
} else {
(oracleValue, ratioObserved) = readBurn(oracleConfig);
}
if (ratioObserved < minRatio) minRatio = ratioObserved;
}
}
/// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value
/// (e.g the target price of the asset)
/// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.
/// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price
function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {
if (quoteType == OracleQuoteType.UNIT) return BASE_18;
else return baseValue;
}
function readSpotAndTarget(
OracleReadType oracleType,
OracleReadType targetType,
bytes memory oracleData,
bytes memory targetData,
uint256 deviation
)
internal
view
returns (uint256 oracleValue, uint256 targetPrice)
{
targetPrice = read(targetType, BASE_18, targetData);
oracleValue = read(oracleType, targetPrice, oracleData);
// System may tolerate small deviations from target
// If the oracle value reported is reasonably close to the target
// --> disregard the oracle value and return the target price
if (
targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18
&& oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)
) oracleValue = targetPrice;
}
/// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`
function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {
if (readType == OracleReadType.CHAINLINK_FEEDS) {
(
AggregatorV3Interface[] memory circuitChainlink,
uint32[] memory stalePeriods,
uint8[] memory circuitChainIsMultiplied,
uint8[] memory chainlinkDecimals,
OracleQuoteType quoteType
) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));
uint256 quotePrice = quoteAmount(quoteType, baseValue);
uint256 listLength = circuitChainlink.length;
for (uint256 i; i < listLength; ++i) {
quotePrice = readChainlinkFeed(
quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]
);
}
return quotePrice;
} else if (readType == OracleReadType.STABLE) {
return BASE_18;
} else if (readType == OracleReadType.NO_ORACLE) {
return baseValue;
} else if (readType == OracleReadType.WSTETH) {
return STETH.getPooledEthByShares(1 ether);
} else if (readType == OracleReadType.CBETH) {
return CBETH.exchangeRate();
} else if (readType == OracleReadType.RETH) {
return RETH.getExchangeRate();
} else if (readType == OracleReadType.SFRXETH) {
return SFRXETH.pricePerShare();
} else if (readType == OracleReadType.MAX) {
uint256 maxValue = abi.decode(data, (uint256));
return maxValue;
} else if (readType == OracleReadType.MORPHO_ORACLE) {
(address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));
return IMorphoOracle(contractAddress).price() / normalizationFactor;
}
// If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a
// `targetPrice` in which case the `baseValue` is returned here
else {
return baseValue;
}
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SPECIFIC HELPERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency
/// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`
/// @param feed Chainlink feed to query
/// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`
/// @param decimals Number of decimals of the corresponding Chainlink pair
/// @return The `quoteAmount` converted in out-currency
function readChainlinkFeed(
uint256 _quoteAmount,
AggregatorV3Interface feed,
uint8 multiplied,
uint256 decimals,
uint32 stalePeriod
)
internal
view
returns (uint256)
{
(, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();
if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();
// Checking whether we should multiply or divide by the ratio computed
if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);
else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);
}
/// @notice Parses an `oracleConfig` into several sub fields
function _parseOracleConfig(bytes memory oracleConfig)
private
pure
returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)
{
return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));
}
function updateOracle(address collateral) internal {
ParallelizerStorage storage ts = s.transmuterStorage();
if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();
(
OracleReadType oracleType,
OracleReadType targetType,
bytes memory oracleData,
bytes memory targetData,
bytes memory hyperparameters
) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);
if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();
uint256 oracleValue = read(oracleType, BASE_18, oracleData);
uint256 maxValue = abi.decode(targetData, (uint256));
if (oracleValue > maxValue) {
ts.collaterals[collateral].oracleConfig = abi.encode(
oracleType,
targetType,
oracleData,
// There are no checks whether the value increased or not
abi.encode(oracleValue),
hyperparameters
);
} else {
revert OracleUpdateFailed();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
pragma solidity ^0.8.20;
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*
* _Available since v5.1._
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
assembly ("memory-safe") {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.28;
import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
import "../parallelizer/Storage.sol";
/// @title ISettersGovernor
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface
/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol
interface ISettersGovernor {
/// @notice Recovers `amount` of `token` from the Parallelizer contract
function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;
/// @notice Sets a new access manager address
function setAccessManager(address _newAccessManager) external;
/// @notice Sets (or unsets) a collateral manager `collateral`
/// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has
/// assets before setting the new manager
function setCollateralManager(
address collateral,
bool checkExternalManagerBalance,
ManagerStorage memory managerData
)
external;
/// @notice Sets the allowance of the contract on `token` for `spender` to `amount`
function changeAllowance(IERC20 token, address spender, uint256 amount) external;
/// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer
function toggleTrusted(address sender, TrustedType t) external;
/// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted
/// addresses
/// and sets the data used to read into the whitelist
function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;
/// @notice Add `collateral` as a supported collateral in the system
function addCollateral(address collateral) external;
/// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`
function adjustStablecoins(address collateral, uint128 amount, bool increase) external;
/// @notice Revokes `collateral` from the system
/// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has
/// assets before revoking the collateral
function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;
/// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption
/// operations
function setOracle(address collateral, bytes memory oracleConfig) external;
/// @notice Update oracle data for a given `collateral`
function updateOracle(address collateral) external;
}
/// @title ISettersGovernor
/// @author Cooper Labs
/// @custom:contact [email protected]
interface ISettersGuardian {
/// @notice Changes the pause status for mint or burn transactions for `collateral`
function togglePause(address collateral, ActionType action) external;
/// @notice Sets the mint or burn fees for `collateral`
function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;
/// @notice Sets the parameters for the redemption curve
function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;
/// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`
function toggleWhitelist(WhitelistType whitelistType, address who) external;
/// @notice Sets the stablecoin cap that can be issued from a `collateral`
function setStablecoinCap(address collateral, uint256 stablecoinCap) external;
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
import { LibStorage as s } from "./LibStorage.sol";
import { IAccessManager } from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
import { AuthorityUtils } from "@openzeppelin/contracts/access/manager/AuthorityUtils.sol";
import "../../utils/Errors.sol";
import "../../utils/Constants.sol";
import "../Storage.sol";
/// @title LibDiamond
/// @author Cooper Labs
/// @custom:contact [email protected]
/// @notice Helper library to deal with diamond proxies.
/// @dev Reference: EIP-2535 Diamonds
/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen
library LibDiamond {
event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
function isGovernor(address caller) internal view returns (bool) {
(bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);
return isMember;
}
/// @notice Checks whether `caller` can call `data` on `this`
function checkCanCall(address caller, bytes calldata data) internal returns (bool) {
IAccessManager accessManager = s.diamondStorage().accessManager;
(bool immediate, uint32 delay) =
AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));
if (!immediate) {
if (delay > 0) {
ParallelizerStorage storage ts = s.transmuterStorage();
ts.consumingSchedule = true;
accessManager.consumeScheduledOp(caller, data);
ts.consumingSchedule = false;
} else {
return false;
}
}
return true;
}
/// @notice Internal function version of `diamondCut`
function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {
uint256 diamondCutLength = _diamondCut.length;
for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {
bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;
address facetAddress = _diamondCut[facetIndex].facetAddress;
if (functionSelectors.length == 0) {
revert NoSelectorsProvidedForFacetForCut(facetAddress);
}
FacetCutAction action = _diamondCut[facetIndex].action;
if (action == FacetCutAction.Add) {
_addFunctions(facetAddress, functionSelectors);
} else if (action == FacetCutAction.Replace) {
_replaceFunctions(facetAddress, functionSelectors);
} else if (action == FacetCutAction.Remove) {
_removeFunctions(facetAddress, functionSelectors);
}
}
emit DiamondCut(_diamondCut, _init, _calldata);
_initializeDiamondCut(_init, _calldata);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PRIVATE FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Does a delegate call on `_init` with `_calldata`
function _initializeDiamondCut(address _init, bytes memory _calldata) private {
if (_init == address(0)) {
return;
}
_enforceHasContractCode(_init);
(bool success, bytes memory error) = _init.delegatecall(_calldata);
if (!success) {
if (error.length > 0) {
assembly ("memory-safe") {
let returndata_size := mload(error)
revert(add(32, error), returndata_size)
}
} else {
revert InitializationFunctionReverted(_init, _calldata);
}
}
}
/// @notice Adds a new function to the diamond proxy
/// @dev Reverts if selectors are already existing
function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {
if (_facetAddress == address(0)) {
revert CannotAddSelectorsToZeroAddress(_functionSelectors);
}
DiamondStorage storage ds = s.diamondStorage();
uint16 selectorCount = uint16(ds.selectors.length);
_enforceHasContractCode(_facetAddress);
uint256 functionSelectorsLength = _functionSelectors.length;
for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.selectorInfo[selector].facetAddress;
if (oldFacetAddress != address(0)) {
revert CannotAddFunctionToDiamondThatAlreadyExists(selector);
}
ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);
ds.selectors.push(selector);
selectorCount++;
}
}
/// @notice Upgrades a function in the diamond proxy
/// @dev Reverts if selectors do not already exist
function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {
DiamondStorage storage ds = s.diamondStorage();
if (_facetAddress == address(0)) {
revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);
}
_enforceHasContractCode(_facetAddress);
uint256 functionSelectorsLength = _functionSelectors.length;
for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.selectorInfo[selector].facetAddress;
// Can't replace immutable functions -- functions defined directly in the diamond in this case
if (oldFacetAddress == address(this)) {
revert CannotReplaceImmutableFunction(selector);
}
if (oldFacetAddress == _facetAddress) {
revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);
}
if (oldFacetAddress == address(0)) {
revert CannotReplaceFunctionThatDoesNotExists(selector);
}
// Replace old facet address
ds.selectorInfo[selector].facetAddress = _facetAddress;
}
}
/// @notice Removes a function in the diamond proxy
/// @dev Reverts if selectors do not already exist
function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {
DiamondStorage storage ds = s.diamondStorage();
uint256 selectorCount = ds.selectors.length;
if (_facetAddress != address(0)) {
revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);
}
uint256 functionSelectorsLength = _functionSelectors.length;
for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];
if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {
revert CannotRemoveFunctionThatDoesNotExist(selector);
}
// Can't remove immutable functions -- functions defined directly in the diamond
if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {
revert CannotRemoveImmutableFunction(selector);
}
// Replace selector with last selector
selectorCount--;
if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {
bytes4 lastSelector = ds.selectors[selectorCount];
ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;
ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;
}
// Delete last selector
ds.selectors.pop();
delete ds.selectorInfo[selector];
}
}
/// @notice Checks that an address has a non void bytecode
function _enforceHasContractCode(address _contract) private view {
uint256 contractSize;
assembly ("memory-safe") {
contractSize := extcodesize(_contract)
}
if (contractSize == 0) {
revert ContractHasNoCode();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2²⁵⁶ + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 1);
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 1);
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.28; /// @title IManager /// @author Cooper Labs /// @custom:contact [email protected] /// @dev This interface is an authorized fork of Angle's `IManager` interface /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol interface IManager { /// @notice Returns the amount of collateral managed by the Manager /// @return balances Balances of all the subCollaterals handled by the manager /// @dev MUST NOT revert function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue); /// @notice Hook to invest `amount` of `collateral` /// @dev MUST revert if the manager cannot accept these funds /// @dev MUST have received the funds beforehand function invest(uint256 amount) external; /// @notice Sends `amount` of `collateral` to the `to` address /// @dev Called when `tokenP` are burnt and during redemptions // @dev MUST revert if there are not funds enough available /// @dev MUST be callable only by the parallelizer function release(address asset, address to, uint256 amount) external; /// @notice Gives the maximum amount of collateral immediately available for a transfer /// @dev Useful for integrators using `quoteIn` and `quoteOut` function maxAvailable() external view returns (uint256); }
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/IAccessManager.sol)
pragma solidity ^0.8.20;
import {Time} from "../../utils/types/Time.sol";
interface IAccessManager {
/**
* @dev A delayed operation was scheduled.
*/
event OperationScheduled(
bytes32 indexed operationId,
uint32 indexed nonce,
uint48 schedule,
address caller,
address target,
bytes data
);
/**
* @dev A scheduled operation was executed.
*/
event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);
/**
* @dev A scheduled operation was canceled.
*/
event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);
/**
* @dev Informational labelling for a roleId.
*/
event RoleLabel(uint64 indexed roleId, string label);
/**
* @dev Emitted when `account` is granted `roleId`.
*
* NOTE: The meaning of the `since` argument depends on the `newMember` argument.
* If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,
* otherwise it indicates the execution delay for this account and roleId is updated.
*/
event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);
/**
* @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.
*/
event RoleRevoked(uint64 indexed roleId, address indexed account);
/**
* @dev Role acting as admin over a given `roleId` is updated.
*/
event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);
/**
* @dev Role acting as guardian over a given `roleId` is updated.
*/
event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);
/**
* @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.
*/
event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);
/**
* @dev Target mode is updated (true = closed, false = open).
*/
event TargetClosed(address indexed target, bool closed);
/**
* @dev Role required to invoke `selector` on `target` is updated to `roleId`.
*/
event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);
/**
* @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.
*/
event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);
error AccessManagerAlreadyScheduled(bytes32 operationId);
error AccessManagerNotScheduled(bytes32 operationId);
error AccessManagerNotReady(bytes32 operationId);
error AccessManagerExpired(bytes32 operationId);
error AccessManagerLockedRole(uint64 roleId);
error AccessManagerBadConfirmation();
error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);
error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);
error AccessManagerUnauthorizedConsume(address target);
error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);
error AccessManagerInvalidInitialAdmin(address initialAdmin);
/**
* @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with
* no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}
* & {execute} workflow.
*
* This function is usually called by the targeted contract to control immediate execution of restricted functions.
* Therefore we only return true if the call can be performed without any delay. If the call is subject to a
* previously set delay (not zero), then the function should return false and the caller should schedule the operation
* for future execution.
*
* If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise
* the operation can be executed if and only if delay is greater than 0.
*
* NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that
* is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail
* to identify the indirect workflow, and will consider calls that require a delay to be forbidden.
*
* NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the
* {AccessManager} documentation.
*/
function canCall(
address caller,
address target,
bytes4 selector
) external view returns (bool allowed, uint32 delay);
/**
* @dev Expiration delay for scheduled proposals. Defaults to 1 week.
*
* IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,
* disabling any scheduling usage.
*/
function expiration() external view returns (uint32);
/**
* @dev Minimum setback for all delay updates, with the exception of execution delays. It
* can be increased without setback (and reset via {revokeRole} in the case event of an
* accidental increase). Defaults to 5 days.
*/
function minSetback() external view returns (uint32);
/**
* @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.
*
* NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.
*/
function isTargetClosed(address target) external view returns (bool);
/**
* @dev Get the role required to call a function.
*/
function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);
/**
* @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.
*/
function getTargetAdminDelay(address target) external view returns (uint32);
/**
* @dev Get the id of the role that acts as an admin for the given role.
*
* The admin permission is required to grant the role, revoke the role and update the execution delay to execute
* an operation that is restricted to this role.
*/
function getRoleAdmin(uint64 roleId) external view returns (uint64);
/**
* @dev Get the role that acts as a guardian for a given role.
*
* The guardian permission allows canceling operations that have been scheduled under the role.
*/
function getRoleGuardian(uint64 roleId) external view returns (uint64);
/**
* @dev Get the role current grant delay.
*
* Its value may change at any point without an event emitted following a call to {setGrantDelay}.
* Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.
*/
function getRoleGrantDelay(uint64 roleId) external view returns (uint32);
/**
* @dev Get the access details for a given account for a given role. These details include the timepoint at which
* membership becomes active, and the delay applied to all operation by this user that requires this permission
* level.
*
* Returns:
* [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.
* [1] Current execution delay for the account.
* [2] Pending execution delay for the account.
* [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.
*/
function getAccess(
uint64 roleId,
address account
) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);
/**
* @dev Check if a given account currently has the permission level corresponding to a given role. Note that this
* permission might be associated with an execution delay. {getAccess} can provide more details.
*/
function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);
/**
* @dev Give a label to a role, for improved role discoverability by UIs.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {RoleLabel} event.
*/
function labelRole(uint64 roleId, string calldata label) external;
/**
* @dev Add `account` to `roleId`, or change its execution delay.
*
* This gives the account the authorization to call any function that is restricted to this role. An optional
* execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation
* that is restricted to members of this role. The user will only be able to execute the operation after the delay has
* passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).
*
* If the account has already been granted this role, the execution delay will be updated. This update is not
* immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is
* called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any
* operation executed in the 3 hours that follows this update was indeed scheduled before this update.
*
* Requirements:
*
* - the caller must be an admin for the role (see {getRoleAdmin})
* - granted role must not be the `PUBLIC_ROLE`
*
* Emits a {RoleGranted} event.
*/
function grantRole(uint64 roleId, address account, uint32 executionDelay) external;
/**
* @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has
* no effect.
*
* Requirements:
*
* - the caller must be an admin for the role (see {getRoleAdmin})
* - revoked role must not be the `PUBLIC_ROLE`
*
* Emits a {RoleRevoked} event if the account had the role.
*/
function revokeRole(uint64 roleId, address account) external;
/**
* @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in
* the role this call has no effect.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*
* Emits a {RoleRevoked} event if the account had the role.
*/
function renounceRole(uint64 roleId, address callerConfirmation) external;
/**
* @dev Change admin role for a given role.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {RoleAdminChanged} event
*/
function setRoleAdmin(uint64 roleId, uint64 admin) external;
/**
* @dev Change guardian role for a given role.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {RoleGuardianChanged} event
*/
function setRoleGuardian(uint64 roleId, uint64 guardian) external;
/**
* @dev Update the delay for granting a `roleId`.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {RoleGrantDelayChanged} event.
*/
function setGrantDelay(uint64 roleId, uint32 newDelay) external;
/**
* @dev Set the role required to call functions identified by the `selectors` in the `target` contract.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {TargetFunctionRoleUpdated} event per selector.
*/
function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;
/**
* @dev Set the delay for changing the configuration of a given target contract.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {TargetAdminDelayUpdated} event.
*/
function setTargetAdminDelay(address target, uint32 newDelay) external;
/**
* @dev Set the closed flag for a contract.
*
* Closing the manager itself won't disable access to admin methods to avoid locking the contract.
*
* Requirements:
*
* - the caller must be a global admin
*
* Emits a {TargetClosed} event.
*/
function setTargetClosed(address target, bool closed) external;
/**
* @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the
* operation is not yet scheduled, has expired, was executed, or was canceled.
*/
function getSchedule(bytes32 id) external view returns (uint48);
/**
* @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never
* been scheduled.
*/
function getNonce(bytes32 id) external view returns (uint32);
/**
* @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to
* choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays
* required for the caller. The special value zero will automatically set the earliest possible time.
*
* Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when
* the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this
* scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.
*
* Emits a {OperationScheduled} event.
*
* NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If
* this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target
* contract if it is using standard Solidity ABI encoding.
*/
function schedule(
address target,
bytes calldata data,
uint48 when
) external returns (bytes32 operationId, uint32 nonce);
/**
* @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the
* execution delay is 0.
*
* Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the
* operation wasn't previously scheduled (if the caller doesn't have an execution delay).
*
* Emits an {OperationExecuted} event only if the call was scheduled and delayed.
*/
function execute(address target, bytes calldata data) external payable returns (uint32);
/**
* @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled
* operation that is cancelled.
*
* Requirements:
*
* - the caller must be the proposer, a guardian of the targeted function, or a global admin
*
* Emits a {OperationCanceled} event.
*/
function cancel(address caller, address target, bytes calldata data) external returns (uint32);
/**
* @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed
* (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.
*
* This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,
* with all the verifications that it implies.
*
* Emit a {OperationExecuted} event.
*/
function consumeScheduledOp(address caller, bytes calldata data) external;
/**
* @dev Hashing function for delayed operations.
*/
function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);
/**
* @dev Changes the authority of a target managed by this manager instance.
*
* Requirements:
*
* - the caller must be a global admin
*/
function updateAuthority(address target, address newAuthority) external;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;
/// @title IKeyringGuard
/// @notice Interface for the `KeyringGuard` contract
interface IKeyringGuard {
function isAuthorized(address from, address to) external returns (bool passed);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../utils/introspection/IERC165.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}{
"evmVersion": "cancun",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 1000
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"viaIR": true
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"AccessManagedUnauthorized","type":"error"},{"inputs":[],"name":"AlreadyAdded","type":"error"},{"inputs":[],"name":"CollateralBacked","type":"error"},{"inputs":[],"name":"InvalidAccessManager","type":"error"},{"inputs":[],"name":"InvalidChainlinkRate","type":"error"},{"inputs":[],"name":"InvalidParams","type":"error"},{"inputs":[],"name":"ManagerHasAssets","type":"error"},{"inputs":[],"name":"NotCollateral","type":"error"},{"inputs":[],"name":"NotTrusted","type":"error"},{"inputs":[],"name":"OracleUpdateFailed","type":"error"},{"inputs":[{"internalType":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"currentAllowance","type":"uint256"},{"internalType":"uint256","name":"requestedDecrease","type":"uint256"}],"name":"SafeERC20FailedDecreaseAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"}],"name":"CollateralAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"},{"components":[{"internalType":"contract IERC20[]","name":"subCollaterals","type":"address[]"},{"internalType":"bytes","name":"config","type":"bytes"}],"indexed":false,"internalType":"struct ManagerStorage","name":"managerData","type":"tuple"}],"name":"CollateralManagerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"}],"name":"CollateralRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"bytes","name":"whitelistData","type":"bytes"},{"indexed":false,"internalType":"uint8","name":"whitelistStatus","type":"uint8"}],"name":"CollateralWhitelistStatusUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"bytes","name":"oracleConfig","type":"bytes"}],"name":"OracleSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"increase","type":"bool"}],"name":"ReservesAdjusted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bool","name":"isTrusted","type":"bool"},{"indexed":false,"internalType":"enum TrustedType","name":"trustedType","type":"uint8"}],"name":"TrustedToggled","type":"event"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"}],"name":"addCollateral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"bool","name":"increase","type":"bool"}],"name":"adjustStablecoins","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"changeAllowance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"bool","name":"checkExternalManagerBalance","type":"bool"}],"name":"revokeCollateral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newAccessManager","type":"address"}],"name":"setAccessManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"bool","name":"checkExternalManagerBalance","type":"bool"},{"components":[{"internalType":"contract IERC20[]","name":"subCollaterals","type":"address[]"},{"internalType":"bytes","name":"config","type":"bytes"}],"internalType":"struct ManagerStorage","name":"managerData","type":"tuple"}],"name":"setCollateralManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"bytes","name":"oracleConfig","type":"bytes"}],"name":"setOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"uint8","name":"whitelistStatus","type":"uint8"},{"internalType":"bytes","name":"whitelistData","type":"bytes"}],"name":"setWhitelistStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"enum TrustedType","name":"t","type":"uint8"}],"name":"toggleTrusted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"}],"name":"updateOracle","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Loading...
Loading
0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7
Net Worth in USD
$0.00
Net Worth in HYPE
0
Multichain Portfolio | 35 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.