Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 17893896 | 334 days ago | IN | Create: RolloverVault | 0 ETH | 0.08278238 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
RolloverVault
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.19; import { IERC20Upgradeable, IPerpetualTranche, IBondIssuer, IBondController, ITranche } from "../_interfaces/IPerpetualTranche.sol"; import { IVault, UnexpectedAsset, UnauthorizedTransferOut, InsufficientDeployment, DeployedCountOverLimit } from "../_interfaces/IVault.sol"; import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol"; import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol"; import { MathUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol"; import { ERC20BurnableUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol"; import { EnumerableSetUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol"; import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol"; import { BondTranches, TrancheHelpers, BondHelpers } from "../_utils/BondHelpers.sol"; /// @notice Storage array access out of bounds. error OutOfBounds(); /* * @title RolloverVault * * @notice A vault which generates yield (from fees) by performing rollovers on PerpetualTranche (or perp). * The vault takes in AMPL or any other rebasing collateral as the "underlying" asset. * * Vault strategy: * 1) deploy: The vault deposits the underlying asset into perp's current deposit bond * to get tranche tokens in return, it then swaps these fresh tranche tokens for * older tranche tokens (ones mature or approaching maturity) from perp. * system through a rollover operation and earns an income in perp tokens. * 2) recover: The vault redeems tranches for the underlying asset. * NOTE: It performs both mature and immature redemption. Read more: https://bit.ly/3tuN6OC * * */ contract RolloverVault is ERC20BurnableUpgradeable, OwnableUpgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable, IVault { // data handling using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet; using BondHelpers for IBondController; using TrancheHelpers for ITranche; // ERC20 operations using SafeERC20Upgradeable for IERC20Upgradeable; // math using MathUpgradeable for uint256; //------------------------------------------------------------------------- // Events /// @notice Emits the vault asset's token balance that's recorded after a change. /// @param token Address of token. /// @param balance The recorded ERC-20 balance of the token. event AssetSynced(IERC20Upgradeable token, uint256 balance); //------------------------------------------------------------------------- // Constants uint8 public constant PERC_DECIMALS = 6; uint256 public constant UNIT_PERC = 10**PERC_DECIMALS; uint256 public constant HUNDRED_PERC = 100 * UNIT_PERC; /// @dev Initial exchange rate between the underlying asset and notes. uint256 private constant INITIAL_RATE = 10**6; /// @dev Values should line up as is in the perp contract. uint8 private constant PERP_PRICE_DECIMALS = 8; uint256 private constant PERP_UNIT_PRICE = (10**PERP_PRICE_DECIMALS); /// @dev The maximum number of deployed assets that can be held in this vault at any given time. uint256 public constant MAX_DEPLOYED_COUNT = 47; //-------------------------------------------------------------------------- // ASSETS // // The vault's assets are represented by a master list of ERC-20 tokens // => { [underlying] U _deployed U _earned } // // In the case of this vault, the "earned" assets are the perp tokens themselves. // The reward (or yield) for performing rollovers is paid out in perp tokens. /// @notice The ERC20 token that can be deposited into this vault. IERC20Upgradeable public underlying; /// @dev The set of the intermediate ERC-20 tokens when the underlying asset has been put to use. /// In the case of this vault, they represent the tranche tokens held before maturity. EnumerableSetUpgradeable.AddressSet private _deployed; //------------------------------------------------------------------------- // Storage /// @notice Minimum amount of underlying assets that must be deployed, for a deploy operation to succeed. /// @dev The deployment transaction reverts, if the vaults does not have sufficient underlying tokens /// to cover the minimum deployment amount. uint256 public minDeploymentAmt; /// @notice The perpetual token on which rollovers are performed. IPerpetualTranche public perp; //-------------------------------------------------------------------------- // Construction & Initialization /// @notice Contract state initialization. /// @param name ERC-20 Name of the vault token. /// @param symbol ERC-20 Symbol of the vault token. /// @param perp_ ERC-20 address of the perpetual tranche rolled over. function init( string memory name, string memory symbol, IPerpetualTranche perp_ ) public initializer { __ERC20_init(name, symbol); __ERC20Burnable_init(); __Ownable_init(); __Pausable_init(); __ReentrancyGuard_init(); underlying = perp_.collateral(); _syncAsset(underlying); perp = perp_; } //-------------------------------------------------------------------------- // ADMIN only methods /// @notice Pauses deposits, withdrawals and vault operations. /// @dev NOTE: ERC-20 functions, like transfers will always remain operational. function pause() external onlyOwner { _pause(); } /// @notice Unpauses deposits, withdrawals and vault operations. /// @dev NOTE: ERC-20 functions, like transfers will always remain operational. function unpause() external onlyOwner { _unpause(); } /// @notice Updates the minimum deployment amount. /// @param minDeploymentAmt_ The new minimum deployment amount, denominated in underlying tokens. function updateMinDeploymentAmt(uint256 minDeploymentAmt_) external onlyOwner { minDeploymentAmt = minDeploymentAmt_; } /// @notice Transfers a non-vault token out of the contract, which may have been added accidentally. /// @param token The token address. /// @param to The destination address. /// @param amount The amount of tokens to be transferred. function transferERC20( IERC20Upgradeable token, address to, uint256 amount ) external onlyOwner { if (isVaultAsset(token)) { revert UnauthorizedTransferOut(token); } token.safeTransfer(to, amount); } //-------------------------------------------------------------------------- // External & Public write methods /// @inheritdoc IVault /// @dev Simply batches the `recover` and `deploy` functions. Reverts if there are no funds to deploy. function recoverAndRedeploy() external override { recover(); deploy(); } /// @inheritdoc IVault /// @dev Its safer to call `recover` before `deploy` so the full available balance can be deployed. /// Reverts if no funds are rolled over or if the minimum deployment threshold is not reached. function deploy() public override nonReentrant whenNotPaused { (uint256 deployedAmt, BondTranches memory bt) = _tranche(perp.getDepositBond()); uint256 perpsRolledOver = _rollover(perp, bt); // NOTE: The following enforces that we only tranche the underlying if it can immediately be used for rotations. if (deployedAmt <= minDeploymentAmt || perpsRolledOver <= 0) { revert InsufficientDeployment(); } } /// @inheritdoc IVault function recover() public override nonReentrant whenNotPaused { uint256 deployedCount_ = _deployed.length(); if (deployedCount_ <= 0) { return; } // execute redemption on each deployed asset for (uint256 i = 0; i < deployedCount_; i++) { ITranche tranche = ITranche(_deployed.at(i)); uint256 trancheBalance = tranche.balanceOf(address(this)); // if the vault has no tranche balance, // we update our internal book-keeping and continue to the next one. if (trancheBalance <= 0) { continue; } // get the parent bond IBondController bond = IBondController(tranche.bond()); // if bond has matured, redeem the tranche token if (bond.secondsToMaturity() <= 0) { // execute redemption _execMatureTrancheRedemption(bond, tranche, trancheBalance); } // if not redeem using proportional balances // redeems this tranche and it's siblings if the vault holds balances. // NOTE: For gas optimization, we perform this operation only once // ie) when we encounter the most-senior tranche. else if (tranche == bond.trancheAt(0)) { // execute redemption _execImmatureTrancheRedemption(bond); } } // sync deployed tranches // NOTE: We traverse the deployed set in the reverse order // as deletions involve swapping the deleted element to the // end of the set and removing the last element. for (uint256 i = deployedCount_; i > 0; i--) { _syncAndRemoveDeployedAsset(IERC20Upgradeable(_deployed.at(i - 1))); } // sync underlying _syncAsset(underlying); } /// @inheritdoc IVault /// @dev Reverts when attempting to recover a tranche which is not part of the deployed list. /// In the case of immature redemption, this method will recover other sibling tranches as well. function recover(IERC20Upgradeable token) external override nonReentrant whenNotPaused { if (!_deployed.contains(address(token))) { revert UnexpectedAsset(token); } ITranche tranche = ITranche(address(token)); uint256 trancheBalance = tranche.balanceOf(address(this)); // if the vault has no tranche balance, // we update our internal book-keeping and return. if (trancheBalance <= 0) { _syncAndRemoveDeployedAsset(tranche); return; } // get the parent bond IBondController bond = IBondController(tranche.bond()); // if bond has matured, redeem the tranche token if (bond.secondsToMaturity() <= 0) { // execute redemption _execMatureTrancheRedemption(bond, tranche, trancheBalance); // sync deployed asset _syncAndRemoveDeployedAsset(tranche); } // if not redeem using proportional balances // redeems this tranche and it's siblings if the vault holds balances. else { // execute redemption BondTranches memory bt = _execImmatureTrancheRedemption(bond); // sync deployed asset, ie current tranche and all its siblings. for (uint8 j = 0; j < bt.tranches.length; j++) { _syncAndRemoveDeployedAsset(bt.tranches[j]); } } // sync underlying _syncAsset(underlying); } /// @inheritdoc IVault function deposit(uint256 amount) external override nonReentrant whenNotPaused returns (uint256) { uint256 totalSupply_ = totalSupply(); uint256 notes = (totalSupply_ > 0) ? totalSupply_.mulDiv(amount, getTVL()) : (amount * INITIAL_RATE); underlying.safeTransferFrom(_msgSender(), address(this), amount); _syncAsset(underlying); _mint(_msgSender(), notes); return notes; } /// @inheritdoc IVault function redeem(uint256 notes) external override nonReentrant whenNotPaused returns (IVault.TokenAmount[] memory) { uint256 totalNotes = totalSupply(); uint256 deployedCount_ = _deployed.length(); uint256 assetCount = 2 + deployedCount_; // aggregating vault assets to be redeemed IVault.TokenAmount[] memory redemptions = new IVault.TokenAmount[](assetCount); redemptions[0].token = underlying; for (uint256 i = 0; i < deployedCount_; i++) { redemptions[i + 1].token = IERC20Upgradeable(_deployed.at(i)); } redemptions[deployedCount_ + 1].token = IERC20Upgradeable(perp); // burn notes _burn(_msgSender(), notes); // calculating amounts and transferring assets out proportionally for (uint256 i = 0; i < assetCount; i++) { redemptions[i].amount = redemptions[i].token.balanceOf(address(this)).mulDiv(notes, totalNotes); redemptions[i].token.safeTransfer(_msgSender(), redemptions[i].amount); _syncAsset(redemptions[i].token); } return redemptions; } /// @inheritdoc IVault /// @dev The total value is denominated in the underlying asset. function getTVL() public override returns (uint256) { uint256 totalValue = 0; // The underlying balance totalValue += underlying.balanceOf(address(this)); // The deployed asset value denominated in the underlying for (uint256 i = 0; i < _deployed.length(); i++) { ITranche tranche = ITranche(_deployed.at(i)); uint256 trancheBalance = tranche.balanceOf(address(this)); if (trancheBalance > 0) { (uint256 collateralBalance, uint256 trancheSupply) = tranche.getTrancheCollateralization(); totalValue += collateralBalance.mulDiv(trancheBalance, trancheSupply); } } // The earned asset (perp token) value denominated in the underlying uint256 perpBalance = perp.balanceOf(address(this)); if (perpBalance > 0) { // The "earned" asset is assumed to be the perp token. // Perp tokens are assumed to have the same denomination as the underlying totalValue += perpBalance.mulDiv(IPerpetualTranche(address(perp)).getAvgPrice(), PERP_UNIT_PRICE); } return totalValue; } /// @inheritdoc IVault /// @dev The asset value is denominated in the underlying asset. function getVaultAssetValue(IERC20Upgradeable token) external override returns (uint256) { // Underlying asset if (token == underlying) { return token.balanceOf(address(this)); } // Deployed asset else if (_deployed.contains(address(token))) { (uint256 collateralBalance, uint256 trancheSupply) = ITranche(address(token)).getTrancheCollateralization(); return collateralBalance.mulDiv(token.balanceOf(address(this)), trancheSupply); } // Earned asset else if (address(token) == address(perp)) { return ( token.balanceOf(address(this)).mulDiv(IPerpetualTranche(address(perp)).getAvgPrice(), PERP_UNIT_PRICE) ); } // Not a vault asset, so returning zero return 0; } //-------------------------------------------------------------------------- // External & Public read methods /// @inheritdoc IVault function vaultAssetBalance(IERC20Upgradeable token) external view override returns (uint256) { return isVaultAsset(token) ? token.balanceOf(address(this)) : 0; } /// @inheritdoc IVault function deployedCount() external view override returns (uint256) { return _deployed.length(); } /// @inheritdoc IVault function deployedAt(uint256 i) external view override returns (IERC20Upgradeable) { return IERC20Upgradeable(_deployed.at(i)); } /// @inheritdoc IVault function earnedCount() external pure returns (uint256) { return 1; } /// @inheritdoc IVault function earnedAt(uint256 i) external view override returns (IERC20Upgradeable) { if (i > 0) { revert OutOfBounds(); } return IERC20Upgradeable(perp); } /// @inheritdoc IVault function isVaultAsset(IERC20Upgradeable token) public view override returns (bool) { return (token == underlying) || _deployed.contains(address(token)) || (address(token) == address(perp)); } //-------------------------------------------------------------------------- // Private write methods /// @dev Deposits underlying balance into the provided bond and receives tranche tokens in return. /// And performs some book-keeping to keep track of the vault's assets. /// @return balance The amount of underlying assets tranched. /// @return bt The given bonds tranche data. function _tranche(IBondController bond) private returns (uint256, BondTranches memory) { // Get bond's tranche data BondTranches memory bt = bond.getTranches(); // Get underlying balance uint256 balance = underlying.balanceOf(address(this)); // Skip if balance is zero if (balance <= 0) { return (0, bt); } // balance is tranched _checkAndApproveMax(underlying, address(bond), balance); bond.deposit(balance); // sync holdings for (uint8 i = 0; i < bt.tranches.length; i++) { _syncAndAddDeployedAsset(bt.tranches[i]); } _syncAsset(underlying); return (balance, bt); } /// @dev Rolls over freshly tranched tokens from the given bond for older tranches (close to maturity) from perp. /// And performs some book-keeping to keep track of the vault's assets. /// @return The amount of perps rolled over. function _rollover(IPerpetualTranche perp_, BondTranches memory bt) private returns (uint256) { // NOTE: The first element of the list is the mature tranche, // there after the list is NOT ordered by maturity. IERC20Upgradeable[] memory rolloverTokens = perp_.getReserveTokensUpForRollover(); // Batch rollover uint256 totalPerpRolledOver = 0; uint8 vaultTrancheIdx = 0; uint256 perpTokenIdx = 0; // We pair tranche tokens held by the vault with tranche tokens held by perp, // And execute the rollover and continue to the next token with a usable balance. while (vaultTrancheIdx < bt.tranches.length && perpTokenIdx < rolloverTokens.length) { // trancheIntoPerp refers to the tranche going into perp from the vault ITranche trancheIntoPerp = bt.tranches[vaultTrancheIdx]; // tokenOutOfPerp is the reserve token coming out of perp into the vault IERC20Upgradeable tokenOutOfPerp = rolloverTokens[perpTokenIdx]; // compute available token out uint256 tokenOutAmtAvailable = address(tokenOutOfPerp) != address(0) ? tokenOutOfPerp.balanceOf(perp_.reserve()) : 0; // trancheIntoPerp tokens are NOT exhausted but tokenOutOfPerp is exhausted if (tokenOutAmtAvailable <= 0) { // Rollover is a no-op, so skipping to next tokenOutOfPerp ++perpTokenIdx; continue; } // Compute available tranche in uint256 trancheInAmtAvailable = trancheIntoPerp.balanceOf(address(this)); // trancheInAmtAvailable is exhausted if (trancheInAmtAvailable <= 0) { // Rollover is a no-op, so skipping to next trancheIntoPerp ++vaultTrancheIdx; continue; } // Preview rollover IPerpetualTranche.RolloverPreview memory rd = perp_.computeRolloverAmt( trancheIntoPerp, tokenOutOfPerp, trancheInAmtAvailable, tokenOutAmtAvailable ); // trancheIntoPerp isn't accepted by perp, likely because it's yield=0, refer perp docs for more info if (rd.perpRolloverAmt <= 0) { // Rollover is a no-op, so skipping to next trancheIntoPerp ++vaultTrancheIdx; continue; } // Perform rollover _checkAndApproveMax(trancheIntoPerp, address(perp_), trancheInAmtAvailable); perp_.rollover(trancheIntoPerp, tokenOutOfPerp, trancheInAmtAvailable); // sync deployed asset sent to perp _syncAndRemoveDeployedAsset(trancheIntoPerp); // skip insertion into the deployed list the case of the mature tranche, ie underlying if (tokenOutOfPerp != underlying) { // sync deployed asset retrieved from perp _syncAndAddDeployedAsset(tokenOutOfPerp); } // keep track of total amount rolled over totalPerpRolledOver += rd.perpRolloverAmt; } // sync underlying and earned (ie perp) _syncAsset(underlying); _syncAsset(perp_); return totalPerpRolledOver; } /// @dev Low level method that redeems the given mature tranche for the underlying asset. /// It interacts with the button-wood bond contract. /// This function should NOT be called directly, use `recover()` or `recover(tranche)` /// which wrap this function with the internal book-keeping necessary, /// to keep track of the vault's assets. function _execMatureTrancheRedemption( IBondController bond, ITranche tranche, uint256 amount ) private { if (!bond.isMature()) { bond.mature(); } bond.redeemMature(address(tranche), amount); } /// @dev Low level method that redeems the given tranche for the underlying asset, before maturity. /// If the vault holds sibling tranches with proportional balances, those will also get redeemed. /// It interacts with the button-wood bond contract. /// This function should NOT be called directly, use `recover()` or `recover(tranche)` /// which wrap this function with the internal book-keeping necessary, /// to keep track of the vault's assets. function _execImmatureTrancheRedemption(IBondController bond) private returns (BondTranches memory bt) { uint256[] memory trancheAmts; (bt, trancheAmts) = bond.computeRedeemableTrancheAmounts(address(this)); // NOTE: It is guaranteed that if one tranche amount is zero, all amounts are zeros. if (trancheAmts[0] > 0) { bond.redeem(trancheAmts); } return bt; } /// @dev Syncs balance and adds the given asset into the deployed list if the vault has a balance. function _syncAndAddDeployedAsset(IERC20Upgradeable token) private { uint256 balance = token.balanceOf(address(this)); emit AssetSynced(token, balance); if (balance > 0 && !_deployed.contains(address(token))) { // Inserts new token into the deployed assets list. _deployed.add(address(token)); if (_deployed.length() > MAX_DEPLOYED_COUNT) { revert DeployedCountOverLimit(); } } } /// @dev Syncs balance and removes the given asset from the deployed list if the vault has no balance. function _syncAndRemoveDeployedAsset(IERC20Upgradeable token) private { uint256 balance = token.balanceOf(address(this)); emit AssetSynced(token, balance); if (balance <= 0 && _deployed.contains(address(token))) { // Removes token into the deployed assets list. _deployed.remove(address(token)); } } /// @dev Logs the token balance held by the vault. function _syncAsset(IERC20Upgradeable token) private { uint256 balance = token.balanceOf(address(this)); emit AssetSynced(token, balance); } /// @dev Checks if the spender has sufficient allowance. If not, approves the maximum possible amount. function _checkAndApproveMax( IERC20Upgradeable token, address spender, uint256 amount ) private { uint256 allowance = token.allowance(address(this), spender); if (allowance < amount) { token.safeApprove(spender, 0); token.safeApprove(spender, type(uint256).max); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/ContextUpgradeable.sol"; import "../proxy/utils/Initializable.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.sol"; /** * @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] * ``` * 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 Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 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. Equivalent to `reinitializer(1)`. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _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. * * `initializer` is equivalent to `reinitializer(1)`, so 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. * * 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. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _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() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @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. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; import "../utils/ContextUpgradeable.sol"; import "../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 { /** * @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); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ function __Pausable_init() internal onlyInitializing { __Pausable_init_unchained(); } function __Pausable_init_unchained() internal onlyInitializing { _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) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; import "../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; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _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() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20Upgradeable.sol"; import "./extensions/IERC20MetadataUpgradeable.sol"; import "../../utils/ContextUpgradeable.sol"; import "../../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}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * 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. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * 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 { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { 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 value {ERC20} uses, unless this function is * 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 override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` 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 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); 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 `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `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. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` 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. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[45] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20PermitUpgradeable { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; import "../ERC20Upgradeable.sol"; import "../../../utils/ContextUpgradeable.sol"; import "../../../proxy/utils/Initializable.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable { function __ERC20Burnable_init() internal onlyInitializing { } function __ERC20Burnable_init_unchained() internal onlyInitializing { } /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { _spendAllowance(account, _msgSender(), amount); _burn(account, amount); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20Upgradeable.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20MetadataUpgradeable is IERC20Upgradeable { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20Upgradeable { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20Upgradeable.sol"; import "../extensions/draft-IERC20PermitUpgradeable.sol"; import "../../../utils/AddressUpgradeable.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 SafeERC20Upgradeable { using AddressUpgradeable for address; function safeTransfer( IERC20Upgradeable token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20Upgradeable token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20Upgradeable token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20PermitUpgradeable token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; import "../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; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library MathUpgradeable { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. It the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`. // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`. // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a // good first aproximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1; uint256 x = a; if (x >> 128 > 0) { x >>= 128; result <<= 64; } if (x >> 64 > 0) { x >>= 64; result <<= 32; } if (x >> 32 > 0) { x >>= 32; result <<= 16; } if (x >> 16 > 0) { x >>= 16; result <<= 8; } if (x >> 8 > 0) { x >>= 8; result <<= 4; } if (x >> 4 > 0) { x >>= 4; result <<= 2; } if (x >> 2 > 0) { result <<= 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) { uint256 result = sqrt(a); if (rounding == Rounding.Up && result * result < a) { result += 1; } return result; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol) pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCastUpgradeable { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248) { require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits"); return int248(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 * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240) { require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits"); return int240(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 * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232) { require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits"); return int232(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 * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224) { require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits"); return int224(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 * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216) { require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits"); return int216(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 * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208) { require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits"); return int208(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 * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200) { require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits"); return int200(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 * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192) { require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits"); return int192(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 * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184) { require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits"); return int184(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 * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176) { require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits"); return int176(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 * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168) { require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits"); return int168(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 * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160) { require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits"); return int160(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 * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152) { require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits"); return int152(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 * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144) { require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits"); return int144(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 * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136) { require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits"); return int136(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 * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128) { require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits"); return int128(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 * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120) { require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits"); return int120(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 * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112) { require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits"); return int112(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 * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104) { require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits"); return int104(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 * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96) { require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits"); return int96(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 * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88) { require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits"); return int88(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 * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80) { require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits"); return int80(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 * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72) { require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits"); return int72(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 * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64) { require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits"); return int64(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 * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56) { require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits"); return int56(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 * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48) { require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits"); return int48(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 * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40) { require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits"); return int40(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 * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32) { require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits"); return int32(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 * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24) { require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits"); return int24(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 * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16) { require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits"); return int16(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 * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8) { require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits"); return int8(value); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol) pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet. * ==== */ library EnumerableSetUpgradeable { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { ITranche } from "./ITranche.sol"; interface IBondController { function collateralToken() external view returns (address); function maturityDate() external view returns (uint256); function creationDate() external view returns (uint256); function totalDebt() external view returns (uint256); function feeBps() external view returns (uint256); function isMature() external view returns (bool); function tranches(uint256 i) external view returns (ITranche token, uint256 ratio); function trancheCount() external view returns (uint256 count); function trancheTokenAddresses(ITranche token) external view returns (bool); function deposit(uint256 amount) external; function redeem(uint256[] memory amounts) external; function mature() external; function redeemMature(address tranche, uint256 amount) external; }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; interface ITranche is IERC20Upgradeable { function bond() external view returns (address); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IBondController } from "./buttonwood/IBondController.sol"; /// @notice Expected at least one matured bond. error NoMaturedBonds(); interface IBondIssuer { /// @notice Event emitted when a new bond is issued by the issuer. /// @param bond The newly issued bond. event BondIssued(IBondController bond); /// @notice Event emitted when a bond has matured. /// @param bond The matured bond. event BondMature(IBondController bond); /// @notice The address of the underlying collateral token to be used for issued bonds. /// @return Address of the collateral token. function collateral() external view returns (address); /// @notice Invokes `mature` on issued active bonds. function matureActive() external; /// @notice Issues a new bond if sufficient time has elapsed since the last issue. function issue() external; /// @notice Checks if a given bond has been issued by the issuer. /// @param bond Address of the bond to check. /// @return if the bond has been issued by the issuer. function isInstance(IBondController bond) external view returns (bool); /// @notice Fetches the most recently issued bond. /// @return Address of the most recent bond. function getLatestBond() external returns (IBondController); /// @notice Returns the total number of bonds issued by this issuer. /// @return Number of bonds. function issuedCount() external view returns (uint256); /// @notice The bond address from the issued list by index. /// @param index The index of the bond in the issued list. /// @return Address of the bond. function issuedBondAt(uint256 index) external view returns (IBondController); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; interface IDiscountStrategy { /// @notice Computes the discount to be applied to a given tranche token. /// @param tranche The tranche token to compute discount for. /// @return The discount as a fixed point number with `decimals()`. function computeTrancheDiscount(IERC20Upgradeable tranche) external view returns (uint256); /// @notice Number of discount decimals. function decimals() external view returns (uint8); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; interface IFeeStrategy { /// @notice Address of the fee token. function feeToken() external view returns (IERC20Upgradeable); /// @notice Computes the fees while minting given amount of perp tokens. /// @dev The mint fee can be either positive or negative. When positive it's paid by the minting users to the reserve. /// When negative its paid to the minting users by the reserve. /// The protocol fee is always non-negative and is paid by the users minting to the /// perp contract's fee collector. /// @param amount The amount of perp tokens to be minted. /// @return reserveFee The fee paid to the reserve to mint perp tokens. /// @return protocolFee The fee paid to the protocol to mint perp tokens. function computeMintFees(uint256 amount) external view returns (int256 reserveFee, uint256 protocolFee); /// @notice Computes the fees while burning given amount of perp tokens. /// @dev The burn fee can be either positive or negative. When positive it's paid by the burning users to the reserve. /// When negative its paid to the burning users by the reserve. /// The protocol fee is always non-negative and is paid by the users burning to the /// perp contract's fee collector. /// @param amount The amount of perp tokens to be burnt. /// @return reserveFee The fee paid to the reserve to burn perp tokens. /// @return protocolFee The fee paid to the protocol to burn perp tokens. function computeBurnFees(uint256 amount) external view returns (int256 reserveFee, uint256 protocolFee); /// @notice Computes the fees while rolling over given amount of perp tokens. /// @dev The rollover fee can be either positive or negative. When positive it's paid by the users rolling over to the reserve. /// When negative its paid to the users rolling over by the reserve. /// The protocol fee is always positive and is paid by the users rolling over to the /// perp contract's fee collector. /// @param amount The Perp-denominated value of the tranches being rolled over. /// @return reserveFee The fee paid to the reserve to rollover tokens. /// @return protocolFee The fee paid to the protocol to rollover tokens. function computeRolloverFees(uint256 amount) external view returns (int256 reserveFee, uint256 protocolFee); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; import { IBondIssuer } from "./IBondIssuer.sol"; import { IFeeStrategy } from "./IFeeStrategy.sol"; import { IPricingStrategy } from "./IPricingStrategy.sol"; import { IDiscountStrategy } from "./IDiscountStrategy.sol"; import { IBondController } from "./buttonwood/IBondController.sol"; import { ITranche } from "./buttonwood/ITranche.sol"; interface IPerpetualTranche is IERC20Upgradeable { //-------------------------------------------------------------------------- // Events /// @notice Event emitted when the applied discount for a given token is set. /// @param token The address of the token. /// @param discount The discount factor applied. event DiscountApplied(IERC20Upgradeable token, uint256 discount); /// @notice Event emitted the reserve's current token balance is recorded after change. /// @param token Address of token. /// @param balance The recorded ERC-20 balance of the token held by the reserve. event ReserveSynced(IERC20Upgradeable token, uint256 balance); /// @notice Event emitted when the active deposit bond is updated. /// @param bond Address of the new deposit bond. event UpdatedDepositBond(IBondController bond); /// @notice Event emitted when the mature tranche balance is updated. /// @param matureTrancheBalance The mature tranche balance. event UpdatedMatureTrancheBalance(uint256 matureTrancheBalance); //-------------------------------------------------------------------------- // Methods /// @notice Deposits tranche tokens into the system and mint perp tokens. /// @param trancheIn The address of the tranche token to be deposited. /// @param trancheInAmt The amount of tranche tokens deposited. function deposit(ITranche trancheIn, uint256 trancheInAmt) external; /// @notice Burn perp tokens and redeem the share of reserve assets. /// @param perpAmtBurnt The amount of perp tokens burnt from the caller. function redeem(uint256 perpAmtBurnt) external; /// @notice Rotates newer tranches in for reserve tokens. /// @param trancheIn The tranche token deposited. /// @param tokenOut The reserve token to be redeemed. /// @param trancheInAmt The amount of trancheIn tokens deposited. function rollover( ITranche trancheIn, IERC20Upgradeable tokenOut, uint256 trancheInAmt ) external; /// @notice Reference to the wallet or contract that has the ability to pause/unpause operations. /// @return The address of the keeper. function keeper() external view returns (address); /// @notice The address of the underlying rebasing ERC-20 collateral token backing the tranches. /// @return Address of the collateral token. function collateral() external view returns (IERC20Upgradeable); /// @notice The "virtual" balance of all mature tranches held by the system. /// @return The mature tranche balance. function getMatureTrancheBalance() external returns (uint256); /// @notice The parent bond whose tranches are currently accepted to mint perp tokens. /// @return Address of the deposit bond. function getDepositBond() external returns (IBondController); /// @notice Checks if the given `trancheIn` can be rolled out for `tokenOut`. /// @param trancheIn The tranche token deposited. /// @param tokenOut The reserve token to be redeemed. /// @return If the given pair is a valid rollover. function isAcceptableRollover(ITranche trancheIn, IERC20Upgradeable tokenOut) external returns (bool); /// @notice The strategy contract with the fee computation logic. /// @return Address of the strategy contract. function feeStrategy() external view returns (IFeeStrategy); /// @notice The ERC-20 contract which holds perp balances. /// @return Address of the token. function perpERC20() external view returns (IERC20Upgradeable); /// @notice The contract where the protocol holds funds which back the perp token supply. /// @return Address of the reserve. function reserve() external view returns (address); /// @notice The address which holds any revenue extracted by protocol. /// @return Address of the fee collector. function protocolFeeCollector() external view returns (address); /// @notice The fee token currently used to receive fees in. /// @return Address of the fee token. function feeToken() external view returns (IERC20Upgradeable); /// @notice Total count of tokens held in the reserve. /// @return The reserve token count. function getReserveCount() external returns (uint256); /// @notice The token address from the reserve list by index. /// @param index The index of a token. /// @return The reserve token address. function getReserveAt(uint256 index) external returns (IERC20Upgradeable); /// @notice Checks if the given token is part of the reserve. /// @param token The address of a token to check. /// @return If the token is part of the reserve. function inReserve(IERC20Upgradeable token) external returns (bool); /// @notice Fetches the reserve's token balance. /// @param token The address of the tranche token held by the reserve. /// @return The ERC-20 balance of the reserve token. function getReserveTokenBalance(IERC20Upgradeable token) external returns (uint256); /// @notice Fetches the reserve's tranche token balance. /// @param tranche The address of the tranche token held by the reserve. /// @return The ERC-20 balance of the reserve tranche token. function getReserveTrancheBalance(IERC20Upgradeable tranche) external returns (uint256); /// @notice Calculates the reserve's tranche token value, /// in a standard denomination as defined by the implementation. /// @param tranche The address of the tranche token held by the reserve. /// @return The value of the reserve tranche balance held by the reserve, in a standard denomination. function getReserveTrancheValue(IERC20Upgradeable tranche) external returns (uint256); /// @notice Computes the price of each perp token, i.e) reserve value / total supply. /// @return The average price per perp token. function getAvgPrice() external returns (uint256); /// @notice Fetches the list of reserve tokens which are up for rollover. /// @return The list of reserve tokens up for rollover. function getReserveTokensUpForRollover() external returns (IERC20Upgradeable[] memory); /// @notice Computes the amount of perp tokens minted when `trancheInAmt` `trancheIn` tokens /// are deposited into the system. /// @param trancheIn The tranche token deposited. /// @param trancheInAmt The amount of tranche tokens deposited. /// @return The amount of perp tokens to be minted. function computeMintAmt(ITranche trancheIn, uint256 trancheInAmt) external returns (uint256); /// @notice Computes the amount reserve tokens redeemed when burning given number of perp tokens. /// @param perpAmtBurnt The amount of perp tokens to be burnt. /// @return tokensOut The list of reserve tokens redeemed. /// @return tokenOutAmts The list of reserve token amounts redeemed. function computeRedemptionAmts(uint256 perpAmtBurnt) external returns (IERC20Upgradeable[] memory tokensOut, uint256[] memory tokenOutAmts); struct RolloverPreview { /// @notice The perp denominated value of tokens rolled over. uint256 perpRolloverAmt; /// @notice The amount of tokens rolled out. uint256 tokenOutAmt; /// @notice The tranche denominated amount of tokens rolled out. /// @dev tokenOutAmt and trancheOutAmt can only be different values /// in the case of rolling over the mature tranche. uint256 trancheOutAmt; /// @notice The amount of trancheIn tokens rolled in. uint256 trancheInAmt; /// @notice The difference between the available trancheIn amount and /// the amount of tokens used for the rollover. uint256 remainingTrancheInAmt; } /// @notice Computes the amount reserve tokens that are rolled out for the given number /// of `trancheIn` tokens rolled in. /// @param trancheIn The tranche token rolled in. /// @param tokenOut The reserve token to be rolled out. /// @param trancheInAmtAvailable The amount of trancheIn tokens rolled in. /// @param tokenOutAmtRequested The amount of tokenOut tokens requested to be rolled out. /// @return r The rollover amounts in various denominations. function computeRolloverAmt( ITranche trancheIn, IERC20Upgradeable tokenOut, uint256 trancheInAmtAvailable, uint256 tokenOutAmtRequested ) external returns (RolloverPreview memory); /// @notice The discount to be applied given the reserve token. /// @param token The address of the reserve token. /// @return The discount applied. function computeDiscount(IERC20Upgradeable token) external view returns (uint256); /// @notice The price of the given reserve token. /// @param token The address of the reserve token. /// @return The computed price. function computePrice(IERC20Upgradeable token) external view returns (uint256); /// @notice Updates time dependent storage state. function updateState() external; }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; import { ITranche } from "../_interfaces/buttonwood/ITranche.sol"; interface IPricingStrategy { /// @notice Computes the price of a given tranche token. /// @param tranche The tranche to compute price of. /// @return The price as a fixed point number with `decimals()`. function computeTranchePrice(ITranche tranche) external view returns (uint256); /// @notice Computes the price of mature tranches extracted and held as naked collateral. /// @param collateralToken The collateral token. /// @param collateralBalance The collateral balance of all the mature tranches. /// @param debt The total count of mature tranches. /// @return The price as a fixed point number with `decimals()`. function computeMatureTranchePrice( IERC20Upgradeable collateralToken, uint256 collateralBalance, uint256 debt ) external view returns (uint256); /// @notice Number of price decimals. function decimals() external view returns (uint8); }
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity ^0.8.0; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; /// @notice Expected asset to be a valid vault asset. /// @param token Address of the token. error UnexpectedAsset(IERC20Upgradeable token); /// @notice Expected transfer out asset to not be a vault asset. /// @param token Address of the token transferred. error UnauthorizedTransferOut(IERC20Upgradeable token); /// @notice Expected a minimum amount of vault assets to be deployed. error InsufficientDeployment(); /// @notice Expected the number of vault assets deployed to be under the limit. error DeployedCountOverLimit(); /* * @title IVault * * @notice The standard interface for a generic vault as described by the "Vault Framework". * http://thinking.farm/essays/2022-10-05-mechanical-finance/ * * Users deposit a "underlying" asset and mint "notes" (or vault shares). * The vault "deploys" underlying asset in a rules-based fashion (through a hard-coded strategy) * to "earn" income. It "recovers" deployed assets once the investment matures. * * The vault operates through two external poke functions which off-chain keepers can execute. * 1) `deploy`: When executed, the vault "puts to work" the underlying assets it holds. The vault * usually returns other ERC-20 tokens which act as receipts of the deployment. * 2) `recover`: When executed, the vault turns in the receipts and retrieves the underlying asset and * usually collects some yield for this work. * * The rules of the deployment and recovery are specific to the vault strategy. * * At any time the vault will hold multiple ERC20 tokens, together referred to as the vault's "assets". * They can be a combination of the underlying asset, the earned asset and the deployed assets (receipts). * * On redemption users burn their "notes" to receive a proportional slice of all the vault's assets. * */ interface IVault { /// @notice Recovers deployed funds and redeploys them. function recoverAndRedeploy() external; /// @notice Deploys deposited funds. function deploy() external; /// @notice Recovers deployed funds. function recover() external; /// @notice Recovers a given deployed asset. /// @param token The ERC-20 token address of the deployed asset. function recover(IERC20Upgradeable token) external; /// @notice Deposits the underlying asset from {msg.sender} into the vault and mints notes. /// @param amount The amount tokens to be deposited into the vault. /// @return The amount of notes. function deposit(uint256 amount) external returns (uint256); struct TokenAmount { /// @notice The asset token redeemed. IERC20Upgradeable token; /// @notice The amount redeemed. uint256 amount; } /// @notice Burns notes and sends a proportional share of vault's assets back to {msg.sender}. /// @param notes The amount of notes to be burnt. /// @return The list of asset tokens and amounts redeemed. function redeem(uint256 notes) external returns (TokenAmount[] memory); /// @return The total value of assets currently held by the vault, denominated in a standard unit of account. function getTVL() external returns (uint256); /// @param token The address of the asset ERC-20 token held by the vault. /// @return The vault's asset token value, denominated in a standard unit of account. function getVaultAssetValue(IERC20Upgradeable token) external returns (uint256); /// @notice The ERC20 token that can be deposited into this vault. function underlying() external view returns (IERC20Upgradeable); /// @param token The address of the asset ERC-20 token held by the vault. /// @return The vault's asset token balance. function vaultAssetBalance(IERC20Upgradeable token) external view returns (uint256); /// @return Total count of deployed asset tokens held by the vault. function deployedCount() external view returns (uint256); /// @param i The index of a token. /// @return The token address from the deployed asset token list by index. function deployedAt(uint256 i) external view returns (IERC20Upgradeable); /// @return Total count of earned income tokens held by the vault. function earnedCount() external view returns (uint256); /// @param i The index of a token. /// @return The token address from the earned income token list by index. function earnedAt(uint256 i) external view returns (IERC20Upgradeable); /// @param token The address of a token to check. /// @return If the given token is held by the vault. function isVaultAsset(IERC20Upgradeable token) external view returns (bool); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.19; import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; import { IBondController } from "../_interfaces/buttonwood/IBondController.sol"; import { ITranche } from "../_interfaces/buttonwood/ITranche.sol"; import { SafeCastUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol"; import { MathUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol"; /// @notice Expected tranche to be part of bond. /// @param tranche Address of the tranche token. error UnacceptableTranche(ITranche tranche); struct BondTranches { ITranche[] tranches; uint256[] trancheRatios; } /** * @title BondTranchesHelpers * * @notice Library with helper functions for the bond's retrieved tranche data. * */ library BondTranchesHelpers { /// @notice Iterates through the tranche data to find the seniority index of the given tranche. /// @param bt The tranche data object. /// @param t The address of the tranche to check. /// @return the index of the tranche in the tranches array. function indexOf(BondTranches memory bt, ITranche t) internal pure returns (uint8) { for (uint8 i = 0; i < bt.tranches.length; i++) { if (bt.tranches[i] == t) { return i; } } revert UnacceptableTranche(t); } } /** * @title TrancheHelpers * * @notice Library with helper functions for tranche tokens. * */ library TrancheHelpers { /// @notice Given a tranche, looks up the collateral balance backing the tranche supply. /// @param t Address of the tranche token. /// @return The collateral balance and the tranche token supply. function getTrancheCollateralization(ITranche t) internal view returns (uint256, uint256) { IBondController bond = IBondController(t.bond()); BondTranches memory bt; uint256[] memory collateralBalances; uint256[] memory trancheSupplies; (bt, collateralBalances, trancheSupplies) = BondHelpers.getTrancheCollateralizations(bond); uint256 trancheIndex = BondTranchesHelpers.indexOf(bt, t); return (collateralBalances[trancheIndex], trancheSupplies[trancheIndex]); } } /** * @title BondHelpers * * @notice Library with helper functions for ButtonWood's Bond contract. * */ library BondHelpers { using SafeCastUpgradeable for uint256; using MathUpgradeable for uint256; // Replicating value used here: // https://github.com/buttonwood-protocol/tranche/blob/main/contracts/BondController.sol uint256 private constant TRANCHE_RATIO_GRANULARITY = 1000; uint256 private constant BPS = 10_000; /// @notice Given a bond, calculates the time remaining to maturity. /// @param b The address of the bond contract. /// @return The number of seconds before the bond reaches maturity. function secondsToMaturity(IBondController b) internal view returns (uint256) { uint256 maturityDate = b.maturityDate(); return maturityDate > block.timestamp ? maturityDate - block.timestamp : 0; } /// @notice Given a bond, retrieves all of the bond's tranches. /// @param b The address of the bond contract. /// @return The tranche data. function getTranches(IBondController b) internal view returns (BondTranches memory) { BondTranches memory bt; uint8 trancheCount = b.trancheCount().toUint8(); bt.tranches = new ITranche[](trancheCount); bt.trancheRatios = new uint256[](trancheCount); // Max tranches per bond < 2**8 - 1 for (uint8 i = 0; i < trancheCount; i++) { (ITranche t, uint256 ratio) = b.tranches(i); bt.tranches[i] = t; bt.trancheRatios[i] = ratio; } return bt; } /// @notice Given a bond, returns the tranche at the specified index. /// @param b The address of the bond contract. /// @param i Index of the tranche. /// @return t The tranche address. function trancheAt(IBondController b, uint8 i) internal view returns (ITranche t) { (t, ) = b.tranches(i); return t; } /// @notice Helper function to estimate the amount of tranches minted when a given amount of collateral /// is deposited into the bond. /// @dev This function is used off-chain services (using callStatic) to preview tranches minted after /// @param b The address of the bond contract. /// @return The tranche data, an array of tranche amounts and fees. function previewDeposit(IBondController b, uint256 collateralAmount) internal view returns ( BondTranches memory, uint256[] memory, uint256[] memory ) { BondTranches memory bt = getTranches(b); uint256[] memory trancheAmts = new uint256[](bt.tranches.length); uint256[] memory fees = new uint256[](bt.tranches.length); uint256 totalDebt = b.totalDebt(); uint256 collateralBalance = IERC20Upgradeable(b.collateralToken()).balanceOf(address(b)); uint256 feeBps = b.feeBps(); for (uint8 i = 0; i < bt.tranches.length; i++) { trancheAmts[i] = collateralAmount.mulDiv(bt.trancheRatios[i], TRANCHE_RATIO_GRANULARITY); if (collateralBalance > 0) { trancheAmts[i] = trancheAmts[i].mulDiv(totalDebt, collateralBalance); } } if (feeBps > 0) { for (uint8 i = 0; i < bt.tranches.length; i++) { fees[i] = trancheAmts[i].mulDiv(feeBps, BPS); trancheAmts[i] -= fees[i]; } } return (bt, trancheAmts, fees); } /// @notice Given a bond, for each tranche token retrieves the total collateral redeemable /// for the total supply of the tranche token (aka debt issued). /// @dev The cdr can be computed for each tranche by dividing the /// returned tranche's collateralBalance by the tranche's totalSupply. /// @param b The address of the bond contract. /// @return The tranche data and the list of collateral balances and the total supplies for each tranche. function getTrancheCollateralizations(IBondController b) internal view returns ( BondTranches memory, uint256[] memory, uint256[] memory ) { BondTranches memory bt = getTranches(b); uint256[] memory collateralBalances = new uint256[](bt.tranches.length); uint256[] memory trancheSupplies = new uint256[](bt.tranches.length); // When the bond is mature, the collateral is transferred over to the individual tranche token contracts if (b.isMature()) { for (uint8 i = 0; i < bt.tranches.length; i++) { trancheSupplies[i] = bt.tranches[i].totalSupply(); collateralBalances[i] = IERC20Upgradeable(b.collateralToken()).balanceOf(address(bt.tranches[i])); } return (bt, collateralBalances, trancheSupplies); } // Before the bond is mature, all the collateral is held by the bond contract uint256 bondCollateralBalance = IERC20Upgradeable(b.collateralToken()).balanceOf(address(b)); uint256 zTrancheIndex = bt.tranches.length - 1; for (uint8 i = 0; i < bt.tranches.length; i++) { trancheSupplies[i] = bt.tranches[i].totalSupply(); // a to y tranches if (i != zTrancheIndex) { collateralBalances[i] = (trancheSupplies[i] <= bondCollateralBalance) ? trancheSupplies[i] : bondCollateralBalance; bondCollateralBalance -= collateralBalances[i]; } // z tranche else { collateralBalances[i] = bondCollateralBalance; } } return (bt, collateralBalances, trancheSupplies); } /// @notice For a given bond and user address, computes the maximum number of each of the bond's tranches /// the user is able to redeem before the bond's maturity. These tranche amounts necessarily match the bond's tranche ratios. /// @param b The address of the bond contract. /// @param u The address to check balance for. /// @return The tranche data and an array of tranche token balances. function computeRedeemableTrancheAmounts(IBondController b, address u) internal view returns (BondTranches memory, uint256[] memory) { BondTranches memory bt = getTranches(b); uint256[] memory redeemableAmts = new uint256[](bt.tranches.length); // We Calculate how many underlying assets could be redeemed from each tranche balance, // assuming other tranches are not an issue, and record the smallest amount. // // Usually one tranche balance is the limiting factor, we first loop through to identify // it by figuring out the one which has the least `trancheBalance/trancheRatio`. // uint256 minBalanceToTrancheRatio = type(uint256).max; uint8 i; for (i = 0; i < bt.tranches.length; i++) { // NOTE: We round the avaiable balance down to the nearest multiple of the // tranche ratio. This ensures that `minBalanceToTrancheRatio` // can be represented without loss as a fixedPt number. uint256 bal = bt.tranches[i].balanceOf(u); bal = bal - (bal % bt.trancheRatios[i]); uint256 d = bal.mulDiv(TRANCHE_RATIO_GRANULARITY, bt.trancheRatios[i]); if (d < minBalanceToTrancheRatio) { minBalanceToTrancheRatio = d; } // if one of the balances is zero, we return if (minBalanceToTrancheRatio == 0) { return (bt, redeemableAmts); } } // Now that we have `minBalanceToTrancheRatio`, we compute the redeemable amounts. for (i = 0; i < bt.tranches.length; i++) { redeemableAmts[i] = bt.trancheRatios[i].mulDiv(minBalanceToTrancheRatio, TRANCHE_RATIO_GRANULARITY); } return (bt, redeemableAmts); } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"DeployedCountOverLimit","type":"error"},{"inputs":[],"name":"InsufficientDeployment","type":"error"},{"inputs":[],"name":"OutOfBounds","type":"error"},{"inputs":[{"internalType":"contract ITranche","name":"tranche","type":"address"}],"name":"UnacceptableTranche","type":"error"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"UnauthorizedTransferOut","type":"error"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"UnexpectedAsset","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":"contract IERC20Upgradeable","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"}],"name":"AssetSynced","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"inputs":[],"name":"HUNDRED_PERC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_DEPLOYED_COUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERC_DECIMALS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNIT_PERC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deploy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"}],"name":"deployedAt","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deployedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"}],"name":"earnedAt","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"earnedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getTVL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"getVaultAssetValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"contract IPerpetualTranche","name":"perp_","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"isVaultAsset","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minDeploymentAmt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[],"name":"perp","outputs":[{"internalType":"contract IPerpetualTranche","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"recover","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"recover","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"recoverAndRedeploy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"notes","type":"uint256"}],"name":"redeem","outputs":[{"components":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IVault.TokenAmount[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minDeploymentAmt_","type":"uint256"}],"name":"updateMinDeploymentAmt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"token","type":"address"}],"name":"vaultAssetBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
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.