Overview
S Balance
0 SS Value
$0.00More Info
Private Name Tags
ContractCreator
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
PrincipalToken
Compiler Version
v0.8.20+commit.a1b79de6
Optimization Enabled:
Yes with 200 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.20;
import "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";
import "openzeppelin-contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/PausableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import "openzeppelin-math/Math.sol";
import "openzeppelin-erc20-extensions/ERC20PermitUpgradeable.sol";
import "openzeppelin-contracts/proxy/beacon/BeaconProxy.sol";
import "openzeppelin-contracts/interfaces/IERC3156FlashBorrower.sol";
import "openzeppelin-contracts/interfaces/IERC4626.sol";
import "../libraries/PrincipalTokenUtil.sol";
import "../libraries/NamingUtil.sol";
import "../libraries/RayMath.sol";
import "../interfaces/IRegistry.sol";
import "../interfaces/IPrincipalToken.sol";
import "../interfaces/IYieldToken.sol";
import "../interfaces/IRewardsProxy.sol";
/**
* @title PrincipalToken contract
* @author Spectra Finance
* @notice A PrincipalToken (PT) is an ERC5095 vault that allows user to tokenize their yield in a permissionless manner.
* The shares of the vaults are composed by PT/YT pairs. These are always minted at same times and amounts upon deposits.
* Until expiry burning shares necessitates to burn both tokens. At expiry, burning PTs is sufficient.
*/
contract PrincipalToken is
ERC20PermitUpgradeable,
AccessManagedUpgradeable,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
IPrincipalToken
{
using SafeERC20 for IERC20;
using PrincipalTokenUtil for address;
using PrincipalTokenUtil for uint256;
using RayMath for uint256;
using Math for uint256;
/** @dev minimum allowed decimals for underlying and IBT */
uint256 private constant MIN_DECIMALS = 6;
/** @dev maximum allowed decimals for underlying and IBT */
uint256 private constant MAX_DECIMALS = 18;
/** @dev Rates At Expiry not stored */
uint256 private constant RAE_NOT_STORED = 0;
/** @dev Rates At Expiry stored */
uint256 private constant RAE_STORED = 1;
/** @dev expected return value from borrowers onFlashLoan function */
bytes32 private constant ON_FLASH_LOAN = keccak256("ERC3156FlashBorrower.onFlashLoan");
/** @notice registry of the protocol */
address private immutable registry;
/** @notice rewards proxy for this specific instance of PT */
address private rewardsProxy;
/** @dev decimals of the IBT */
uint8 private ibtDecimals;
/** @dev decimals of the underlying asset */
uint8 private underlyingDecimals;
/** @notice Interest Bearing Token 4626 held by this PT vault */
address private ibt;
/** @notice underlying asset of this PT vault (which is also the underlying of the IBT 4626) */
address private underlying_;
/** @notice YT corresponding to this PT, deployed at initialization */
address private yt;
/** @dev represents one unit of the IBT held by this PT vault (10^decimals) */
uint256 private ibtUnit;
/** @dev PT price in asset (in Ray) */
uint256 private ptRate;
/** @dev IBT price in asset (in Ray) */
uint256 private ibtRate;
/** @dev unclaimed fees */
uint256 private unclaimedFeesInIBT;
/** @dev total fees */
uint256 private totalFeesInIBT;
/** @dev date of maturity (set at initialization) */
uint256 private expiry;
/** @dev duration to maturity */
uint256 private duration;
/** @dev uint256 flag acting as a boolean to track whether PT and IBT rates have been stored after expiry */
uint256 private ratesAtExpiryStored;
/** @dev stores each user's IBT rate (in Ray) */
mapping(address user => uint256 lastIBTRate) private ibtRateOfUser;
/** @dev stores each user's PT rate (in Ray) */
mapping(address user => uint256 lastPTRate) private ptRateOfUser;
/** @dev stores each user's yield generated from YTs */
mapping(address user => uint256 yieldInIBT) private yieldOfUserInIBT;
/* EVENTS
*****************************************************************************************************************/
event Redeem(address indexed from, address indexed to, uint256 amount);
event Mint(address indexed from, address indexed to, uint256 amount);
event YTDeployed(address indexed yt);
event YieldUpdated(address indexed user, uint256 indexed yieldInIBT);
event YieldClaimed(address indexed owner, address indexed receiver, uint256 indexed yieldInIBT);
event FeeClaimed(
address indexed user,
uint256 indexed redeemedIbts,
uint256 indexed receivedAssets
);
event RatesStoredAtExpiry(uint256 indexed ibtRate, uint256 indexed ptRate);
event RewardsProxyChange(address indexed oldRewardsProxy, address indexed newRewardsProxy);
/* MODIFIERS
*****************************************************************************************************************/
/** @notice Ensures the current block timestamp is before expiry */
modifier notExpired() virtual {
if (block.timestamp >= expiry) {
revert PTExpired();
}
_;
}
/** @notice Ensures the current block timestamp is at or after expiry */
modifier afterExpiry() virtual {
if (block.timestamp < expiry) {
revert PTNotExpired();
}
_;
}
/* CONSTRUCTOR
*****************************************************************************************************************/
constructor(address _registry) {
if (_registry == address(0)) {
revert AddressError();
}
registry = _registry;
_disableInitializers(); // using this so that the deployed logic contract cannot later be initialized
}
/* INITIALIZER
*****************************************************************************************************************/
/**
* @dev First function called after deployment of the contract
* it deploys yt and initializes values of required variables
* @param _ibt The token which PT contract holds
* @param _duration The duration (in s) to expiry/maturity of the PT contract
* @param _initialAuthority The initial authority of the PT contract
*/
function initialize(
address _ibt,
uint256 _duration,
address _initialAuthority
) external initializer {
if (_ibt == address(0) || _initialAuthority == address(0)) {
revert AddressError();
}
if (IERC4626(_ibt).totalAssets() == 0) {
revert RateError();
}
duration = _duration;
uint256 _expiry = _duration + block.timestamp;
expiry = _expiry;
string memory _ibtSymbol = IERC4626(_ibt).symbol();
string memory _name = NamingUtil.genPTName(_ibtSymbol, _expiry);
__ERC20_init(_name, NamingUtil.genPTSymbol(_ibtSymbol, _expiry));
__ERC20Permit_init(_name);
__Pausable_init();
__ReentrancyGuard_init();
__AccessManaged_init(_initialAuthority);
underlying_ = IERC4626(_ibt).asset();
uint8 _underlyingDecimals = underlying_.tryGetTokenDecimals();
uint8 _ibtDecimals = IERC4626(_ibt).decimals();
if (
_underlyingDecimals < MIN_DECIMALS ||
_underlyingDecimals > _ibtDecimals ||
_ibtDecimals > MAX_DECIMALS
) {
revert InvalidDecimals();
}
underlyingDecimals = _underlyingDecimals;
ibtDecimals = _ibtDecimals;
ibt = _ibt;
ibtUnit = 10 ** _ibtDecimals;
ibtRate = IERC4626(_ibt).previewRedeem(ibtUnit).toRay(_underlyingDecimals);
ptRate = RayMath.RAY_UNIT;
yt = _deployYT(
NamingUtil.genYTName(_ibtSymbol, _expiry),
NamingUtil.genYTSymbol(_ibtSymbol, _expiry)
);
}
/** @dev See {PausableUpgradeable-_pause}. */
function pause() external override restricted {
_pause();
}
/** @dev See {PausableUpgradeable-_unPause}. */
function unPause() external override restricted {
_unpause();
}
/** @dev See {IPrincipalToken-deposit}. */
function deposit(uint256 assets, address receiver) external override returns (uint256 shares) {
shares = deposit(assets, receiver, receiver);
}
/** @dev See {IPrincipalToken-deposit}. */
function deposit(
uint256 assets,
address ptReceiver,
address ytReceiver
) public override nonReentrant returns (uint256 shares) {
address _ibt = ibt;
address _underlying = underlying_;
IERC20(_underlying).safeTransferFrom(msg.sender, address(this), assets);
IERC20(_underlying).safeIncreaseAllowance(_ibt, assets);
uint256 ibts = IERC4626(_ibt).deposit(assets, address(this));
shares = _depositIBT(ibts, ptReceiver, ytReceiver);
}
/** @dev See {IPrincipalToken-deposit}. */
function deposit(
uint256 assets,
address ptReceiver,
address ytReceiver,
uint256 minShares
) external override returns (uint256 shares) {
shares = deposit(assets, ptReceiver, ytReceiver);
if (shares < minShares) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-depositIBT}. */
function depositIBT(uint256 ibts, address receiver) external override returns (uint256 shares) {
shares = depositIBT(ibts, receiver, receiver);
}
/** @dev See {IPrincipalToken-depositIBT}. */
function depositIBT(
uint256 ibts,
address ptReceiver,
address ytReceiver
) public override nonReentrant returns (uint256 shares) {
IERC20(ibt).safeTransferFrom(msg.sender, address(this), ibts);
shares = _depositIBT(ibts, ptReceiver, ytReceiver);
}
/** @dev See {IPrincipalToken-depositIBT}. */
function depositIBT(
uint256 ibts,
address ptReceiver,
address ytReceiver,
uint256 minShares
) external override returns (uint256 shares) {
shares = depositIBT(ibts, ptReceiver, ytReceiver);
if (shares < minShares) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-redeem}. */
function redeem(
uint256 shares,
address receiver,
address owner
) public override nonReentrant returns (uint256 assets) {
_beforeRedeem(shares, owner);
emit Redeem(owner, receiver, shares);
assets = IERC4626(ibt).redeem(_convertSharesToIBTs(shares, false), receiver, address(this));
}
/** @dev See {IPrincipalToken-redeem}. */
function redeem(
uint256 shares,
address receiver,
address owner,
uint256 minAssets
) external override returns (uint256 assets) {
assets = redeem(shares, receiver, owner);
if (assets < minAssets) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-redeemForIBT}. */
function redeemForIBT(
uint256 shares,
address receiver,
address owner
) public override nonReentrant returns (uint256 ibts) {
_beforeRedeem(shares, owner);
ibts = _convertSharesToIBTs(shares, false);
emit Redeem(owner, receiver, shares);
if (ibts != 0) {
IERC20(ibt).safeTransfer(receiver, ibts);
}
}
/** @dev See {IPrincipalToken-redeemForIBT}. */
function redeemForIBT(
uint256 shares,
address receiver,
address owner,
uint256 minIbts
) external override returns (uint256 ibts) {
ibts = redeemForIBT(shares, receiver, owner);
if (ibts < minIbts) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-withdraw}. */
function withdraw(
uint256 assets,
address receiver,
address owner
) public override nonReentrant returns (uint256 shares) {
_beforeWithdraw(assets, owner);
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(false);
uint256 ibts = IERC4626(ibt).withdraw(assets, receiver, address(this));
shares = _burnSharesForWithdraw(ibts, receiver, owner, _ptRate, _ibtRate);
}
/** @dev See {IPrincipalToken-withdraw}. */
function withdraw(
uint256 assets,
address receiver,
address owner,
uint256 maxShares
) external override returns (uint256 shares) {
shares = withdraw(assets, receiver, owner);
if (shares > maxShares) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-withdrawIBT}. */
function withdrawIBT(
uint256 ibts,
address receiver,
address owner
) public override nonReentrant returns (uint256 shares) {
address _ibt = ibt;
_beforeWithdraw(IERC4626(_ibt).previewRedeem(ibts), owner);
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(false);
shares = _burnSharesForWithdraw(ibts, receiver, owner, _ptRate, _ibtRate);
// send IBTs from this contract to receiver
IERC20(_ibt).safeTransfer(receiver, ibts);
}
/** @dev See {IPrincipalToken-withdrawIBT}. */
function withdrawIBT(
uint256 ibts,
address receiver,
address owner,
uint256 maxShares
) external override returns (uint256 shares) {
shares = withdrawIBT(ibts, receiver, owner);
if (shares > maxShares) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-claimFees}. */
function claimFees(
uint256 _minAssets
) external override whenNotPaused returns (uint256 assets) {
if (msg.sender != IRegistry(registry).getFeeCollector()) {
revert UnauthorizedCaller();
}
uint256 ibts = unclaimedFeesInIBT;
unclaimedFeesInIBT = 0;
emit FeeClaimed(msg.sender, ibts, assets);
assets = IERC4626(ibt).redeem(ibts, msg.sender, address(this));
if (_minAssets > assets) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-updateYield}. */
function updateYield(
address _user
) public override whenNotPaused returns (uint256 updatedUserYieldInIBT) {
(uint256 _ptRate, uint256 _ibtRate) = _updatePTandIBTRates();
uint256 _oldIBTRateUser = ibtRateOfUser[_user];
if (_oldIBTRateUser != _ibtRate) {
ibtRateOfUser[_user] = _ibtRate;
}
uint256 _oldPTRateUser = ptRateOfUser[_user];
if (_oldPTRateUser != _ptRate) {
ptRateOfUser[_user] = _ptRate;
}
// Check for skipping yield update when the user deposits for the first time or rates decreased to 0.
if (_oldIBTRateUser != 0) {
updatedUserYieldInIBT = _user.computeYield(
yieldOfUserInIBT[_user],
_oldIBTRateUser,
_ibtRate,
_oldPTRateUser,
_ptRate,
yt
);
yieldOfUserInIBT[_user] = updatedUserYieldInIBT;
emit YieldUpdated(_user, updatedUserYieldInIBT);
}
}
/** @dev See {IPrincipalToken-claimYield}. */
function claimYield(
address _receiver,
uint256 _minAssets
) public override returns (uint256 yieldInAsset) {
uint256 yieldInIBT = _claimYield();
emit YieldClaimed(msg.sender, _receiver, yieldInIBT);
if (yieldInIBT != 0) {
yieldInAsset = IERC4626(ibt).redeem(yieldInIBT, _receiver, address(this));
}
if (_minAssets > yieldInAsset) {
revert ERC5143SlippageProtectionFailed();
}
}
/** @dev See {IPrincipalToken-claimYieldInIBT}. */
function claimYieldInIBT(
address _receiver,
uint256 _minIBT
) public override returns (uint256 yieldInIBT) {
yieldInIBT = _claimYield();
if (_minIBT > yieldInIBT) {
revert ERC5143SlippageProtectionFailed();
}
emit YieldClaimed(msg.sender, _receiver, yieldInIBT);
if (yieldInIBT != 0) {
IERC20(ibt).safeTransfer(_receiver, yieldInIBT);
}
}
/** @dev See {IPrincipalToken-beforeYtTransfer}. */
function beforeYtTransfer(address _from, address _to) external override {
if (msg.sender != yt) {
revert UnauthorizedCaller();
}
updateYield(_from);
updateYield(_to);
}
/** @dev See {IPrincipalToken-claimRewards}. */
function claimRewards(bytes memory _data) external restricted whenNotPaused {
address _rewardsProxy = rewardsProxy;
if (_rewardsProxy == address(0) || _rewardsProxy.code.length == 0) {
revert NoRewardsProxy();
}
bytes memory _data2 = abi.encodeCall(IRewardsProxy(address(0)).claimRewards, (_data));
(bool success, ) = _rewardsProxy.delegatecall(_data2);
if (!success) {
revert ClaimRewardsFailed();
}
}
/** @dev See {IERC3156FlashLender-flashLoan}. */
function flashLoan(
IERC3156FlashBorrower _receiver,
address _token,
uint256 _amount,
bytes calldata _data
) external override whenNotPaused returns (bool) {
if (_amount > maxFlashLoan(_token)) revert FlashLoanExceedsMaxAmount();
uint256 fee = flashFee(_token, _amount);
_updateFees(fee);
// Initiate the flash loan by lending the requested IBT amount
address _ibt = ibt;
IERC20(_ibt).safeTransfer(address(_receiver), _amount);
// Execute the flash loan
if (_receiver.onFlashLoan(msg.sender, _token, _amount, fee, _data) != ON_FLASH_LOAN)
revert FlashLoanCallbackFailed();
// Repay the debt + fee
IERC20(_ibt).safeTransferFrom(address(_receiver), address(this), _amount + fee);
return true;
}
/* SETTERS
*****************************************************************************************************************/
/** @dev See {IPrincipalToken-storeRatesAtExpiry}. */
function storeRatesAtExpiry() public override afterExpiry whenNotPaused {
if (ratesAtExpiryStored == RAE_STORED) {
revert RatesAtExpiryAlreadyStored();
}
ratesAtExpiryStored = RAE_STORED;
// PT rate not rounded up here
(uint256 _ptRate, uint256 _ibtRate) = _getCurrentPTandIBTRates(false);
ptRate = _ptRate;
ibtRate = _ibtRate;
emit RatesStoredAtExpiry(_ibtRate, _ptRate);
}
/** @dev See {IPrincipalToken-setRewardsProxy}. */
function setRewardsProxy(address _rewardsProxy) external restricted {
// Note: address zero is allowed in order to disable the claim proxy
emit RewardsProxyChange(rewardsProxy, _rewardsProxy);
rewardsProxy = _rewardsProxy;
}
/* GETTERS
*****************************************************************************************************************/
/** @dev See {IPrincipalToken-previewDeposit}. */
function previewDeposit(uint256 assets) external view override returns (uint256) {
uint256 ibts = IERC4626(ibt).previewDeposit(assets);
return previewDepositIBT(ibts);
}
/** @dev See {IPrincipalToken-previewDepositIBT}. */
function previewDepositIBT(
uint256 ibts
) public view override notExpired whenNotPaused returns (uint256) {
uint256 tokenizationFee = ibts._computeTokenizationFee(address(this), registry);
return _convertIBTsToSharesPreview(ibts - tokenizationFee);
}
/** @dev See {IPrincipalToken-maxDeposit}. */
function maxDeposit(address /* receiver */) external view override returns (uint256) {
return paused() || (block.timestamp >= expiry) ? 0 : type(uint256).max;
}
/** @dev See {IPrincipalToken-previewWithdraw}. */
function previewWithdraw(uint256 assets) external view override returns (uint256) {
uint256 ibts = IERC4626(ibt).previewWithdraw(assets);
return previewWithdrawIBT(ibts);
}
/** @dev See {IPrincipalToken-previewWithdrawIBT}. */
function previewWithdrawIBT(uint256 ibts) public view override whenNotPaused returns (uint256) {
return _convertIBTsToShares(ibts, true);
}
/** @dev See {IPrincipalToken-maxWithdraw}.
*/
function maxWithdraw(address owner) public view override returns (uint256) {
return paused() ? 0 : convertToUnderlying(_maxBurnable(owner));
}
/** @dev See {IPrincipalToken-maxWithdrawIBT}.
*/
function maxWithdrawIBT(address owner) public view override returns (uint256) {
return paused() ? 0 : _convertSharesToIBTs(_maxBurnable(owner), false);
}
/** @dev See {IPrincipalToken-previewRedeem}. */
function previewRedeem(uint256 shares) external view override returns (uint256) {
return IERC4626(ibt).previewRedeem(previewRedeemForIBT(shares));
}
/** @dev See {IPrincipalToken-previewRedeemForIBT}. */
function previewRedeemForIBT(
uint256 shares
) public view override whenNotPaused returns (uint256) {
return _convertSharesToIBTs(shares, false);
}
/** @dev See {IPrincipalToken-maxRedeem}. */
function maxRedeem(address owner) public view override returns (uint256) {
return paused() ? 0 : _maxBurnable(owner);
}
/** @dev See {IPrincipalToken-convertToPrincipal}. */
function convertToPrincipal(uint256 underlyingAmount) external view override returns (uint256) {
return _convertIBTsToShares(IERC4626(ibt).previewDeposit(underlyingAmount), false);
}
/** @dev See {IPrincipalToken-convertToUnderlying}. */
function convertToUnderlying(uint256 principalAmount) public view override returns (uint256) {
return IERC4626(ibt).previewRedeem(_convertSharesToIBTs(principalAmount, false));
}
/** @dev See {IPrincipalToken-totalAssets}. */
function totalAssets() public view override returns (uint256) {
address _ibt = ibt;
return IERC4626(_ibt).previewRedeem(IERC4626(_ibt).balanceOf(address(this)));
}
/** @dev See {IERC20Metadata-decimals} */
function decimals() public view override(IERC20Metadata, ERC20Upgradeable) returns (uint8) {
return ibtDecimals;
}
/** @dev See {IPrincipalToken-paused}. */
function paused() public view override(IPrincipalToken, PausableUpgradeable) returns (bool) {
return super.paused();
}
/** @dev See {IPrincipalToken-maturity}. */
function maturity() external view override returns (uint256) {
return expiry;
}
/** @dev See {IPrincipalToken-getDuration}. */
function getDuration() external view override returns (uint256) {
return duration;
}
/** @dev See {IPrincipalToken-underlying}. */
function underlying() external view override returns (address) {
return underlying_;
}
/** @dev See {IPrincipalToken-getIBT}. */
function getIBT() external view override returns (address) {
return ibt;
}
/** @dev See {IPrincipalToken-getYT}. */
function getYT() external view override returns (address) {
return yt;
}
/** @dev See {IPrincipalToken-getIBTRate}. */
function getIBTRate() external view override returns (uint256) {
(, uint256 _ibtRate) = _getPTandIBTRates(false);
return _ibtRate;
}
/** @dev See {IPrincipalToken-getPTRate}. */
function getPTRate() external view override returns (uint256) {
(uint256 _ptRate, ) = _getPTandIBTRates(false);
return _ptRate;
}
/** @dev See {IPrincipalToken-getIBTUnit}. */
function getIBTUnit() external view override returns (uint256) {
return ibtUnit;
}
/** @dev See {IPrincipalToken-getUnclaimedFeesInIBT}. */
function getUnclaimedFeesInIBT() external view override returns (uint256) {
return unclaimedFeesInIBT;
}
/** @dev See {IPrincipalToken-getTotalFeesInIBT}. */
function getTotalFeesInIBT() external view override returns (uint256) {
return totalFeesInIBT;
}
/** @dev See {IPrincipalToken-getCurrentYieldOfUserInIBT}. */
function getCurrentYieldOfUserInIBT(
address _user
) external view override returns (uint256 _yieldOfUserInIBT) {
uint256 _oldIBTRate = ibtRateOfUser[_user];
if (_oldIBTRate != 0) {
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(false);
uint256 _oldPTRate = ptRateOfUser[_user];
_yieldOfUserInIBT = _user.computeYield(
yieldOfUserInIBT[_user],
_oldIBTRate,
_ibtRate,
_oldPTRate,
_ptRate,
yt
);
_yieldOfUserInIBT = _yieldOfUserInIBT - _yieldOfUserInIBT._computeYieldFee(registry);
}
}
/** @dev See {IERC3156FlashLender-maxFlashLoan}. */
function maxFlashLoan(address _token) public view override returns (uint256) {
address _ibt = ibt;
if (_token != _ibt) {
return 0;
}
// Entire IBT balance of the contract can be borrowed
return IERC4626(_ibt).balanceOf(address(this));
}
/** @dev See {IERC3156FlashLender-flashFee}. */
function flashFee(address _token, uint256 _amount) public view override returns (uint256) {
if (_token != ibt) revert AddressError();
return _amount._computeFlashloanFee(registry);
}
/** @dev See {IPrincipalToken-tokenizationFee}. */
function getTokenizationFee() public view override returns (uint256) {
return IRegistry(registry).getTokenizationFee();
}
/* INTERNAL FUNCTIONS
*****************************************************************************************************************/
/**
* @dev See {ERC20Upgradeable-_update}.
* @dev The contract must not be paused.
*/
function _update(
address from,
address to,
uint256 value
) internal virtual override whenNotPaused {
super._update(from, to, value);
}
/**
* @dev Converts amount of PT shares to amount of IBT with current rates
* @param _shares amount of shares to convert to IBTs
* @param _roundUp true if result should be rounded up
* @return ibts resulting amount of IBT
*/
function _convertSharesToIBTs(
uint256 _shares,
bool _roundUp
) internal view returns (uint256 ibts) {
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(false);
if (_ibtRate == 0) {
revert RateError();
}
ibts = _shares.mulDiv(
_ptRate,
_ibtRate,
_roundUp ? Math.Rounding.Ceil : Math.Rounding.Floor
);
}
/**
* @dev Converts amount of IBT to amount of PT shares with current rates
* @param _ibts amount of IBT to convert to shares
* @param _roundUp true if result should be rounded up
* @return shares resulting amount of shares
*/
function _convertIBTsToShares(
uint256 _ibts,
bool _roundUp
) internal view returns (uint256 shares) {
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(false);
if (_ptRate == 0) {
revert RateError();
}
shares = _ibts.mulDiv(
_ibtRate,
_ptRate,
_roundUp ? Math.Rounding.Ceil : Math.Rounding.Floor
);
}
/**
* @dev Converts amount of IBT to amount of PT shares with current rates.
* This method also rounds the result of the new PTRate computation in case of negative rate
* @param ibts amount of IBT to convert to shares
* @return shares resulting amount of shares
*/
function _convertIBTsToSharesPreview(uint256 ibts) internal view returns (uint256 shares) {
// to round up the shares, the PT rate must round down
(uint256 _ptRate, uint256 _ibtRate) = _getPTandIBTRates(true);
if (_ptRate == 0) {
revert RateError();
}
shares = ibts.mulDiv(_ibtRate, _ptRate);
}
/**
* @dev Updates unclaimed fees and total fees upon tokenization and yield claiming
* @param _feesInIBT The fees in IBT currently being paid
*/
function _updateFees(uint256 _feesInIBT) internal {
unclaimedFeesInIBT = unclaimedFeesInIBT + _feesInIBT;
totalFeesInIBT = totalFeesInIBT + _feesInIBT;
}
/**
* @dev Deploys a yt for this pt, called while initializing.
* @param _name Name of the yt.
* @param _symbol Symbol of the yt.
* @return _yt The address of deployed yt.
*/
function _deployYT(string memory _name, string memory _symbol) internal returns (address _yt) {
address ytBeacon = IRegistry(registry).getYTBeacon();
if (ytBeacon == address(0)) {
revert BeaconNotSet();
}
_yt = address(
new BeaconProxy(
ytBeacon,
abi.encodeCall(IYieldToken(address(0)).initialize, (_name, _symbol, address(this)))
)
);
emit YTDeployed(_yt);
}
/**
* @dev Internal function for minting pt & yt to depositing user. Also updates yield before minting.
* @param _ibts The amount of IBT being deposited by the user
* @param _ptReceiver The address of the PT receiver
* @param _ytReceiver The address of the YT receiver
* @return shares The amount of shares being minted to the receiver
*/
function _depositIBT(
uint256 _ibts,
address _ptReceiver,
address _ytReceiver
) internal notExpired returns (uint256 shares) {
updateYield(_ytReceiver);
uint256 tokenizationFee = _ibts._computeTokenizationFee(address(this), registry);
_updateFees(tokenizationFee);
shares = _convertIBTsToShares(_ibts - tokenizationFee, false);
if (shares == 0) {
revert RateError();
}
_mint(_ptReceiver, shares);
emit Mint(msg.sender, _ptReceiver, shares);
IYieldToken(yt).mint(_ytReceiver, shares);
}
/**
* @dev Internal function for preparing redeem and burning PT:YT shares.
* @param _shares The amount of shares being redeemed
* @param _owner The address of shares' owner
*/
function _beforeRedeem(uint256 _shares, address _owner) internal {
if (_owner != msg.sender) {
_spendAllowance(_owner, msg.sender, _shares);
}
if (_shares > _maxBurnable(_owner)) {
revert InsufficientBalance();
}
if (block.timestamp >= expiry) {
if (ratesAtExpiryStored == RAE_NOT_STORED) {
storeRatesAtExpiry();
}
} else {
updateYield(_owner);
IYieldToken(yt).burnWithoutYieldUpdate(_owner, msg.sender, _shares);
}
_burn(_owner, _shares);
}
/**
* @dev Internal function for preparing withdraw.
* @param _assets The amount of assets to withdraw
* @param _owner The address of shares' owner
*/
function _beforeWithdraw(uint256 _assets, address _owner) internal {
if (block.timestamp >= expiry) {
if (ratesAtExpiryStored == RAE_NOT_STORED) {
storeRatesAtExpiry();
}
} else {
updateYield(_owner);
}
if (_assets > maxWithdraw(_owner)) {
revert InsufficientBalance();
}
}
/**
* @dev Internal function for burning PT and YT as part of withdrawal process.
* @param _ibts The amount of IBT that are withdrawn for burning shares
* @param _receiver The addresss of the receiver of the assets
* @param _owner The address of the owner of the shares
* @param _ptRate The PT rate (expressed in Ray) to be used
* @param _ibtRate The IBT rate (expressed in Ray) to be used
* @return shares The amount of burnt owner's shares
*/
function _burnSharesForWithdraw(
uint256 _ibts,
address _receiver,
address _owner,
uint256 _ptRate,
uint256 _ibtRate
) internal returns (uint256 shares) {
if (_ptRate == 0) {
revert RateError();
}
// convert ibts to shares using provided rates
shares = _ibts.mulDiv(_ibtRate, _ptRate, Math.Rounding.Ceil);
if (_owner != msg.sender) {
_spendAllowance(_owner, msg.sender, shares);
}
// burn owner's shares (YT and PT)
if (block.timestamp < expiry) {
IYieldToken(yt).burnWithoutYieldUpdate(_owner, msg.sender, shares);
}
_burn(_owner, shares);
emit Redeem(_owner, _receiver, shares);
}
/**
* @dev Internal function for handling the claims of caller's unclaimed yield
* @return yieldInIBT The unclaimed yield in IBT that is about to be claimed
*/
function _claimYield() internal returns (uint256 yieldInIBT) {
yieldInIBT = updateYield(msg.sender);
if (yieldInIBT == 0) {
return 0;
} else {
yieldOfUserInIBT[msg.sender] = 0;
uint256 yieldFeeInIBT = yieldInIBT._computeYieldFee(registry);
_updateFees(yieldFeeInIBT);
yieldInIBT = yieldInIBT - yieldFeeInIBT;
}
}
/**
* @dev Computes the maximum amount of burnable shares for a user
* @param _user The address of the user
* @return maxBurnable The maximum amount of burnable shares
*/
function _maxBurnable(address _user) internal view returns (uint256 maxBurnable) {
if (block.timestamp >= expiry) {
maxBurnable = balanceOf(_user);
} else {
uint256 ptBalance = balanceOf(_user);
uint256 ytBalance = IYieldToken(yt).balanceOf(_user);
maxBurnable = (ptBalance > ytBalance) ? ytBalance : ptBalance;
}
}
/**
* @dev Internal function for updating PT and IBT rates i.e. depegging PT if negative yield happened
* @return _ptRate The new PT rate
* @return _ibtRate The new IBT rate
*/
function _updatePTandIBTRates() internal returns (uint256 _ptRate, uint256 _ibtRate) {
uint256 _expiry = expiry;
if (block.timestamp >= _expiry) {
if (ratesAtExpiryStored == RAE_NOT_STORED) {
storeRatesAtExpiry();
}
}
(_ptRate, _ibtRate) = _getPTandIBTRates(false);
if (block.timestamp < _expiry) {
if (_ibtRate != ibtRate) {
ibtRate = _ibtRate;
}
if (_ptRate != ptRate) {
ptRate = _ptRate;
}
}
}
/**
* @dev View function to get current IBT and PT rate
* @param roundUpPTRate true if the ptRate resulting from mulDiv computation in case of negative rate should
* be rounded up
* @return _ptRate The new PT rate
* @return _ibtRate The new IBT rate
*/
function _getCurrentPTandIBTRates(
bool roundUpPTRate
) internal view returns (uint256 _ptRate, uint256 _ibtRate) {
address _ibt = ibt;
_ibtRate = IERC4626(_ibt).previewRedeem(ibtUnit).toRay(underlyingDecimals);
if (IERC4626(_ibt).totalAssets() == 0 && IERC4626(_ibt).totalSupply() != 0) {
_ibtRate = 0;
}
_ptRate = _ibtRate < ibtRate
? ptRate.mulDiv(
_ibtRate,
ibtRate,
roundUpPTRate ? Math.Rounding.Ceil : Math.Rounding.Floor
)
: ptRate;
}
/**
* @dev View function to get IBT and PT rates
* @param roundUpPTRate true if the PTRate result from mulDiv computation in case of negative rate should
* be rounded up
* @return _ptRate The new PT rate
* @return _ibtRate The new IBT rate
*/
function _getPTandIBTRates(
bool roundUpPTRate
) internal view returns (uint256 _ptRate, uint256 _ibtRate) {
if (ratesAtExpiryStored == RAE_NOT_STORED) {
(_ptRate, _ibtRate) = _getCurrentPTandIBTRates(roundUpPTRate);
} else {
(_ptRate, _ibtRate) = (ptRate, ibtRate);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 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.
*/
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.
*/
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.
*/
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 Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
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 silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AccessManaged.sol)
pragma solidity ^0.8.20;
import {IAuthority} from "@openzeppelin/contracts/access/manager/IAuthority.sol";
import {AuthorityUtils} from "@openzeppelin/contracts/access/manager/AuthorityUtils.sol";
import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev This contract module makes available a {restricted} modifier. Functions decorated with this modifier will be
* permissioned according to an "authority": a contract like {AccessManager} that follows the {IAuthority} interface,
* implementing a policy that allows certain callers to access certain functions.
*
* IMPORTANT: The `restricted` modifier should never be used on `internal` functions, judiciously used in `public`
* functions, and ideally only used in `external` functions. See {restricted}.
*/
abstract contract AccessManagedUpgradeable is Initializable, ContextUpgradeable, IAccessManaged {
/// @custom:storage-location erc7201:openzeppelin.storage.AccessManaged
struct AccessManagedStorage {
address _authority;
bool _consumingSchedule;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessManaged")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant AccessManagedStorageLocation = 0xf3177357ab46d8af007ab3fdb9af81da189e1068fefdc0073dca88a2cab40a00;
function _getAccessManagedStorage() private pure returns (AccessManagedStorage storage $) {
assembly {
$.slot := AccessManagedStorageLocation
}
}
/**
* @dev Initializes the contract connected to an initial authority.
*/
function __AccessManaged_init(address initialAuthority) internal onlyInitializing {
__AccessManaged_init_unchained(initialAuthority);
}
function __AccessManaged_init_unchained(address initialAuthority) internal onlyInitializing {
_setAuthority(initialAuthority);
}
/**
* @dev Restricts access to a function as defined by the connected Authority for this contract and the
* caller and selector of the function that entered the contract.
*
* [IMPORTANT]
* ====
* In general, this modifier should only be used on `external` functions. It is okay to use it on `public`
* functions that are used as external entry points and are not called internally. Unless you know what you're
* doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security
* implications! This is because the permissions are determined by the function that entered the contract, i.e. the
* function at the bottom of the call stack, and not the function where the modifier is visible in the source code.
* ====
*
* [WARNING]
* ====
* Avoid adding this modifier to the https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]
* function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These
* functions are the only execution paths where a function selector cannot be unambiguosly determined from the calldata
* since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()` function
* if no calldata is provided. (See {_checkCanCall}).
*
* The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.
* ====
*/
modifier restricted() {
_checkCanCall(_msgSender(), _msgData());
_;
}
/// @inheritdoc IAccessManaged
function authority() public view virtual returns (address) {
AccessManagedStorage storage $ = _getAccessManagedStorage();
return $._authority;
}
/// @inheritdoc IAccessManaged
function setAuthority(address newAuthority) public virtual {
address caller = _msgSender();
if (caller != authority()) {
revert AccessManagedUnauthorized(caller);
}
if (newAuthority.code.length == 0) {
revert AccessManagedInvalidAuthority(newAuthority);
}
_setAuthority(newAuthority);
}
/// @inheritdoc IAccessManaged
function isConsumingScheduledOp() public view returns (bytes4) {
AccessManagedStorage storage $ = _getAccessManagedStorage();
return $._consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);
}
/**
* @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the
* permissions set by the current authority.
*/
function _setAuthority(address newAuthority) internal virtual {
AccessManagedStorage storage $ = _getAccessManagedStorage();
$._authority = newAuthority;
emit AuthorityUpdated(newAuthority);
}
/**
* @dev Reverts if the caller is not allowed to call the function identified by a selector. Panics if the calldata
* is less than 4 bytes long.
*/
function _checkCanCall(address caller, bytes calldata data) internal virtual {
AccessManagedStorage storage $ = _getAccessManagedStorage();
(bool immediate, uint32 delay) = AuthorityUtils.canCallWithDelay(
authority(),
caller,
address(this),
bytes4(data[0:4])
);
if (!immediate) {
if (delay > 0) {
$._consumingSchedule = true;
IAccessManager(authority()).consumeScheduledOp(caller, data);
$._consumingSchedule = false;
} else {
revert AccessManagedUnauthorized(caller);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Pausable
struct PausableStorage {
bool _paused;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
/**
* @dev The operation failed because the contract is paused.
*/
error EnforcedPause();
/**
* @dev The operation failed because the contract is not paused.
*/
error ExpectedPause();
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
/// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
struct ReentrancyGuardStorage {
uint256 _status;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
assembly {
$.slot := ReentrancyGuardStorageLocation
}
}
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// On the first call to nonReentrant, _status will be NOT_ENTERED
if ($._status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
$._status = ENTERED;
}
function _nonReentrantAfter() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
$._status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
return $._status == ENTERED;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
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 overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
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 division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds 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.
return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0 = 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^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 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^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @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;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @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;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Permit.sol)
pragma solidity ^0.8.20;
import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712Upgradeable} from "../../../utils/cryptography/EIP712Upgradeable.sol";
import {NoncesUpgradeable} from "../../../utils/NoncesUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20Permit, EIP712Upgradeable, NoncesUpgradeable {
bytes32 private constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/**
* @dev Permit deadline has expired.
*/
error ERC2612ExpiredSignature(uint256 deadline);
/**
* @dev Mismatched signature.
*/
error ERC2612InvalidSigner(address signer, address owner);
/**
* @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
*
* It's a good idea to use the same `name` that is defined as the ERC20 token name.
*/
function __ERC20Permit_init(string memory name) internal onlyInitializing {
__EIP712_init_unchained(name, "1");
}
function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}
/**
* @inheritdoc IERC20Permit
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (block.timestamp > deadline) {
revert ERC2612ExpiredSignature(deadline);
}
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
if (signer != owner) {
revert ERC2612InvalidSigner(signer, owner);
}
_approve(owner, spender, value);
}
/**
* @inheritdoc IERC20Permit
*/
function nonces(address owner) public view virtual override(IERC20Permit, NoncesUpgradeable) returns (uint256) {
return super.nonces(owner);
}
/**
* @inheritdoc IERC20Permit
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
return _domainSeparatorV4();
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/BeaconProxy.sol)
pragma solidity ^0.8.20;
import {IBeacon} from "./IBeacon.sol";
import {Proxy} from "../Proxy.sol";
import {ERC1967Utils} from "../ERC1967/ERC1967Utils.sol";
/**
* @dev This contract implements a proxy that gets the implementation address for each call from an {UpgradeableBeacon}.
*
* The beacon address can only be set once during construction, and cannot be changed afterwards. It is stored in an
* immutable variable to avoid unnecessary storage reads, and also in the beacon storage slot specified by
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] so that it can be accessed externally.
*
* CAUTION: Since the beacon address can never be changed, you must ensure that you either control the beacon, or trust
* the beacon to not upgrade the implementation maliciously.
*
* IMPORTANT: Do not use the implementation logic to modify the beacon storage slot. Doing so would leave the proxy in
* an inconsistent state where the beacon storage slot does not match the beacon address.
*/
contract BeaconProxy is Proxy {
// An immutable address for the beacon to avoid unnecessary SLOADs before each delegate call.
address private immutable _beacon;
/**
* @dev Initializes the proxy with `beacon`.
*
* If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This
* will typically be an encoded function call, and allows initializing the storage of the proxy like a Solidity
* constructor.
*
* Requirements:
*
* - `beacon` must be a contract with the interface {IBeacon}.
* - If `data` is empty, `msg.value` must be zero.
*/
constructor(address beacon, bytes memory data) payable {
ERC1967Utils.upgradeBeaconToAndCall(beacon, data);
_beacon = beacon;
}
/**
* @dev Returns the current implementation address of the associated beacon.
*/
function _implementation() internal view virtual override returns (address) {
return IBeacon(_getBeacon()).implementation();
}
/**
* @dev Returns the beacon.
*/
function _getBeacon() internal view virtual returns (address) {
return _beacon;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC3156FlashBorrower.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC3156 FlashBorrower, as defined in
* https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
*/
interface IERC3156FlashBorrower {
/**
* @dev Receive a flash loan.
* @param initiator The initiator of the loan.
* @param token The loan currency.
* @param amount The amount of tokens lent.
* @param fee The additional amount of tokens to repay.
* @param data Arbitrary data structure, intended to contain user-defined parameters.
* @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
*/
function onFlashLoan(
address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data
) external returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4626.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";
/**
* @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
* https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
*/
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.20;
import "../interfaces/IYieldToken.sol";
import "../interfaces/IPrincipalToken.sol";
import "../interfaces/IRegistry.sol";
import "openzeppelin-contracts/interfaces/IERC4626.sol";
import "openzeppelin-math/Math.sol";
import "../libraries/RayMath.sol";
/**
* @title PrincipalTokenUtil library
* @author Spectra Finance
* @notice Provides miscellaneous utils for computations in PrincipalToken.sol.
*/
library PrincipalTokenUtil {
using Math for uint256;
using RayMath for uint256;
error AssetDoesNotImplementMetadata();
uint256 private constant SAFETY_BOUND = 100; // used to favour the protocol in case of approximations
uint256 private constant FEE_DIVISOR = 1e18; // equivalent to 100% fees
uint256 private constant MIN_LENGTH = 32; // minimum length the encoded decimals should have
/**
* @dev Computes the yield for a specified user since the last update.
* @param _user The address for which the yield is to be calculated.
* @param _currentYieldInIBT the current yield of user in IBT
* @param _oldIBTRate the previous deposit IBT rate of user (in Ray)
* @param _ibtRate the current IBT rate (in Ray)
* @param _oldPTRate the previous deposit pt rate of user (in Ray)
* @param _ptRate the current PT rate (in Ray)
* @param _yt the address of YT
* @return updatedYieldInIBT the calculated yield in IBT of user
*/
function computeYield(
address _user,
uint256 _currentYieldInIBT,
uint256 _oldIBTRate,
uint256 _ibtRate,
uint256 _oldPTRate,
uint256 _ptRate,
address _yt
) external view returns (uint256 updatedYieldInIBT) {
if (_oldPTRate == _ptRate && _ibtRate == _oldIBTRate) {
return _currentYieldInIBT;
}
uint8 ytDecimals = IERC20Metadata(_yt).decimals();
uint256 newYieldInIBTRay;
uint256 userYTBalanceInRay = IYieldToken(_yt).actualBalanceOf(_user).toRay(ytDecimals);
// ibtOfPT is the yield generated by each PT corresponding to the YTs that the user holds
uint256 ibtOfPTInRay = userYTBalanceInRay.mulDiv(_oldPTRate, _oldIBTRate);
if (_oldPTRate == _ptRate && _ibtRate > _oldIBTRate) {
// only positive yield happened
newYieldInIBTRay = ibtOfPTInRay.mulDiv(_ibtRate - _oldIBTRate, _ibtRate);
} else {
if (_oldPTRate > _ptRate) {
// PT depeg happened
uint256 yieldInAssetRay;
uint256 actualNegativeYieldInAssetRay = _convertToAssetsWithRate(
userYTBalanceInRay,
_oldPTRate - _ptRate,
Math.Rounding.Floor
);
if (_ibtRate >= _oldIBTRate) {
// both negative and positive yield happened, more positive
yieldInAssetRay =
actualNegativeYieldInAssetRay +
_convertToAssetsWithRate(
ibtOfPTInRay,
_ibtRate - _oldIBTRate,
Math.Rounding.Floor
);
} else {
// either both negative and positive yield happened, more negative
// or only negative yield happened
uint256 expectedNegativeYieldInAssetRay = _convertToAssetsWithRate(
ibtOfPTInRay,
(_oldIBTRate - _ibtRate),
Math.Rounding.Ceil
);
yieldInAssetRay = expectedNegativeYieldInAssetRay >
actualNegativeYieldInAssetRay
? 0
: actualNegativeYieldInAssetRay - expectedNegativeYieldInAssetRay;
yieldInAssetRay = yieldInAssetRay.fromRay(
IERC20Metadata(IPrincipalToken(IYieldToken(_yt).getPT()).underlying())
.decimals()
) < SAFETY_BOUND
? 0
: yieldInAssetRay;
}
newYieldInIBTRay = _convertToSharesWithRate(
yieldInAssetRay,
_ibtRate,
Math.Rounding.Floor
);
} else {
// PT rate increased or did not depeg on IBT rate decrease
revert IPrincipalToken.RateError();
}
}
updatedYieldInIBT = _currentYieldInIBT + newYieldInIBTRay.fromRay(ytDecimals);
}
/**
* @dev Attempts to fetch the token decimals. Reverts if the attempt failed in some way.
* @param _token The token address
* @return The ERC20 token decimals
*/
function tryGetTokenDecimals(address _token) external view returns (uint8) {
(bool success, bytes memory encodedDecimals) = _token.staticcall(
abi.encodeCall(IERC20Metadata.decimals, ())
);
if (success && encodedDecimals.length >= MIN_LENGTH) {
uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
if (returnedDecimals <= type(uint8).max) {
return uint8(returnedDecimals);
}
}
revert AssetDoesNotImplementMetadata();
}
/**
* @dev Convert underlying amount to share, with the given rate
* @param _assetsInRay The amount of underlying (in Ray)
* @param _rate The share price in underlying (in Ray)
* @param _rounding The rounding type to be used in the computation
* @return sharesInRay The amount of share (in Ray)
*/
function _convertToSharesWithRate(
uint256 _assetsInRay,
uint256 _rate,
Math.Rounding _rounding
) internal pure returns (uint256 sharesInRay) {
if (_rate == 0) {
revert IPrincipalToken.RateError();
}
sharesInRay = _assetsInRay.mulDiv(RayMath.RAY_UNIT, _rate, _rounding);
}
/**
* @dev Convert share amount to underlying, with the given rate
* @param _sharesInRay The amount of share (in Ray)
* @param _rate The share price in underlying (in Ray)
* @param _rounding The rounding type to be used in the computation
* @return assetsInRay The amount of underlying (in Ray)
*/
function _convertToAssetsWithRate(
uint256 _sharesInRay,
uint256 _rate,
Math.Rounding _rounding
) internal pure returns (uint256 assetsInRay) {
assetsInRay = _sharesInRay.mulDiv(_rate, RayMath.RAY_UNIT, _rounding);
}
/**
* @dev Compute tokenization fee for a given amount
* @param _amount The amount to tokenize
* @param _pt The address of the pt on which the fee is being paid
* @param _registry The address of registry that stores fee rate
* @return returns The calculated tokenization fee
*/
function _computeTokenizationFee(
uint256 _amount,
address _pt,
address _registry
) internal view returns (uint256) {
return
_amount
.mulDiv(IRegistry(_registry).getTokenizationFee(), FEE_DIVISOR, Math.Rounding.Ceil)
.mulDiv(
FEE_DIVISOR - IRegistry(_registry).getFeeReduction(_pt, msg.sender),
FEE_DIVISOR,
Math.Rounding.Ceil
);
}
/**
* @dev Compute yield fee for a given amount
* @param _amount the amount of yield
* @param _registry the address of registry that stores fee rate
* @return returns the calculated yield fee
*/
function _computeYieldFee(uint256 _amount, address _registry) internal view returns (uint256) {
return _amount.mulDiv(IRegistry(_registry).getYieldFee(), FEE_DIVISOR, Math.Rounding.Ceil);
}
/**
* @dev Compute flashloan fee for a given amount
* @param _amount the amount to flashloan
* @param _registry the address of registry that stores fee rate
* @return returns the calculated flashloan fee
*/
function _computeFlashloanFee(
uint256 _amount,
address _registry
) internal view returns (uint256) {
return
_amount.mulDiv(
IRegistry(_registry).getPTFlashLoanFee(),
FEE_DIVISOR,
Math.Rounding.Ceil
);
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.20;
/**
* @title NamingUtil library
* @author Spectra Finance
* @notice Provides miscellaneous utils for token naming.
*/
library NamingUtil {
function genYTSymbol(
string memory _ibtSymbol,
uint256 _dateOfExpiry
) internal pure returns (string memory) {
string memory date = uintToString(_dateOfExpiry);
string memory symbol = concatenate(_ibtSymbol, "-");
return concatenate(concatenate("YT-", symbol), date);
}
function genYTName(
string memory _ibtSymbol,
uint256 _dateOfExpiry
) internal pure returns (string memory) {
string memory date = uintToString(_dateOfExpiry);
string memory symbol = concatenate(_ibtSymbol, "-");
return concatenate(concatenate("Yield Token: ", symbol), date);
}
function genPTSymbol(
string memory _ibtSymbol,
uint256 _dateOfExpiry
) internal pure returns (string memory) {
string memory date = uintToString(_dateOfExpiry);
string memory symbol = concatenate(_ibtSymbol, "-");
return concatenate(concatenate("PT-", symbol), date);
}
function genPTName(
string memory _ibtSymbol,
uint256 _dateOfExpiry
) internal pure returns (string memory) {
string memory date = uintToString(_dateOfExpiry);
string memory symbol = concatenate(_ibtSymbol, "-");
return concatenate(concatenate("Principal Token: ", symbol), date);
}
function concatenate(string memory a, string memory b) internal pure returns (string memory) {
return string(abi.encodePacked(a, b));
}
function uintToString(uint256 _i) internal pure returns (string memory) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.20;
/**
* @title RayMath library
* @author Spectra Finance
* @notice Provides conversions for/to any decimal tokens to/from ray.
* @dev Conversions from Ray are rounded down.
*/
library RayMath {
/// @dev 27 decimal unit
uint256 public constant RAY_UNIT = 1e27;
uint256 public constant RAY_DECIMALS = 27;
/**
* @dev Converts a value from Ray (27-decimal precision) to a representation with a specified number of decimals.
* @param _a The amount in Ray to be converted. Ray is a fixed-point representation with 27 decimals.
* @param _decimals The target decimal precision for the converted amount.
* @return b The amount converted from Ray to the specified decimal precision.
*/
function fromRay(uint256 _a, uint256 _decimals) internal pure returns (uint256 b) {
uint256 decimals_ratio = 10 ** (RAY_DECIMALS - _decimals);
assembly {
b := div(_a, decimals_ratio)
}
}
/**
* @dev Converts a value from Ray (27-decimal precision) to a representation with a specified number of decimals.
* @param _a The amount in Ray to be converted. Ray is a fixed-point representation with 27 decimals.
* @param _decimals The target decimal precision for the converted amount.
* @param _roundUp If true, the function rounds up the result to the nearest integer value.
* If false, it truncates (rounds down) to the nearest integer.
* @return b The amount converted from Ray to the specified decimal precision, rounded as specified.
*/
function fromRay(
uint256 _a,
uint256 _decimals,
bool _roundUp
) internal pure returns (uint256 b) {
uint256 decimals_ratio = 10 ** (RAY_DECIMALS - _decimals);
assembly {
b := div(_a, decimals_ratio)
if and(eq(_roundUp, 1), gt(mod(_a, decimals_ratio), 0)) {
b := add(b, 1)
}
}
}
/**
* @dev Converts a value with a specified number of decimals to Ray (27-decimal precision).
* @param _a The amount to be converted, specified in a decimal format.
* @param _decimals The number of decimals in the representation of 'a'.
* @return b The amount in Ray, converted from the specified decimal precision.
* Ensures that the conversion maintains the value's integrity (no overflow).
*/
function toRay(uint256 _a, uint256 _decimals) internal pure returns (uint256 b) {
uint256 decimals_ratio = 10 ** (RAY_DECIMALS - _decimals);
// to avoid overflow, b/decimals_ratio == _a
assembly {
b := mul(_a, decimals_ratio)
if iszero(eq(div(b, decimals_ratio), _a)) {
revert(0, 0)
}
}
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.20;
interface IRegistry {
/* Errors
*****************************************************************************************************************/
error FeeGreaterThanMaxValue();
error PTListUpdateFailed();
error ReductionTooBig();
error AddressError();
/* GETTERS
*****************************************************************************************************************/
/**
* @notice Getter for the factory address
* @return The address of token factory
*/
function getFactory() external view returns (address);
/**
* @notice Get the address of the router
* @return The address of the router
*/
function getRouter() external view returns (address);
/**
* @notice Get the address of the routerUtil
* @return The address of the routerUtil
*/
function getRouterUtil() external view returns (address);
/**
* @notice Get the address of the pt beacon
* @return The address of PT beacon
*/
function getPTBeacon() external view returns (address);
/**
* @notice Get the address of the yt beacon
* @return The address of yt beacon
*/
function getYTBeacon() external view returns (address);
/**
* @notice Get the value of tokenization fee
* @return The value of tokenization fee
*/
function getTokenizationFee() external view returns (uint256);
/**
* @notice Get the value of yield fee
* @return The value of yield fee
*/
function getYieldFee() external view returns (uint256);
/**
* @notice Get the value of PT flash loan fee
* @return The value of PT flash loan fee
*/
function getPTFlashLoanFee() external view returns (uint256);
/**
* @notice Get the address of the fee collector
* @return The address of fee collector
*/
function getFeeCollector() external view returns (address);
/**
* @notice Get the fee reduction of the given user for the given pt
* @param _pt The address of the pt
* @param _user The address of the user
* @return The fee reduction of the given user for the given pt
*/
function getFeeReduction(address _pt, address _user) external view returns (uint256);
/**
* @notice Getter to check if a pt is registered
* @param _pt the address of the pt to check the registration of
* @return true if it is, false otherwise
*/
function isRegisteredPT(address _pt) external view returns (bool);
/**
* @notice Getter for the pt registered at an index
* @param _index the index of the pt to return
* @return The address of the corresponding pt
*/
function getPTAt(uint256 _index) external view returns (address);
/**
* @notice Getter for number of PT registered
* @return The number of PT registered
*/
function pTCount() external view returns (uint256);
/* SETTERS
*****************************************************************************************************************/
/**
* @notice Setter for the tokens factory address
* @param _newFactory The address of the new factory
*/
function setFactory(address _newFactory) external;
/**
* @notice set the router
* @param _router The address of the router
*/
function setRouter(address _router) external;
/**
* @notice set the routerUtil
* @param _routerUtil The address of the routerUtil
*/
function setRouterUtil(address _routerUtil) external;
/**
* @notice set the tokenization fee
* @param _tokenizationFee The value of tokenization fee
*/
function setTokenizationFee(uint256 _tokenizationFee) external;
/**
* @notice set the yield fee
* @param _yieldFee The value of yield fee
*/
function setYieldFee(uint256 _yieldFee) external;
/**
* @notice set the PT flash loan fee
* @param _ptFlashLoanFee The value of PT flash loan fee
*/
function setPTFlashLoanFee(uint256 _ptFlashLoanFee) external;
/**
* @notice set the fee collector
* @param _feeCollector The address of fee collector
*/
function setFeeCollector(address _feeCollector) external;
/**
* @notice Set the fee reduction of the given pt for the given user
* @param _pt The address of the pt
* @param _user The address of the user
* @param _reduction The fee reduction
*/
function reduceFee(address _pt, address _user, uint256 _reduction) external;
/**
* @notice set the pt beacon
* @param _ptBeacon The address of PT beacon
*/
function setPTBeacon(address _ptBeacon) external;
/**
* @notice set the yt beacon
* @param _ytBeacon The address of yt beacon
*/
function setYTBeacon(address _ytBeacon) external;
/**
* @notice Add a pt to the registry
* @param _pt The address of the pt to add to the registry
*/
function addPT(address _pt) external;
/**
* @notice Remove a pt from the registry
* @param _pt The address of the pt to remove from the registry
*/
function removePT(address _pt) external;
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.20;
import "openzeppelin-contracts/interfaces/IERC20.sol";
import "openzeppelin-contracts/interfaces/IERC20Metadata.sol";
import "openzeppelin-contracts/interfaces/IERC3156FlashLender.sol";
interface IPrincipalToken is IERC20, IERC20Metadata, IERC3156FlashLender {
/* ERRORS
*****************************************************************************************************************/
error InvalidDecimals();
error BeaconNotSet();
error PTExpired();
error PTNotExpired();
error RateError();
error AddressError();
error UnauthorizedCaller();
error RatesAtExpiryAlreadyStored();
error ERC5143SlippageProtectionFailed();
error InsufficientBalance();
error FlashLoanExceedsMaxAmount();
error FlashLoanCallbackFailed();
error NoRewardsProxy();
error ClaimRewardsFailed();
/* Functions
*****************************************************************************************************************/
function initialize(address _ibt, uint256 _duration, address initialAuthority) external;
/**
* @notice Toggle Pause
* @dev Should only be called in extraordinary situations by the admin of the contract
*/
function pause() external;
/**
* @notice Toggle UnPause
* @dev Should only be called in extraordinary situations by the admin of the contract
*/
function unPause() external;
/**
* @notice Deposits amount of assets in the PT vault
* @param assets The amount of assets being deposited
* @param receiver The receiver address of the shares
* @return shares The amount of shares minted (same amount for PT & yt)
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @notice Deposits amount of assets in the PT vault
* @param assets The amount of assets being deposited
* @param ptReceiver The receiver address of the PTs
* @param ytReceiver the receiver address of the YTs
* @return shares The amount of shares minted (same amount for PT & yt)
*/
function deposit(
uint256 assets,
address ptReceiver,
address ytReceiver
) external returns (uint256 shares);
/**
* @notice Deposits amount of assets with a lower bound on shares received
* @param assets The amount of assets being deposited
* @param ptReceiver The receiver address of the PTs
* @param ytReceiver The receiver address of the YTs
* @param minShares The minimum allowed shares from this deposit
* @return shares The amount of shares actually minted to the receiver
*/
function deposit(
uint256 assets,
address ptReceiver,
address ytReceiver,
uint256 minShares
) external returns (uint256 shares);
/**
* @notice Same as normal deposit but with IBTs
* @param ibts The amount of IBT being deposited
* @param receiver The receiver address of the shares
* @return shares The amount of shares minted to the receiver
*/
function depositIBT(uint256 ibts, address receiver) external returns (uint256 shares);
/**
* @notice Same as normal deposit but with IBTs
* @param ibts The amount of IBT being deposited
* @param ptReceiver The receiver address of the PTs
* @param ytReceiver the receiver address of the YTs
* @return shares The amount of shares minted to the receiver
*/
function depositIBT(
uint256 ibts,
address ptReceiver,
address ytReceiver
) external returns (uint256 shares);
/**
* @notice Same as normal deposit but with IBTs
* @param ibts The amount of IBT being deposited
* @param ptReceiver The receiver address of the PTs
* @param ytReceiver The receiver address of the YTs
* @param minShares The minimum allowed shares from this deposit
* @return shares The amount of shares minted to the receiver
*/
function depositIBT(
uint256 ibts,
address ptReceiver,
address ytReceiver,
uint256 minShares
) external returns (uint256 shares);
/**
* @notice Burns owner's shares (PTs and YTs before expiry, PTs after expiry)
* and sends assets to receiver
* @param shares The amount of shares to burn
* @param receiver The address that will receive the assets
* @param owner The owner of the shares
* @return assets The actual amount of assets received for burning the shares
*/
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets);
/**
* @notice Burns owner's shares (PTs and YTs before expiry, PTs after expiry)
* and sends assets to receiver
* @param shares The amount of shares to burn
* @param receiver The address that will receive the assets
* @param owner The owner of the shares
* @param minAssets The minimum assets that should be returned to user
* @return assets The actual amount of assets received for burning the shares
*/
function redeem(
uint256 shares,
address receiver,
address owner,
uint256 minAssets
) external returns (uint256 assets);
/**
* @notice Burns owner's shares (PTs and YTs before expiry, PTs after expiry)
* and sends IBTs to receiver
* @param shares The amount of shares to burn
* @param receiver The address that will receive the IBTs
* @param owner The owner of the shares
* @return ibts The actual amount of IBT received for burning the shares
*/
function redeemForIBT(
uint256 shares,
address receiver,
address owner
) external returns (uint256 ibts);
/**
* @notice Burns owner's shares (PTs and YTs before expiry, PTs after expiry)
* and sends IBTs to receiver
* @param shares The amount of shares to burn
* @param receiver The address that will receive the IBTs
* @param owner The owner of the shares
* @param minIbts The minimum IBTs that should be returned to user
* @return ibts The actual amount of IBT received for burning the shares
*/
function redeemForIBT(
uint256 shares,
address receiver,
address owner,
uint256 minIbts
) external returns (uint256 ibts);
/**
* @notice Burns owner's shares (before expiry : PTs and YTs) and sends assets to receiver
* @param assets The amount of assets to be received
* @param receiver The address that will receive the assets
* @param owner The owner of the shares (PTs and YTs)
* @return shares The actual amount of shares burnt for receiving the assets
*/
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares);
/**
* @notice Burns owner's shares (before expiry : PTs and YTs) and sends assets to receiver
* @param assets The amount of assets to be received
* @param receiver The address that will receive the assets
* @param owner The owner of the shares (PTs and YTs)
* @param maxShares The maximum shares allowed to be burnt
* @return shares The actual amount of shares burnt for receiving the assets
*/
function withdraw(
uint256 assets,
address receiver,
address owner,
uint256 maxShares
) external returns (uint256 shares);
/**
* @notice Burns owner's shares (before expiry : PTs and YTs) and sends IBTs to receiver
* @param ibts The amount of IBT to be received
* @param receiver The address that will receive the IBTs
* @param owner The owner of the shares (PTs and YTs)
* @return shares The actual amount of shares burnt for receiving the IBTs
*/
function withdrawIBT(
uint256 ibts,
address receiver,
address owner
) external returns (uint256 shares);
/**
* @notice Burns owner's shares (before expiry : PTs and YTs) and sends IBTs to receiver
* @param ibts The amount of IBT to be received
* @param receiver The address that will receive the IBTs
* @param owner The owner of the shares (PTs and YTs)
* @param maxShares The maximum shares allowed to be burnt
* @return shares The actual amount of shares burnt for receiving the IBTs
*/
function withdrawIBT(
uint256 ibts,
address receiver,
address owner,
uint256 maxShares
) external returns (uint256 shares);
/**
* @notice Updates _user's yield since last update
* @param _user The user whose yield will be updated
* @return updatedUserYieldInIBT The unclaimed yield of the user in IBT (not just the updated yield)
*/
function updateYield(address _user) external returns (uint256 updatedUserYieldInIBT);
/**
* @notice Claims caller's unclaimed yield in asset
* @param _receiver The receiver of yield
* @param _minAssets The minimum amount of assets that should be received
* @return yieldInAsset The amount of yield claimed in asset
*/
function claimYield(
address _receiver,
uint256 _minAssets
) external returns (uint256 yieldInAsset);
/**
* @notice Claims caller's unclaimed yield in IBT
* @param _receiver The receiver of yield
* @param _minIBT The minimum amount of IBT that should be received
* @return yieldInIBT The amount of yield claimed in IBT
*/
function claimYieldInIBT(
address _receiver,
uint256 _minIBT
) external returns (uint256 yieldInIBT);
/**
* @notice Claims the collected ibt fees and redeems them to the fee collector
* @param _minAssets The minimum amount of assets that should be received
* @return assets The amount of assets sent to the fee collector
*/
function claimFees(uint256 _minAssets) external returns (uint256 assets);
/**
* @notice Updates yield of both sender and receiver of YTs
* @param _from the sender of YTs
* @param _to the receiver of YTs
*/
function beforeYtTransfer(address _from, address _to) external;
/**
* Call the claimRewards function of the rewards contract
* @param data The optional data to be passed to the rewards contract
*/
function claimRewards(bytes memory data) external;
/* SETTERS
*****************************************************************************************************************/
/**
* @notice Stores PT and IBT rates at expiry. Ideally, it should be called the day of expiry
*/
function storeRatesAtExpiry() external;
/** Set a new Rewards Proxy
* @param _rewardsProxy The address of the new reward proxy
*/
function setRewardsProxy(address _rewardsProxy) external;
/* GETTERS
*****************************************************************************************************************/
/**
* @notice Returns the amount of shares minted for the theorical deposited amount of assets
* @param assets The amount of assets deposited
* @return The amount of shares minted
*/
function previewDeposit(uint256 assets) external view returns (uint256);
/**
* @notice Returns the amount of shares minted for the theorical deposited amount of IBT
* @param ibts The amount of IBT deposited
* @return The amount of shares minted
*/
function previewDepositIBT(uint256 ibts) external view returns (uint256);
/**
* @notice Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
* @param receiver The receiver of the shares
* @return The maximum amount of assets that can be deposited
*/
function maxDeposit(address receiver) external view returns (uint256);
/**
* @notice Returns the theorical amount of shares that need to be burnt to receive assets of underlying
* @param assets The amount of assets to receive
* @return The amount of shares burnt
*/
function previewWithdraw(uint256 assets) external view returns (uint256);
/**
* @notice Returns the theorical amount of shares that need to be burnt to receive amount of IBT
* @param ibts The amount of IBT to receive
* @return The amount of shares burnt
*/
function previewWithdrawIBT(uint256 ibts) external view returns (uint256);
/**
* @notice Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
* @param owner The owner of the Vault shares
* @return The maximum amount of assets that can be withdrawn
*/
function maxWithdraw(address owner) external view returns (uint256);
/**
* @notice Returns the maximum amount of the IBT that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
* @param owner The owner of the Vault shares
* @return The maximum amount of IBT that can be withdrawn
*/
function maxWithdrawIBT(address owner) external view returns (uint256);
/**
* @notice Returns the amount of assets received for the theorical amount of burnt shares
* @param shares The amount of shares to burn
* @return The amount of assets received
*/
function previewRedeem(uint256 shares) external view returns (uint256);
/**
* @notice Returns the amount of IBT received for the theorical amount of burnt shares
* @param shares The amount of shares to burn
* @return The amount of IBT received
*/
function previewRedeemForIBT(uint256 shares) external view returns (uint256);
/**
* @notice Returns the maximum amount of Vault shares that can be redeemed by the owner
* @notice This function behaves differently before and after expiry. Before expiry an equal amount of PT and YT
* needs to be burnt, while after expiry only PTs are burnt.
* @param owner The owner of the shares
* @return The maximum amount of shares that can be redeemed
*/
function maxRedeem(address owner) external view returns (uint256);
/**
* Returns the total amount of the underlying asset that is owned by the Vault in the form of IBT.
*/
function totalAssets() external view returns (uint256);
/**
* @notice Converts an underlying amount in principal. Equivalent to ERC-4626's convertToShares method.
* @param underlyingAmount The amount of underlying (or assets) to convert
* @return The resulting amount of principal (or shares)
*/
function convertToPrincipal(uint256 underlyingAmount) external view returns (uint256);
/**
* @notice Converts a principal amount in underlying. Equivalent to ERC-4626's convertToAssets method.
* @param principalAmount The amount of principal (or shares) to convert
* @return The resulting amount of underlying (or assets)
*/
function convertToUnderlying(uint256 principalAmount) external view returns (uint256);
/**
* @notice Returns whether or not the contract is paused.
* @return true if the contract is paused, and false otherwise
*/
function paused() external view returns (bool);
/**
* @notice Returns the unix timestamp (uint256) at which the PT contract expires
* @return The unix timestamp (uint256) when PTs become redeemable
*/
function maturity() external view returns (uint256);
/**
* @notice Returns the duration of the PT contract
* @return The duration (in s) to expiry/maturity of the PT contract
*/
function getDuration() external view returns (uint256);
/**
* @notice Returns the address of the underlying token (or asset). Equivalent to ERC-4626's asset method.
* @return The address of the underlying token (or asset)
*/
function underlying() external view returns (address);
/**
* @notice Returns the IBT address of the PT contract
* @return ibt The address of the IBT
*/
function getIBT() external view returns (address ibt);
/**
* @notice Returns the yt address of the PT contract
* @return yt The address of the yt
*/
function getYT() external view returns (address yt);
/**
* @notice Returns the current ibtRate
* @return The current ibtRate
*/
function getIBTRate() external view returns (uint256);
/**
* @notice Returns the current ptRate
* @return The current ptRate
*/
function getPTRate() external view returns (uint256);
/**
* @notice Returns 1 unit of IBT
* @return The IBT unit
*/
function getIBTUnit() external view returns (uint256);
/**
* @notice Get the unclaimed fees in IBT
* @return The unclaimed fees in IBT
*/
function getUnclaimedFeesInIBT() external view returns (uint256);
/**
* @notice Get the total collected fees in IBT (claimed and unclaimed)
* @return The total fees in IBT
*/
function getTotalFeesInIBT() external view returns (uint256);
/**
* @notice Get the tokenization fee of the PT
* @return The tokenization fee
*/
function getTokenizationFee() external view returns (uint256);
/**
* @notice Get the current IBT yield of the user
* @param _user The address of the user to get the current yield from
* @return The yield of the user in IBT
*/
function getCurrentYieldOfUserInIBT(address _user) external view returns (uint256);
}// SPDX-License-Identifier: BUSL-1.1
import "openzeppelin-contracts/interfaces/IERC20.sol";
pragma solidity ^0.8.20;
interface IYieldToken is IERC20 {
error EnforcedPause();
error UnauthorizedCaller();
/**
* @notice Initializer of the contract.
* @param name_ The name of the yt token.
* @param symbol_ The symbol of the yt token.
* @param pt The address of the PT associated with this yt token.
*/
function initialize(string calldata name_, string calldata symbol_, address pt) external;
/**
* @notice returns the decimals of the yt tokens.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the address of PT associated with this yt.
*/
function getPT() external view returns (address);
/**
* @dev Updates yield of sender and receiver in associated PT contract and
* then calls transfer of ERC20Upgradeable.
* See {ERC20Upgradeable-transfer}.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Updates yield of sender and receiver in associated PT contract and
* then calls transferFrom of ERC20Upgradeable.
* See {ERC20Upgradeable-transferFrom}.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
/**
* @notice Burn amount of tokens using ERC20Upgradeable-_burn, in the context of PT's redeem or withdraw.
* @dev call only be called by associated PT.
* @dev does not update owner's yield, as opposed to burn().
* See {ERC20Upgradeable-_burn}.
* @param owner address from which tokens will be burnt
* @param caller address who made the PT's redeem/withdraw call
* @param amount to burn
*/
function burnWithoutYieldUpdate(address owner, address caller, uint256 amount) external;
/**
* @notice Checks for msg.sender to be pt and then calls _mint of ERC20Upgradeable.
* See {ERC20Upgradeable- _mint}.
* @param to address to mint YT's to
* @param amount to mint
*/
function mint(address to, uint256 amount) external;
/**
* @notice Updates the yield of the caller and then calls _burn of ERC20Upgradeable.
* See {ERC20Upgradeable-_burn}.
* @param amount of YT's to burn
*/
function burn(uint256 amount) external;
/**
* @dev Returns the amount of tokens in existence before expiry, and 0 after expiry
* @notice This behaviour is for UI/UX purposes only
* @return the value of YTs in existence, and 0 after expiry
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account` before expiry, and 0 after expiry
* @notice This behaviour is for UI/UX purposes only
* @param account The address of the user to get the actual balance of YT from
* @return The users balance of YTs before expiry, and 0 after expiry
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Returns the actual amount of tokens owned by `account` at any point in time
* @param account The address of the user to get the actual balance of YT from
* @return The actual users balance of YTs (before and after expiry)
*/
function actualBalanceOf(address account) external view returns (uint256);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.20;
interface IRewardsProxy {
/**
* @notice Claims rewards based on the provided data.
* @dev This function should be called using `delegatecall`, and should handle the logic for claiming rewards
* based on the input data. The specific format and structure of `data` should be defined by the implementation.
* @param _data ABI-encoded data containing the necessary information to claim rewards.
*/
function claimRewards(bytes memory _data) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the 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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}// 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.0.0) (access/manager/IAccessManager.sol)
pragma solidity ^0.8.20;
import {IAccessManaged} from "./IAccessManaged.sol";
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 AccessManagerLockedAccount(address account);
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 this manager itself. These are defined by the
* {_canCallSelf} function instead.
*/
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.
*/
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, uint32, uint32, uint48);
/**
* @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, uint32);
/**
* @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.
*
* 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, uint32);
/**
* @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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol)
pragma solidity ^0.8.20;
interface IAccessManaged {
/**
* @dev Authority that manages this contract was updated.
*/
event AuthorityUpdated(address authority);
error AccessManagedUnauthorized(address caller);
error AccessManagedRequiredDelay(address caller, uint32 delay);
error AccessManagedInvalidAuthority(address authority);
/**
* @dev Returns the current authority.
*/
function authority() external view returns (address);
/**
* @dev Transfers control to a new authority. The caller must be the current authority.
*/
function setAuthority(address) external;
/**
* @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is
* being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs
* attacker controlled calls.
*/
function isConsumingScheduledOp() external view returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*/
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
/// @custom:storage-location erc7201:openzeppelin.storage.ERC20
struct ERC20Storage {
mapping(address account => uint256) _balances;
mapping(address account => mapping(address spender => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;
function _getERC20Storage() private pure returns (ERC20Storage storage $) {
assembly {
$.slot := ERC20StorageLocation
}
}
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC20Storage storage $ = _getERC20Storage();
$._name = name_;
$._symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
$._totalSupply += value;
} else {
uint256 fromBalance = $._balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
$._balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
$._totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
$._balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
$._allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.20;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
/**
* @dev The signature derives the `address(0)`.
*/
error ECDSAInvalidSignature();
/**
* @dev The signature has an invalid length.
*/
error ECDSAInvalidSignatureLength(uint256 length);
/**
* @dev The signature has an S value that is in the upper half order.
*/
error ECDSAInvalidSignatureS(bytes32 s);
/**
* @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
* return address(0) without also returning an error description. Errors are documented using an enum (error type)
* and a bytes32 providing additional information about the error.
*
* If no error is returned, then the address can be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
// We do not check for an overflow here since the shift operation results in 0 or 1.
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
*/
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)
pragma solidity ^0.8.20;
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
* encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
* does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
* produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
* separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
* separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
*/
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
/// @custom:storage-location erc7201:openzeppelin.storage.EIP712
struct EIP712Storage {
/// @custom:oz-renamed-from _HASHED_NAME
bytes32 _hashedName;
/// @custom:oz-renamed-from _HASHED_VERSION
bytes32 _hashedVersion;
string _name;
string _version;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.EIP712")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;
function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
assembly {
$.slot := EIP712StorageLocation
}
}
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
EIP712Storage storage $ = _getEIP712Storage();
$._name = name;
$._version = version;
// Reset prior values in storage if upgrading
$._hashedName = 0;
$._hashedVersion = 0;
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator();
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
/**
* @dev See {IERC-5267}.
*/
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
EIP712Storage storage $ = _getEIP712Storage();
// If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
// and the EIP712 domain is not reliable, as it will be missing name and version.
require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");
return (
hex"0f", // 01111
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
/**
* @dev The name parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712Name() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._name;
}
/**
* @dev The version parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712Version() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._version;
}
/**
* @dev The hash of the name parameter for the EIP712 domain.
*
* NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
*/
function _EIP712NameHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory name = _EIP712Name();
if (bytes(name).length > 0) {
return keccak256(bytes(name));
} else {
// If the name is empty, the contract may have been upgraded without initializing the new storage.
// We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
bytes32 hashedName = $._hashedName;
if (hashedName != 0) {
return hashedName;
} else {
return keccak256("");
}
}
}
/**
* @dev The hash of the version parameter for the EIP712 domain.
*
* NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
*/
function _EIP712VersionHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory version = _EIP712Version();
if (bytes(version).length > 0) {
return keccak256(bytes(version));
} else {
// If the version is empty, the contract may have been upgraded without initializing the new storage.
// We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
bytes32 hashedVersion = $._hashedVersion;
if (hashedVersion != 0) {
return hashedVersion;
} else {
return keccak256("");
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides tracking nonces for addresses. Nonces will only increment.
*/
abstract contract NoncesUpgradeable is Initializable {
/**
* @dev The nonce used for an `account` is not the expected current nonce.
*/
error InvalidAccountNonce(address account, uint256 currentNonce);
/// @custom:storage-location erc7201:openzeppelin.storage.Nonces
struct NoncesStorage {
mapping(address account => uint256) _nonces;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Nonces")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant NoncesStorageLocation = 0x5ab42ced628888259c08ac98db1eb0cf702fc1501344311d8b100cd1bfe4bb00;
function _getNoncesStorage() private pure returns (NoncesStorage storage $) {
assembly {
$.slot := NoncesStorageLocation
}
}
function __Nonces_init() internal onlyInitializing {
}
function __Nonces_init_unchained() internal onlyInitializing {
}
/**
* @dev Returns the next unused nonce for an address.
*/
function nonces(address owner) public view virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
return $._nonces[owner];
}
/**
* @dev Consumes a nonce.
*
* Returns the current value and increments nonce.
*/
function _useNonce(address owner) internal virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
// For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
// decremented or reset. This guarantees that the nonce never overflows.
unchecked {
// It is important to do x++ and not ++x here.
return $._nonces[owner]++;
}
}
/**
* @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
*/
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.20;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeacon {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {UpgradeableBeacon} will check that this address is a contract.
*/
function implementation() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Proxy.sol)
pragma solidity ^0.8.20;
/**
* @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
* instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
* be specified by overriding the virtual {_implementation} function.
*
* Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
* different contract through the {_delegate} function.
*
* The success and return data of the delegated call will be returned back to the caller of the proxy.
*/
abstract contract Proxy {
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
/**
* @dev This is a virtual function that should be overridden so it returns the address to which the fallback
* function and {_fallback} should delegate.
*/
function _implementation() internal view virtual returns (address);
/**
* @dev Delegates the current call to the address returned by `_implementation()`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _fallback() internal virtual {
_delegate(_implementation());
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
* function in the contract matches the call data.
*/
fallback() external payable virtual {
_fallback();
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)
pragma solidity ^0.8.20;
import {IBeacon} from "../beacon/IBeacon.sol";
import {Address} from "../../utils/Address.sol";
import {StorageSlot} from "../../utils/StorageSlot.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*/
library ERC1967Utils {
// We re-declare ERC-1967 events here because they can't be used directly from IERC1967.
// This will be fixed in Solidity 0.8.21. At that point we should remove these events.
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev The `implementation` of the proxy is invalid.
*/
error ERC1967InvalidImplementation(address implementation);
/**
* @dev The `admin` of the proxy is invalid.
*/
error ERC1967InvalidAdmin(address admin);
/**
* @dev The `beacon` of the proxy is invalid.
*/
error ERC1967InvalidBeacon(address beacon);
/**
* @dev An upgrade function sees `msg.value > 0` that may be lost.
*/
error ERC1967NonPayable();
/**
* @dev Returns the current implementation address.
*/
function getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
if (newImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(newImplementation);
}
StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Performs implementation upgrade with additional setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-Upgraded} event.
*/
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0) {
Address.functionDelegateCall(newImplementation, data);
} else {
_checkNonPayable();
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Returns the current admin.
*
* TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using
* the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
* `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
*/
function getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
if (newAdmin == address(0)) {
revert ERC1967InvalidAdmin(address(0));
}
StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {IERC1967-AdminChanged} event.
*/
function changeAdmin(address newAdmin) internal {
emit AdminChanged(getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Returns the current beacon.
*/
function getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
if (newBeacon.code.length == 0) {
revert ERC1967InvalidBeacon(newBeacon);
}
StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;
address beaconImplementation = IBeacon(newBeacon).implementation();
if (beaconImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(beaconImplementation);
}
}
/**
* @dev Change the beacon and trigger a setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-BeaconUpgraded} event.
*
* CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
* it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
* efficiency.
*/
function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
} else {
_checkNonPayable();
}
}
/**
* @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
* if an upgrade doesn't perform an initialization call.
*/
function _checkNonPayable() private {
if (msg.value > 0) {
revert ERC1967NonPayable();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.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 ERC20 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: 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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC3156FlashLender.sol)
pragma solidity ^0.8.20;
import {IERC3156FlashBorrower} from "./IERC3156FlashBorrower.sol";
/**
* @dev Interface of the ERC3156 FlashLender, as defined in
* https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
*/
interface IERC3156FlashLender {
/**
* @dev The amount of currency available to be lended.
* @param token The loan currency.
* @return The amount of `token` that can be borrowed.
*/
function maxFlashLoan(address token) external view returns (uint256);
/**
* @dev The fee to be charged for a given loan.
* @param token The loan currency.
* @param amount The amount of tokens lent.
* @return The amount of `token` to be charged for the loan, on top of the returned principal.
*/
function flashFee(address token, uint256 amount) external view returns (uint256);
/**
* @dev Initiate a flash loan.
* @param receiver The receiver of the tokens in the loan, and the receiver of the callback.
* @param token The loan currency.
* @param amount The amount of tokens lent.
* @param data Arbitrary data structure, intended to contain user-defined parameters.
*/
function flashLoan(
IERC3156FlashBorrower receiver,
address token,
uint256 amount,
bytes calldata data
) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.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, uint32, uint48) {
(uint32 valueBefore, uint32 valueAfter, uint48 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, uint32, uint48) {
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.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
/**
* @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
*
* The library provides methods for generating a hash of a message that conforms to the
* https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
* specifications.
*/
library MessageHashUtils {
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing a bytes32 `messageHash` with
* `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
* keccak256, although any bytes32 value can be safely used because the final digest will
* be re-hashed.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
}
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing an arbitrary `message` with
* `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x00` (data with intended validator).
*
* The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
* `validator` address. Then hashing the result.
*
* See {ECDSA-recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
/**
* @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
*
* The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
* `\x19\x01` and hashing the result. It corresponds to the hash signed by the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
*
* See {ECDSA-recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)
pragma solidity ^0.8.20;
interface IERC5267 {
/**
* @dev MAY be emitted to signal that the domain could have changed.
*/
event EIP712DomainChanged();
/**
* @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
* signature.
*/
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.20;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(newImplementation.code.length > 0);
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.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 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);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}{
"remappings": [
"ds-test/=lib/forge-std/lib/ds-test/src/",
"erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
"forge-std/=lib/forge-std/src/",
"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
"openzeppelin-erc20-basic/=lib/openzeppelin-contracts/contracts/token/ERC20/",
"openzeppelin-erc20-extensions/=lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/",
"openzeppelin-erc20/=lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/",
"openzeppelin-math/=lib/openzeppelin-contracts/contracts/utils/math/",
"openzeppelin-proxy/=lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/",
"openzeppelin-utils/=lib/openzeppelin-contracts/contracts/utils/",
"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/"
],
"optimizer": {
"enabled": true,
"runs": 200
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"evmVersion": "shanghai",
"viaIR": false,
"libraries": {
"src/libraries/CurvePoolUtil.sol": {
"CurvePoolUtil": "0xe6c69Dd9c450406c3E4383431bAe36B7B6aE018c"
},
"src/libraries/PrincipalTokenUtil.sol": {
"PrincipalTokenUtil": "0x335408Ca7f0258427F99eF2457291583B55d757c"
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_registry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"authority","type":"address"}],"name":"AccessManagedInvalidAuthority","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint32","name":"delay","type":"uint32"}],"name":"AccessManagedRequiredDelay","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"AccessManagedUnauthorized","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"AddressError","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"BeaconNotSet","type":"error"},{"inputs":[],"name":"ClaimRewardsFailed","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[],"name":"ERC5143SlippageProtectionFailed","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"FlashLoanCallbackFailed","type":"error"},{"inputs":[],"name":"FlashLoanExceedsMaxAmount","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidDecimals","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"MathOverflowedMulDiv","type":"error"},{"inputs":[],"name":"NoRewardsProxy","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"PTExpired","type":"error"},{"inputs":[],"name":"PTNotExpired","type":"error"},{"inputs":[],"name":"RateError","type":"error"},{"inputs":[],"name":"RatesAtExpiryAlreadyStored","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"UnauthorizedCaller","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"authority","type":"address"}],"name":"AuthorityUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"redeemedIbts","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"receivedAssets","type":"uint256"}],"name":"FeeClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"ibtRate","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"ptRate","type":"uint256"}],"name":"RatesStoredAtExpiry","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRewardsProxy","type":"address"},{"indexed":true,"internalType":"address","name":"newRewardsProxy","type":"address"}],"name":"RewardsProxyChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"yt","type":"address"}],"name":"YTDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"uint256","name":"yieldInIBT","type":"uint256"}],"name":"YieldClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"yieldInIBT","type":"uint256"}],"name":"YieldUpdated","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"authority","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"beforeYtTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minAssets","type":"uint256"}],"name":"claimFees","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_minAssets","type":"uint256"}],"name":"claimYield","outputs":[{"internalType":"uint256","name":"yieldInAsset","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_minIBT","type":"uint256"}],"name":"claimYieldInIBT","outputs":[{"internalType":"uint256","name":"yieldInIBT","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"underlyingAmount","type":"uint256"}],"name":"convertToPrincipal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"principalAmount","type":"uint256"}],"name":"convertToUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"ptReceiver","type":"address"},{"internalType":"address","name":"ytReceiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"ptReceiver","type":"address"},{"internalType":"address","name":"ytReceiver","type":"address"},{"internalType":"uint256","name":"minShares","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"},{"internalType":"address","name":"ptReceiver","type":"address"},{"internalType":"address","name":"ytReceiver","type":"address"},{"internalType":"uint256","name":"minShares","type":"uint256"}],"name":"depositIBT","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"depositIBT","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"},{"internalType":"address","name":"ptReceiver","type":"address"},{"internalType":"address","name":"ytReceiver","type":"address"}],"name":"depositIBT","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"flashFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC3156FlashBorrower","name":"_receiver","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"flashLoan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getCurrentYieldOfUserInIBT","outputs":[{"internalType":"uint256","name":"_yieldOfUserInIBT","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIBT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIBTRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIBTUnit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPTRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenizationFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalFeesInIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUnclaimedFeesInIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getYT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_ibt","type":"address"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"address","name":"_initialAuthority","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isConsumingScheduledOp","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maturity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"maxFlashLoan","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdrawIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"}],"name":"previewDepositIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeemForIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"}],"name":"previewWithdrawIBT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"minAssets","type":"uint256"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"minIbts","type":"uint256"}],"name":"redeemForIBT","outputs":[{"internalType":"uint256","name":"ibts","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeemForIBT","outputs":[{"internalType":"uint256","name":"ibts","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAuthority","type":"address"}],"name":"setAuthority","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsProxy","type":"address"}],"name":"setRewardsProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"storeRatesAtExpiry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"updateYield","outputs":[{"internalType":"uint256","name":"updatedUserYieldInIBT","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"maxShares","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdrawIBT","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ibts","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"maxShares","type":"uint256"}],"name":"withdrawIBT","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000cb671f588c85e1403ecb9b4f6da0dff0d1e9d3fb
-----Decoded View---------------
Arg [0] : _registry (address): 0xcb671f588c85E1403ecB9B4f6dA0dff0d1e9D3FB
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000cb671f588c85e1403ecb9b4f6da0dff0d1e9d3fb
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
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.