Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x61020060 | 19870456 | 125 days ago | IN | 0 ETH | 0.0346603 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
AccToke
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 200 runs
Other Settings:
london EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; // solhint-disable not-rely-on-time,no-complex-fallback import { SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol"; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { ERC20 } from "openzeppelin-contracts/token/ERC20/ERC20.sol"; import { ERC20Votes } from "openzeppelin-contracts/token/ERC20/extensions/ERC20Votes.sol"; import { ERC20Permit } from "openzeppelin-contracts/token/ERC20/extensions/draft-ERC20Permit.sol"; import { Pausable } from "openzeppelin-contracts/security/Pausable.sol"; import { SafeCast } from "openzeppelin-contracts/utils/math/SafeCast.sol"; import { PRBMathUD60x18 } from "prb-math/contracts/PRBMathUD60x18.sol"; import { IWETH9 } from "src/interfaces/utils/IWETH9.sol"; import { IAccToke } from "src/interfaces/staking/IAccToke.sol"; import { ISystemRegistry } from "src/interfaces/ISystemRegistry.sol"; import { SecurityBase } from "src/security/SecurityBase.sol"; import { Errors } from "src/utils/Errors.sol"; import { SystemComponent } from "src/SystemComponent.sol"; import { Roles } from "src/libs/Roles.sol"; contract AccToke is IAccToke, ERC20Votes, Pausable, SystemComponent, SecurityBase { using SafeERC20 for IERC20Metadata; using SafeERC20 for IWETH9; // variables uint256 public immutable startEpoch; uint256 public immutable minStakeDuration; // solhint-disable-next-line const-name-snakecase uint256 public maxStakeDuration = 1461 days; // default 4 years uint256 public constant MIN_STAKE_AMOUNT = 10_000; uint256 public constant MAX_STAKE_AMOUNT = 100e6 * 1e18; // default 100m toke mapping(address => Lockup[]) public lockups; uint256 private constant YEAR_BASE_BOOST = 18e17; IERC20Metadata public immutable toke; // // Reward Vars // IWETH9 private immutable weth; uint256 public constant REWARD_FACTOR = 1e12; // tracks user's checkpointed reward debt per share mapping(address => uint256) public rewardDebtPerShare; // keeps track of rewards checkpointed / offloaded but not yet transferred mapping(address => uint256) private unclaimedRewards; // total current accumulated reward per share uint256 public accRewardPerShare; // See {IAccToke-totalRewardsEarned} uint256 public totalRewardsEarned; // See {IAccToke-totalRewardsClaimed} uint256 public totalRewardsClaimed; // See {IAccToke-rewardsClaimed} mapping(address => uint256) public rewardsClaimed; constructor( ISystemRegistry _systemRegistry, uint256 _startEpoch, uint256 _minStakeDuration ) SystemComponent(_systemRegistry) ERC20("Staked Toke", "accToke") ERC20Permit("accToke") SecurityBase(address(_systemRegistry.accessController())) { startEpoch = _startEpoch; minStakeDuration = _minStakeDuration; toke = systemRegistry.toke(); weth = systemRegistry.weth(); } // @dev short-circuit transfers function transfer(address, uint256) public pure override returns (bool) { revert TransfersDisabled(); } // @dev short-circuit transfers function transferFrom(address, address, uint256) public pure override returns (bool) { revert TransfersDisabled(); } /// @inheritdoc IAccToke function stake(uint256 amount, uint256 duration, address to) external { _stake(amount, duration, to); } /// @inheritdoc IAccToke function stake(uint256 amount, uint256 duration) external { _stake(amount, duration, msg.sender); } /// @inheritdoc IAccToke function isStakeableAmount(uint256 amount) public pure returns (bool) { return amount >= MIN_STAKE_AMOUNT && amount <= MAX_STAKE_AMOUNT; } function _stake(uint256 amount, uint256 duration, address to) internal whenNotPaused { // // validation checks // if (to == address(0)) revert ZeroAddress(); if (!isStakeableAmount(amount)) revert IncorrectStakingAmount(); // duration checked inside previewPoints (uint256 points, uint256 end) = previewPoints(amount, duration); if (points + totalSupply() > type(uint192).max) { revert StakingPointsExceeded(); } // checkpoint rewards for caller _collectRewards(to, false); // save information for current lockup lockups[to].push(Lockup({ amount: SafeCast.toUint128(amount), end: SafeCast.toUint128(end), points: points })); // create points for user _mint(to, points); emit Stake(to, lockups[to].length - 1, amount, end, points); // transfer staked toke in toke.safeTransferFrom(msg.sender, address(this), amount); } /// @inheritdoc IAccToke function unstake(uint256[] memory lockupIds) external whenNotPaused { _collectRewards(msg.sender, false); uint256 length = lockupIds.length; if (length == 0) revert InvalidLockupIds(); uint256 totalPoints = 0; uint256 totalAmount = 0; uint256 totalLockups = lockups[msg.sender].length; for (uint256 iter = 0; iter < length;) { uint256 lockupId = lockupIds[iter]; if (lockupId >= totalLockups) revert LockupDoesNotExist(); // get staking information Lockup memory lockup = lockups[msg.sender][lockupId]; // slither-disable-next-line timestamp if (block.timestamp < lockup.end) revert NotUnlockableYet(); if (lockup.end == 0) revert AlreadyUnlocked(); // remove stake delete lockups[msg.sender][lockupId]; // tally total points to be burned totalPoints += lockup.points; emit Unstake(msg.sender, lockupId, lockup.amount, lockup.end, lockup.points); // tally total toke amount to be returned totalAmount += lockup.amount; unchecked { ++iter; } } // wipe points _burn(msg.sender, totalPoints); // send staked toke back to user toke.safeTransfer(msg.sender, totalAmount); } /// @inheritdoc IAccToke function extend(uint256[] memory lockupIds, uint256[] memory durations) external whenNotPaused { uint256 length = lockupIds.length; if (length == 0) revert InvalidLockupIds(); if (length != durations.length) revert InvalidDurationLength(); // before doing anything, make sure the rewards checkpoints are updated! _collectRewards(msg.sender, false); uint256 totalExtendedPoints = 0; uint256 totalLockups = lockups[msg.sender].length; for (uint256 iter = 0; iter < length;) { uint256 lockupId = lockupIds[iter]; uint256 duration = durations[iter]; if (lockupId >= totalLockups) revert LockupDoesNotExist(); // duration checked inside previewPoints Lockup storage lockup = lockups[msg.sender][lockupId]; uint256 oldAmount = lockup.amount; uint256 oldEnd = lockup.end; uint256 oldPoints = lockup.points; (uint256 newPoints, uint256 newEnd) = previewPoints(oldAmount, duration); if (newEnd <= oldEnd) revert ExtendDurationTooShort(); lockup.end = SafeCast.toUint128(newEnd); lockup.points = newPoints; totalExtendedPoints = totalExtendedPoints + newPoints - oldPoints; emit Extend(msg.sender, lockupId, oldAmount, oldEnd, newEnd, oldPoints, newPoints); unchecked { ++iter; } } // issue extra points for extension _mint(msg.sender, totalExtendedPoints); } /// @inheritdoc IAccToke function previewPoints(uint256 amount, uint256 duration) public view returns (uint256 points, uint256 end) { if (duration < minStakeDuration) revert StakingDurationTooShort(); if (duration > maxStakeDuration) revert StakingDurationTooLong(); // slither-disable-next-line timestamp uint256 start = block.timestamp > startEpoch ? block.timestamp : startEpoch; end = start + duration; // calculate points based on duration from staking end date uint256 endYearpoc = ((end - startEpoch) * 1e18) / 365 days; uint256 multiplier = PRBMathUD60x18.pow(YEAR_BASE_BOOST, endYearpoc); points = (amount * multiplier) / 1e18; } /// @inheritdoc IAccToke function getLockups(address user) external view returns (Lockup[] memory) { return lockups[user]; } /// @notice Update max stake duration allowed function setMaxStakeDuration(uint256 _maxStakeDuration) external hasRole(Roles.ACC_TOKE_MANAGER) { uint256 old = maxStakeDuration; maxStakeDuration = _maxStakeDuration; emit SetMaxStakeDuration(old, _maxStakeDuration); } function pause() external hasRole(Roles.ACC_TOKE_MANAGER) { _pause(); } function unpause() external hasRole(Roles.ACC_TOKE_MANAGER) { _unpause(); } /* **************************************************************************** */ /* */ /* Rewards */ /* */ /* **************************************************************************** */ /// @notice Allows an actor to deposit ETH as staking reward to be distributed to all staked participants /// @param amount Amount of `WETH` to take from caller and deposit as reward for the stakers function addWETHRewards(uint256 amount) external { // update accounting to factor in new rewards _addWETHRewards(amount); // actually transfer WETH weth.safeTransferFrom(msg.sender, address(this), amount); } /// @dev Internal function used by both `addWETHRewards` external and the `receive()` function /// @param amount See {IAccToke-addWETHRewards}. function _addWETHRewards(uint256 amount) internal whenNotPaused { Errors.verifyNotZero(amount, "amount"); uint256 supply = totalSupply(); Errors.verifyNotZero(supply, "supply"); if (amount * REWARD_FACTOR < supply) { revert InsufficientAmount(); } totalRewardsEarned += amount; accRewardPerShare += amount * REWARD_FACTOR / supply; emit RewardsAdded(amount, accRewardPerShare); } /// @inheritdoc IAccToke function previewRewards() external view returns (uint256 amount) { return previewRewards(msg.sender); } /// @inheritdoc IAccToke function previewRewards(address user) public view returns (uint256 amount) { uint256 supply = totalSupply(); if (supply == 0) { return unclaimedRewards[user]; } // calculate reward per share by taking the current reward per share and subtracting what user already claimed uint256 _netRewardsPerShare = accRewardPerShare - rewardDebtPerShare[user]; // calculate full reward user is entitled to by taking their recently earned and adding unclaimed checkpointed return ((balanceOf(user) * _netRewardsPerShare) / REWARD_FACTOR) + unclaimedRewards[user]; } /// @inheritdoc IAccToke function collectRewards() external returns (uint256) { return _collectRewards(msg.sender, true); } /// @dev See {IAccToke-collectRewards}. function _collectRewards(address user, bool distribute) internal returns (uint256) { // calculate user's new rewards per share (current minus claimed) uint256 netRewardsPerShare = accRewardPerShare - rewardDebtPerShare[user]; // calculate amount of actual rewards uint256 netRewards = (balanceOf(user) * netRewardsPerShare) / REWARD_FACTOR; // get reference to user's pending (sandboxed) rewards uint256 pendingRewards = unclaimedRewards[user]; // update checkpoint to current rewardDebtPerShare[user] = accRewardPerShare; // if nothing to claim, bail if (netRewards == 0 && pendingRewards == 0) { return 0; } if (distribute) { // // if asked for actual distribution, transfer all earnings // // reset sandboxed rewards unclaimedRewards[user] = 0; // get total amount by adding new rewards and previously sandboxed uint256 totalClaiming = netRewards + pendingRewards; // update running totals //slither-disable-next-line costly-loop totalRewardsClaimed += totalClaiming; rewardsClaimed[user] += totalClaiming; emit RewardsClaimed(user, totalClaiming); // send rewards to user weth.safeTransfer(user, totalClaiming); // return total amount claimed return totalClaiming; } if (netRewards > 0) { // Save (sandbox) to their account for later transfer unclaimedRewards[user] += netRewards; emit RewardsCollected(user, netRewards); } // nothing collected return 0; } /// @notice Catch-all. If any eth is sent, wrap and add to rewards receive() external payable { // update accounting to factor in new rewards // NOTE: doing it in this order keeps slither happy _addWETHRewards(msg.value); // appreciate the ETH! wrap and add as rewards weth.deposit{ value: msg.value }(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/draft-IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.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.openzeppelin.com/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 ERC20 is Context, IERC20, IERC20Metadata { 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. */ constructor(string memory name_, string memory symbol_) { _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; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _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; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _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; // Overflow not possible: amount <= accountBalance <= totalSupply. _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 {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.1) (token/ERC20/extensions/ERC20Votes.sol) pragma solidity ^0.8.0; import "./draft-ERC20Permit.sol"; import "../../../utils/math/Math.sol"; import "../../../governance/utils/IVotes.sol"; import "../../../utils/math/SafeCast.sol"; import "../../../utils/cryptography/ECDSA.sol"; /** * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's, * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1. * * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module. * * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting * power can be queried through the public accessors {getVotes} and {getPastVotes}. * * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked. * * _Available since v4.2._ */ abstract contract ERC20Votes is IVotes, ERC20Permit { struct Checkpoint { uint32 fromBlock; uint224 votes; } bytes32 private constant _DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); mapping(address => address) private _delegates; mapping(address => Checkpoint[]) private _checkpoints; Checkpoint[] private _totalSupplyCheckpoints; /** * @dev Get the `pos`-th checkpoint for `account`. */ function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) { return _checkpoints[account][pos]; } /** * @dev Get number of checkpoints for `account`. */ function numCheckpoints(address account) public view virtual returns (uint32) { return SafeCast.toUint32(_checkpoints[account].length); } /** * @dev Get the address `account` is currently delegating to. */ function delegates(address account) public view virtual override returns (address) { return _delegates[account]; } /** * @dev Gets the current votes balance for `account` */ function getVotes(address account) public view virtual override returns (uint256) { uint256 pos = _checkpoints[account].length; return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes; } /** * @dev Retrieve the number of votes for `account` at the end of `blockNumber`. * * Requirements: * * - `blockNumber` must have been already mined */ function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_checkpoints[account], blockNumber); } /** * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances. * It is but NOT the sum of all the delegated votes! * * Requirements: * * - `blockNumber` must have been already mined */ function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber); } /** * @dev Lookup a value in a list of (sorted) checkpoints. */ function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) { // We run a binary search to look for the earliest checkpoint taken after `blockNumber`. // // Initially we check if the block is recent to narrow the search range. // During the loop, the index of the wanted checkpoint remains in the range [low-1, high). // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant. // - If the middle checkpoint is after `blockNumber`, we look in [low, mid) // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high) // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not // out of bounds (in which case we're looking too far in the past and the result is 0). // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out // the same. uint256 length = ckpts.length; uint256 low = 0; uint256 high = length; if (length > 5) { uint256 mid = length - Math.sqrt(length); if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) { high = mid; } else { low = mid + 1; } } while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(ckpts, mid).fromBlock > blockNumber) { high = mid; } else { low = mid + 1; } } return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes; } /** * @dev Delegate votes from the sender to `delegatee`. */ function delegate(address delegatee) public virtual override { _delegate(_msgSender(), delegatee); } /** * @dev Delegates votes from signer to `delegatee` */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= expiry, "ERC20Votes: signature expired"); address signer = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))), v, r, s ); require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce"); _delegate(signer, delegatee); } /** * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1). */ function _maxSupply() internal view virtual returns (uint224) { return type(uint224).max; } /** * @dev Snapshots the totalSupply after it has been increased. */ function _mint(address account, uint256 amount) internal virtual override { super._mint(account, amount); require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes"); _writeCheckpoint(_totalSupplyCheckpoints, _add, amount); } /** * @dev Snapshots the totalSupply after it has been decreased. */ function _burn(address account, uint256 amount) internal virtual override { super._burn(account, amount); _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount); } /** * @dev Move voting power when tokens are transferred. * * Emits a {IVotes-DelegateVotesChanged} event. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._afterTokenTransfer(from, to, amount); _moveVotingPower(delegates(from), delegates(to), amount); } /** * @dev Change delegation for `delegator` to `delegatee`. * * Emits events {IVotes-DelegateChanged} and {IVotes-DelegateVotesChanged}. */ function _delegate(address delegator, address delegatee) internal virtual { address currentDelegate = delegates(delegator); uint256 delegatorBalance = balanceOf(delegator); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveVotingPower(currentDelegate, delegatee, delegatorBalance); } function _moveVotingPower( address src, address dst, uint256 amount ) private { if (src != dst && amount > 0) { if (src != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount); emit DelegateVotesChanged(src, oldWeight, newWeight); } if (dst != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount); emit DelegateVotesChanged(dst, oldWeight, newWeight); } } } function _writeCheckpoint( Checkpoint[] storage ckpts, function(uint256, uint256) view returns (uint256) op, uint256 delta ) private returns (uint256 oldWeight, uint256 newWeight) { uint256 pos = ckpts.length; Checkpoint memory oldCkpt = pos == 0 ? Checkpoint(0, 0) : _unsafeAccess(ckpts, pos - 1); oldWeight = oldCkpt.votes; newWeight = op(oldWeight, delta); if (pos > 0 && oldCkpt.fromBlock == block.number) { _unsafeAccess(ckpts, pos - 1).votes = SafeCast.toUint224(newWeight); } else { ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)})); } } function _add(uint256 a, uint256 b) private pure returns (uint256) { return a + b; } function _subtract(uint256 a, uint256 b) private pure returns (uint256) { return a - b; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) { assembly { mstore(0, ckpts.slot) result.slot := add(keccak256(0, 0x20), pos) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/extensions/draft-ERC20Permit.sol) pragma solidity ^0.8.0; import "./draft-IERC20Permit.sol"; import "../ERC20.sol"; import "../../../utils/cryptography/ECDSA.sol"; import "../../../utils/cryptography/EIP712.sol"; import "../../../utils/Counters.sol"; /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`. * However, to ensure consistency with the upgradeable transpiler, we will continue * to reserve a slot. * @custom:oz-renamed-from _PERMIT_TYPEHASH */ // solhint-disable-next-line var-name-mixedcase bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT; /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= deadline, "ERC20Permit: expired deadline"); bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. * * _Available since v4.1._ */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; import "../utils/Context.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 Pausable is Context { /** * @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. */ constructor() { _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()); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: Unlicense pragma solidity >=0.8.4; import "./PRBMath.sol"; /// @title PRBMathUD60x18 /// @author Paul Razvan Berg /// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18 /// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60 /// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the /// maximum values permitted by the Solidity type uint256. library PRBMathUD60x18 { /// @dev Half the SCALE number. uint256 internal constant HALF_SCALE = 5e17; /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number. uint256 internal constant LOG2_E = 1_442695040888963407; /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have. uint256 internal constant MAX_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_584007913129639935; /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have. uint256 internal constant MAX_WHOLE_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_000000000000000000; /// @dev How many trailing decimals can be represented. uint256 internal constant SCALE = 1e18; /// @notice Calculates the arithmetic average of x and y, rounding down. /// @param x The first operand as an unsigned 60.18-decimal fixed-point number. /// @param y The second operand as an unsigned 60.18-decimal fixed-point number. /// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number. function avg(uint256 x, uint256 y) internal pure returns (uint256 result) { // The operations can never overflow. unchecked { // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice. result = (x >> 1) + (y >> 1) + (x & y & 1); } } /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x. /// /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. /// /// Requirements: /// - x must be less than or equal to MAX_WHOLE_UD60x18. /// /// @param x The unsigned 60.18-decimal fixed-point number to ceil. /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number. function ceil(uint256 x) internal pure returns (uint256 result) { if (x > MAX_WHOLE_UD60x18) { revert PRBMathUD60x18__CeilOverflow(x); } assembly { // Equivalent to "x % SCALE" but faster. let remainder := mod(x, SCALE) // Equivalent to "SCALE - remainder" but faster. let delta := sub(SCALE, remainder) // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster. result := add(x, mul(delta, gt(remainder, 0))) } } /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number. /// /// @dev Uses mulDiv to enable overflow-safe multiplication and division. /// /// Requirements: /// - The denominator cannot be zero. /// /// @param x The numerator as an unsigned 60.18-decimal fixed-point number. /// @param y The denominator as an unsigned 60.18-decimal fixed-point number. /// @param result The quotient as an unsigned 60.18-decimal fixed-point number. function div(uint256 x, uint256 y) internal pure returns (uint256 result) { result = PRBMath.mulDiv(x, SCALE, y); } /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number. /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant). function e() internal pure returns (uint256 result) { result = 2_718281828459045235; } /// @notice Calculates the natural exponent of x. /// /// @dev Based on the insight that e^x = 2^(x * log2(e)). /// /// Requirements: /// - All from "log2". /// - x must be less than 133.084258667509499441. /// /// @param x The exponent as an unsigned 60.18-decimal fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function exp(uint256 x) internal pure returns (uint256 result) { // Without this check, the value passed to "exp2" would be greater than 192. if (x >= 133_084258667509499441) { revert PRBMathUD60x18__ExpInputTooBig(x); } // Do the fixed-point multiplication inline to save gas. unchecked { uint256 doubleScaleProduct = x * LOG2_E; result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE); } } /// @notice Calculates the binary exponent of x using the binary fraction method. /// /// @dev See https://ethereum.stackexchange.com/q/79903/24693. /// /// Requirements: /// - x must be 192 or less. /// - The result must fit within MAX_UD60x18. /// /// @param x The exponent as an unsigned 60.18-decimal fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function exp2(uint256 x) internal pure returns (uint256 result) { // 2^192 doesn't fit within the 192.64-bit format used internally in this function. if (x >= 192e18) { revert PRBMathUD60x18__Exp2InputTooBig(x); } unchecked { // Convert x to the 192.64-bit fixed-point format. uint256 x192x64 = (x << 64) / SCALE; // Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation. result = PRBMath.exp2(x192x64); } } /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x. /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. /// @param x The unsigned 60.18-decimal fixed-point number to floor. /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number. function floor(uint256 x) internal pure returns (uint256 result) { assembly { // Equivalent to "x % SCALE" but faster. let remainder := mod(x, SCALE) // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster. result := sub(x, mul(remainder, gt(remainder, 0))) } } /// @notice Yields the excess beyond the floor of x. /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part. /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of. /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number. function frac(uint256 x) internal pure returns (uint256 result) { assembly { result := mod(x, SCALE) } } /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation. /// /// @dev Requirements: /// - x must be less than or equal to MAX_UD60x18 divided by SCALE. /// /// @param x The basic integer to convert. /// @param result The same number in unsigned 60.18-decimal fixed-point representation. function fromUint(uint256 x) internal pure returns (uint256 result) { unchecked { if (x > MAX_UD60x18 / SCALE) { revert PRBMathUD60x18__FromUintOverflow(x); } result = x * SCALE; } } /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down. /// /// @dev Requirements: /// - x * y must fit within MAX_UD60x18, lest it overflows. /// /// @param x The first operand as an unsigned 60.18-decimal fixed-point number. /// @param y The second operand as an unsigned 60.18-decimal fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function gm(uint256 x, uint256 y) internal pure returns (uint256 result) { if (x == 0) { return 0; } unchecked { // Checking for overflow this way is faster than letting Solidity do it. uint256 xy = x * y; if (xy / x != y) { revert PRBMathUD60x18__GmOverflow(x, y); } // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE // during multiplication. See the comments within the "sqrt" function. result = PRBMath.sqrt(xy); } } /// @notice Calculates 1 / x, rounding toward zero. /// /// @dev Requirements: /// - x cannot be zero. /// /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse. /// @return result The inverse as an unsigned 60.18-decimal fixed-point number. function inv(uint256 x) internal pure returns (uint256 result) { unchecked { // 1e36 is SCALE * SCALE. result = 1e36 / x; } } /// @notice Calculates the natural logarithm of x. /// /// @dev Based on the insight that ln(x) = log2(x) / log2(e). /// /// Requirements: /// - All from "log2". /// /// Caveats: /// - All from "log2". /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision. /// /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm. /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number. function ln(uint256 x) internal pure returns (uint256 result) { // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x) // can return is 196205294292027477728. unchecked { result = (log2(x) * SCALE) / LOG2_E; } } /// @notice Calculates the common logarithm of x. /// /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common /// logarithm based on the insight that log10(x) = log2(x) / log2(10). /// /// Requirements: /// - All from "log2". /// /// Caveats: /// - All from "log2". /// /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm. /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number. function log10(uint256 x) internal pure returns (uint256 result) { if (x < SCALE) { revert PRBMathUD60x18__LogInputTooSmall(x); } // Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined // in this contract. // prettier-ignore assembly { switch x case 1 { result := mul(SCALE, sub(0, 18)) } case 10 { result := mul(SCALE, sub(1, 18)) } case 100 { result := mul(SCALE, sub(2, 18)) } case 1000 { result := mul(SCALE, sub(3, 18)) } case 10000 { result := mul(SCALE, sub(4, 18)) } case 100000 { result := mul(SCALE, sub(5, 18)) } case 1000000 { result := mul(SCALE, sub(6, 18)) } case 10000000 { result := mul(SCALE, sub(7, 18)) } case 100000000 { result := mul(SCALE, sub(8, 18)) } case 1000000000 { result := mul(SCALE, sub(9, 18)) } case 10000000000 { result := mul(SCALE, sub(10, 18)) } case 100000000000 { result := mul(SCALE, sub(11, 18)) } case 1000000000000 { result := mul(SCALE, sub(12, 18)) } case 10000000000000 { result := mul(SCALE, sub(13, 18)) } case 100000000000000 { result := mul(SCALE, sub(14, 18)) } case 1000000000000000 { result := mul(SCALE, sub(15, 18)) } case 10000000000000000 { result := mul(SCALE, sub(16, 18)) } case 100000000000000000 { result := mul(SCALE, sub(17, 18)) } case 1000000000000000000 { result := 0 } case 10000000000000000000 { result := SCALE } case 100000000000000000000 { result := mul(SCALE, 2) } case 1000000000000000000000 { result := mul(SCALE, 3) } case 10000000000000000000000 { result := mul(SCALE, 4) } case 100000000000000000000000 { result := mul(SCALE, 5) } case 1000000000000000000000000 { result := mul(SCALE, 6) } case 10000000000000000000000000 { result := mul(SCALE, 7) } case 100000000000000000000000000 { result := mul(SCALE, 8) } case 1000000000000000000000000000 { result := mul(SCALE, 9) } case 10000000000000000000000000000 { result := mul(SCALE, 10) } case 100000000000000000000000000000 { result := mul(SCALE, 11) } case 1000000000000000000000000000000 { result := mul(SCALE, 12) } case 10000000000000000000000000000000 { result := mul(SCALE, 13) } case 100000000000000000000000000000000 { result := mul(SCALE, 14) } case 1000000000000000000000000000000000 { result := mul(SCALE, 15) } case 10000000000000000000000000000000000 { result := mul(SCALE, 16) } case 100000000000000000000000000000000000 { result := mul(SCALE, 17) } case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) } case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) } case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) } case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) } case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) } case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) } case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) } case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) } case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) } case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) } case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) } case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) } case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) } case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) } case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) } case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) } case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) } case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) } case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) } case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) } case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) } case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) } case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) } case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) } case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) } case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) } case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) } case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) } case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) } case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) } case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) } case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) } case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) } case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) } case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) } case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) } case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) } case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) } case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) } case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) } case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) } case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) } default { result := MAX_UD60x18 } } if (result == MAX_UD60x18) { // Do the fixed-point division inline to save gas. The denominator is log2(10). unchecked { result = (log2(x) * SCALE) / 3_321928094887362347; } } } /// @notice Calculates the binary logarithm of x. /// /// @dev Based on the iterative approximation algorithm. /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation /// /// Requirements: /// - x must be greater than or equal to SCALE, otherwise the result would be negative. /// /// Caveats: /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation. /// /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm. /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number. function log2(uint256 x) internal pure returns (uint256 result) { if (x < SCALE) { revert PRBMathUD60x18__LogInputTooSmall(x); } unchecked { // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n). uint256 n = PRBMath.mostSignificantBit(x / SCALE); // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow // because n is maximum 255 and SCALE is 1e18. result = n * SCALE; // This is y = x * 2^(-n). uint256 y = x >> n; // If y = 1, the fractional part is zero. if (y == SCALE) { return result; } // Calculate the fractional part via the iterative approximation. // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster. for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) { y = (y * y) / SCALE; // Is y^2 > 2 and so in the range [2,4)? if (y >= 2 * SCALE) { // Add the 2^(-m) factor to the logarithm. result += delta; // Corresponds to z/2 on Wikipedia. y >>= 1; } } } } /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal /// fixed-point number. /// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function. /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number. /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number. /// @return result The product as an unsigned 60.18-decimal fixed-point number. function mul(uint256 x, uint256 y) internal pure returns (uint256 result) { result = PRBMath.mulDivFixedPoint(x, y); } /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number. function pi() internal pure returns (uint256 result) { result = 3_141592653589793238; } /// @notice Raises x to the power of y. /// /// @dev Based on the insight that x^y = 2^(log2(x) * y). /// /// Requirements: /// - All from "exp2", "log2" and "mul". /// /// Caveats: /// - All from "exp2", "log2" and "mul". /// - Assumes 0^0 is 1. /// /// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number. /// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number. /// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number. function pow(uint256 x, uint256 y) internal pure returns (uint256 result) { if (x == 0) { result = y == 0 ? SCALE : uint256(0); } else { result = exp2(mul(log2(x), y)); } } /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the /// famous algorithm "exponentiation by squaring". /// /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring /// /// Requirements: /// - The result must fit within MAX_UD60x18. /// /// Caveats: /// - All from "mul". /// - Assumes 0^0 is 1. /// /// @param x The base as an unsigned 60.18-decimal fixed-point number. /// @param y The exponent as an uint256. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function powu(uint256 x, uint256 y) internal pure returns (uint256 result) { // Calculate the first iteration of the loop in advance. result = y & 1 > 0 ? x : SCALE; // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster. for (y >>= 1; y > 0; y >>= 1) { x = PRBMath.mulDivFixedPoint(x, x); // Equivalent to "y % 2 == 1" but faster. if (y & 1 > 0) { result = PRBMath.mulDivFixedPoint(result, x); } } } /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number. function scale() internal pure returns (uint256 result) { result = SCALE; } /// @notice Calculates the square root of x, rounding down. /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. /// /// Requirements: /// - x must be less than MAX_UD60x18 / SCALE. /// /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root. /// @return result The result as an unsigned 60.18-decimal fixed-point . function sqrt(uint256 x) internal pure returns (uint256 result) { unchecked { if (x > MAX_UD60x18 / SCALE) { revert PRBMathUD60x18__SqrtOverflow(x); } // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root). result = PRBMath.sqrt(x * SCALE); } } /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process. /// @param x The unsigned 60.18-decimal fixed-point number to convert. /// @return result The same number in basic integer form. function toUint(uint256 x) internal pure returns (uint256 result) { unchecked { result = x / SCALE; } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; interface IWETH9 is IERC20 { function symbol() external view returns (string memory); function deposit() external payable; function withdraw(uint256 amount) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; interface IAccToke { /////////////////////////////////////////////////////////////////// // Variables /////////////////////////////////////////////////////////////////// function startEpoch() external view returns (uint256); function minStakeDuration() external view returns (uint256); struct Lockup { uint128 amount; uint128 end; uint256 points; } function getLockups(address user) external view returns (Lockup[] memory); function toke() external view returns (IERC20Metadata); /////////////////////////////////////////////////////////////////// // Errors /////////////////////////////////////////////////////////////////// error ZeroAddress(); error StakingDurationTooShort(); error StakingDurationTooLong(); error StakingPointsExceeded(); error IncorrectStakingAmount(); error InsufficientFunds(); error LockupDoesNotExist(); error NotUnlockableYet(); error AlreadyUnlocked(); error ExtendDurationTooShort(); error TransfersDisabled(); error TransferFailed(); error NoRewardsToClaim(); error InsufficientAmount(); error InvalidLockupIds(); error InvalidDurationLength(); /////////////////////////////////////////////////////////////////// // Events /////////////////////////////////////////////////////////////////// event SetMaxStakeDuration(uint256 oldDuration, uint256 newDuration); event Stake(address indexed user, uint256 lockupId, uint256 amount, uint256 end, uint256 points); event Unstake(address indexed user, uint256 lockupId, uint256 amount, uint256 end, uint256 points); event Extend( address indexed user, uint256 lockupId, uint256 amount, uint256 oldEnd, uint256 newEnd, uint256 oldPoints, uint256 newPoints ); event RewardsAdded(uint256 amount, uint256 accRewardPerShare); event RewardsCollected(address indexed user, uint256 amount); event RewardsClaimed(address indexed user, uint256 amount); /////////////////////////////////////////////////////////////////// // // Staking Methods // /////////////////////////////////////////////////////////////////// /** * @notice Stake TOKE to an address that may not be the same as the sender of the funds. This can be used to give * staked funds to someone else. * * If staking before the start of staking (epoch), then the lockup start and end dates are shifted forward so that * the lockup starts at the epoch. * * @param amount TOKE to lockup in the stake * @param duration in seconds for the stake * @param to address to receive ownership of the stake */ function stake(uint256 amount, uint256 duration, address to) external; /** * @notice Stake TOKE * * If staking before the start of staking (epoch), then the lockup start and end dates are shifted forward so that * the lockup starts at the epoch. * * @notice Stake TOKE for myself. * @param amount TOKE to lockup in the stake * @param duration in seconds for the stake */ function stake(uint256 amount, uint256 duration) external; /** * @notice Collect staked TOKE for a lockup and any earned rewards. * @param lockupIds the id of the lockup to unstake */ function unstake(uint256[] memory lockupIds) external; /** * @notice Extend a stake lockup for additional points. * * The stake end time is computed from the current time + duration, just like it is for new stakes. So a new stake * for seven days duration and an old stake extended with a seven days duration would have the same end. * * If an extend is made before the start of staking, the start time for the new stake is shifted forwards to the * start of staking, which also shifts forward the end date. * * @param lockupIds the id of the old lockup to extend * @param durations number of seconds from now to stake for */ function extend(uint256[] memory lockupIds, uint256[] memory durations) external; /////////////////////////////////////////////////////////////////// // // Rewards // /////////////////////////////////////////////////////////////////// /// @notice The total amount of rewards earned for all stakes function totalRewardsEarned() external returns (uint256); /// @notice Total rewards claimed by all stakers function totalRewardsClaimed() external returns (uint256); /// @notice Rewards claimed by a specific wallet /// @param user Address of the wallet to check function rewardsClaimed(address user) external returns (uint256); /** * @notice Preview the number of points that would be returned for the * given amount and duration. * * @param amount TOKE to be staked * @param duration number of seconds to stake for * @return points staking points that would be returned * @return end staking period end date */ function previewPoints(uint256 amount, uint256 duration) external view returns (uint256, uint256); /// @notice Preview the reward amount a caller can claim function previewRewards() external view returns (uint256); /// @notice Preview the reward amount a specified wallet can claim function previewRewards(address user) external view returns (uint256); /// @notice Claim rewards for the caller function collectRewards() external returns (uint256); /// @notice Check if amount can be staked function isStakeableAmount(uint256 amount) external pure returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IWETH9 } from "src/interfaces/utils/IWETH9.sol"; import { IAccToke } from "src/interfaces/staking/IAccToke.sol"; import { IAutopoolRegistry } from "src/interfaces/vault/IAutopoolRegistry.sol"; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { ISwapRouter } from "src/interfaces/swapper/ISwapRouter.sol"; import { ICurveResolver } from "src/interfaces/utils/ICurveResolver.sol"; import { IAutopilotRouter } from "src/interfaces/vault/IAutopilotRouter.sol"; import { IAutopoolFactory } from "src/interfaces/vault/IAutopoolFactory.sol"; import { ISystemSecurity } from "src/interfaces/security/ISystemSecurity.sol"; import { IDestinationRegistry } from "src/interfaces/destinations/IDestinationRegistry.sol"; import { IRootPriceOracle } from "src/interfaces/oracles/IRootPriceOracle.sol"; import { IDestinationVaultRegistry } from "src/interfaces/vault/IDestinationVaultRegistry.sol"; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { IStatsCalculatorRegistry } from "src/interfaces/stats/IStatsCalculatorRegistry.sol"; import { IAsyncSwapperRegistry } from "src/interfaces/liquidation/IAsyncSwapperRegistry.sol"; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IIncentivesPricingStats } from "src/interfaces/stats/IIncentivesPricingStats.sol"; import { IMessageProxy } from "src/interfaces/messageProxy/IMessageProxy.sol"; /// @notice Root most registry contract for the system interface ISystemRegistry { /// @notice Get the TOKE contract for the system /// @return toke instance of TOKE used in the system function toke() external view returns (IERC20Metadata); /// @notice Get the referenced WETH contract for the system /// @return weth contract pointer function weth() external view returns (IWETH9); /// @notice Get the AccToke staking contract /// @return accToke instance of the accToke contract for the system function accToke() external view returns (IAccToke); /// @notice Get the AutopoolRegistry for this system /// @return registry instance of the registry for this system function autoPoolRegistry() external view returns (IAutopoolRegistry registry); /// @notice Get the destination Vault registry for this system /// @return registry instance of the registry for this system function destinationVaultRegistry() external view returns (IDestinationVaultRegistry registry); /// @notice Get the access Controller for this system /// @return controller instance of the access controller for this system function accessController() external view returns (IAccessController controller); /// @notice Get the destination template registry for this system /// @return registry instance of the registry for this system function destinationTemplateRegistry() external view returns (IDestinationRegistry registry); /// @notice Auto Pilot Router /// @return router instance of the system function autoPoolRouter() external view returns (IAutopilotRouter router); /// @notice Vault factory lookup by type /// @return vaultFactory instance of the vault factory for this vault type function getAutopoolFactoryByType(bytes32 vaultType) external view returns (IAutopoolFactory vaultFactory); /// @notice Get the stats calculator registry for this system /// @return registry instance of the registry for this system function statsCalculatorRegistry() external view returns (IStatsCalculatorRegistry registry); /// @notice Get the root price oracle for this system /// @return oracle instance of the root price oracle for this system function rootPriceOracle() external view returns (IRootPriceOracle oracle); /// @notice Get the async swapper registry for this system /// @return registry instance of the registry for this system function asyncSwapperRegistry() external view returns (IAsyncSwapperRegistry registry); /// @notice Get the swap router for this system /// @return router instance of the swap router for this system function swapRouter() external view returns (ISwapRouter router); /// @notice Get the curve resolver for this system /// @return resolver instance of the curve resolver for this system function curveResolver() external view returns (ICurveResolver resolver); /// @notice Verify if given address is registered as Reward Token /// @param rewardToken token address to verify /// @return bool that indicates true if token is registered and false if not function isRewardToken(address rewardToken) external view returns (bool); /// @notice Get the system security instance for this system /// @return security instance of system security for this system function systemSecurity() external view returns (ISystemSecurity security); /// @notice Get the Incentive Pricing Stats /// @return incentivePricing the incentive pricing contract function incentivePricing() external view returns (IIncentivesPricingStats); /// @notice Get the Messagy Proxy /// @return Message proxy contract function messageProxy() external view returns (IMessageProxy); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { Errors } from "src/utils/Errors.sol"; contract SecurityBase { IAccessController public immutable accessController; error UndefinedAddress(); constructor(address _accessController) { if (_accessController == address(0)) revert UndefinedAddress(); accessController = IAccessController(_accessController); } modifier onlyOwner() { accessController.verifyOwner(msg.sender); _; } modifier hasRole(bytes32 role) { if (!accessController.hasRole(role, msg.sender)) revert Errors.AccessDenied(); _; } /////////////////////////////////////////////////////////////////// // // Forward all the regular methods to central security module // /////////////////////////////////////////////////////////////////// function _hasRole(bytes32 role, address account) internal view returns (bool) { return accessController.hasRole(role, account); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { Address } from "openzeppelin-contracts/utils/Address.sol"; library Errors { using Address for address; /////////////////////////////////////////////////////////////////// // Set errors /////////////////////////////////////////////////////////////////// error AccessDenied(); error ZeroAddress(string paramName); error ZeroAmount(); error InsufficientBalance(address token); error AssetNotAllowed(address token); error NotImplemented(); error InvalidAddress(address addr); error InvalidParam(string paramName); error InvalidParams(); error UnsafePrice(address token, uint256 spotPrice, uint256 safePrice); error AlreadySet(string param); error AlreadyRegistered(address param); error SlippageExceeded(uint256 expected, uint256 actual); error ArrayLengthMismatch(uint256 length1, uint256 length2, string details); error ItemNotFound(); error ItemExists(); error MissingRole(bytes32 role, address user); error RegistryItemMissing(string item); error NotRegistered(); // Used to check storage slot is empty before setting. error MustBeZero(); // Used to check storage slot set before deleting. error MustBeSet(); error ApprovalFailed(address token); error FlashLoanFailed(address token, uint256 amount); error SystemMismatch(address source1, address source2); error InvalidToken(address token); error UnreachableError(); error InvalidSigner(address signer); error InvalidChainId(uint256 chainId); error SenderMismatch(address recipient, address sender); function verifyNotZero(address addr, string memory paramName) internal pure { if (addr == address(0)) { revert ZeroAddress(paramName); } } function verifyNotZero(bytes32 key, string memory paramName) internal pure { if (key == bytes32(0)) { revert InvalidParam(paramName); } } function verifyNotEmpty(string memory val, string memory paramName) internal pure { if (bytes(val).length == 0) { revert InvalidParam(paramName); } } function verifyNotZero(uint256 num, string memory paramName) internal pure { if (num == 0) { revert InvalidParam(paramName); } } function verifySystemsMatch(address component1, address component2) internal view { bytes memory call = abi.encodeWithSignature("getSystemRegistry()"); address registry1 = abi.decode(component1.functionStaticCall(call), (address)); address registry2 = abi.decode(component2.functionStaticCall(call), (address)); if (registry1 != registry2) { revert SystemMismatch(component1, component2); } } function verifyArrayLengths(uint256 length1, uint256 length2, string memory details) internal pure { if (length1 != length2) { revert ArrayLengthMismatch(length1, length2, details); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISystemComponent } from "src/interfaces/ISystemComponent.sol"; import { ISystemRegistry } from "src/interfaces/ISystemRegistry.sol"; import { Errors } from "src/utils/Errors.sol"; contract SystemComponent is ISystemComponent { ISystemRegistry internal immutable systemRegistry; constructor(ISystemRegistry _systemRegistry) { Errors.verifyNotZero(address(_systemRegistry), "_systemRegistry"); systemRegistry = _systemRegistry; } /// @inheritdoc ISystemComponent function getSystemRegistry() external view returns (address) { return address(systemRegistry); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; library Roles { // -------------------------------------------------------------------- // Central roles list used by all contracts that call AccessController // -------------------------------------------------------------------- // TODO: Update the hash values to match the variable names for new deployments. // Naming Conventions: // - Use MANAGER, CREATOR, UPDATER, ..., for roles primarily managing on-chain activities. // - Use EXECUTOR for roles that trigger off-chain initiated actions. // - Group roles by functional area for clarity. // -------------------------------------------------------------------- // Destination Vault Management bytes32 public constant DESTINATION_VAULT_FACTORY_MANAGER = keccak256("CREATE_DESTINATION_VAULT_ROLE"); bytes32 public constant DESTINATION_VAULT_REGISTRY_MANAGER = keccak256("DESTINATION_VAULT_REGISTRY_MANAGER"); bytes32 public constant DESTINATION_VAULT_MANAGER = keccak256("DESTINATION_VAULT_MANAGER"); // Auto Pool Factory and Registry Management bytes32 public constant AUTO_POOL_REGISTRY_UPDATER = keccak256("REGISTRY_UPDATER"); bytes32 public constant AUTO_POOL_FACTORY_MANAGER = 0x00; // keccak256("LMP_VAULT_FACTORY_MANAGER"); bytes32 public constant AUTO_POOL_FACTORY_VAULT_CREATOR = keccak256("CREATE_POOL_ROLE"); // Auto Pool Management bytes32 public constant AUTO_POOL_DESTINATION_UPDATER = keccak256("DESTINATION_VAULTS_UPDATER"); bytes32 public constant AUTO_POOL_FEE_UPDATER = keccak256("AUTO_POOL_FEE_SETTER_ROLE"); bytes32 public constant AUTO_POOL_PERIODIC_FEE_UPDATER = keccak256("AUTO_POOL_PERIODIC_FEE_SETTER_ROLE"); bytes32 public constant AUTO_POOL_REWARD_MANAGER = keccak256("AUTO_POOL_REWARD_MANAGER_ROLE"); bytes32 public constant AUTO_POOL_MANAGER = keccak256("AUTO_POOL_ADMIN"); bytes32 public constant REBALANCER = keccak256("REBALANCER_ROLE"); // Reward Management bytes32 public constant LIQUIDATOR_MANAGER = keccak256("LIQUIDATOR_ROLE"); bytes32 public constant DV_REWARD_MANAGER = keccak256("DV_REWARD_MANAGER_ROLE"); bytes32 public constant REWARD_LIQUIDATION_MANAGER = keccak256("REWARD_LIQUIDATION_MANAGER"); bytes32 public constant EXTRA_REWARD_MANAGER = keccak256("EXTRA_REWARD_MANAGER_ROLE"); bytes32 public constant REWARD_LIQUIDATION_EXECUTOR = keccak256("REWARD_LIQUIDATION_EXECUTOR"); // Statistics and Reporting bytes32 public constant STATS_CALC_REGISTRY_MANAGER = 0x00; // keccak256("STATS_CALC_REGISTRY_MANAGER"); bytes32 public constant STATS_CALC_FACTORY_MANAGER = keccak256("CREATE_STATS_CALC_ROLE"); bytes32 public constant STATS_CALC_FACTORY_TEMPLATE_MANAGER = keccak256("STATS_CALC_TEMPLATE_MGMT_ROLE"); bytes32 public constant STATS_SNAPSHOT_EXECUTOR = keccak256("STATS_SNAPSHOT_ROLE"); bytes32 public constant STATS_INCENTIVE_TOKEN_UPDATER = keccak256("STATS_INCENTIVE_TOKEN_UPDATER"); bytes32 public constant STATS_GENERAL_MANAGER = keccak256("STATS_GENERAL_MANAGER"); // Emergency Management bytes32 public constant EMERGENCY_PAUSER = keccak256("EMERGENCY_PAUSER"); // Miscellaneous Roles bytes32 public constant SOLVER = keccak256("SOLVER_ROLE"); bytes32 public constant AUTO_POOL_REPORTING_EXECUTOR = keccak256("AUTO_POOL_UPDATE_DEBT_REPORTING_ROLE"); // Swapper Roles bytes32 public constant SWAP_ROUTER_MANAGER = 0x00; // keccak256("SWAP_ROUTER_MANAGER"); // Price Oracles Roles bytes32 public constant ORACLE_MANAGER = keccak256("ORACLE_MANAGER_ROLE"); bytes32 public constant CUSTOM_ORACLE_EXECUTOR = keccak256("CUSTOM_ORACLE_EXECUTOR"); bytes32 public constant MAVERICK_FEE_ORACLE_EXECUTOR = keccak256("MAVERICK_FEE_ORACLE_MANAGER"); // AccToke Roles bytes32 public constant ACC_TOKE_MANAGER = keccak256("ACC_TOKE_MANAGER"); // Admin Roles bytes32 public constant TOKEN_RECOVERY_MANAGER = keccak256("TOKEN_RECOVERY_ROLE"); // Message Proxy Roles bytes32 public constant MESSAGE_PROXY_MANAGER = keccak256("MESSAGE_PROXY_MANAGER"); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol) pragma solidity ^0.8.0; /** * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts. * * _Available since v4.5._ */ interface IVotes { /** * @dev Emitted when an account changes their delegate. */ event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /** * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes. */ event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance); /** * @dev Returns the current amount of votes that `account` has. */ function getVotes(address account) external view returns (uint256); /** * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`). */ function getPastVotes(address account, uint256 blockNumber) external view returns (uint256); /** * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`). * * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes. * Votes that have not been delegated are still part of total supply, even though they would not participate in a * vote. */ function getPastTotalSupply(uint256 blockNumber) external view returns (uint256); /** * @dev Returns the delegate that `account` has chosen. */ function delegates(address account) external view returns (address); /** * @dev Delegates votes from the sender to `delegatee`. */ function delegate(address delegatee) external; /** * @dev Delegates votes from signer to `delegatee`. */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; import "../Strings.sol"; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol) pragma solidity ^0.8.0; import "./ECDSA.sol"; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; address private immutable _CACHED_THIS; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion); _CACHED_THIS = address(this); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 nameHash, bytes32 versionHash ) private view returns (bytes32) { return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } }
// SPDX-License-Identifier: Unlicense pragma solidity >=0.8.4; /// @notice Emitted when the result overflows uint256. error PRBMath__MulDivFixedPointOverflow(uint256 prod1); /// @notice Emitted when the result overflows uint256. error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator); /// @notice Emitted when one of the inputs is type(int256).min. error PRBMath__MulDivSignedInputTooSmall(); /// @notice Emitted when the intermediary absolute result overflows int256. error PRBMath__MulDivSignedOverflow(uint256 rAbs); /// @notice Emitted when the input is MIN_SD59x18. error PRBMathSD59x18__AbsInputTooSmall(); /// @notice Emitted when ceiling a number overflows SD59x18. error PRBMathSD59x18__CeilOverflow(int256 x); /// @notice Emitted when one of the inputs is MIN_SD59x18. error PRBMathSD59x18__DivInputTooSmall(); /// @notice Emitted when one of the intermediary unsigned results overflows SD59x18. error PRBMathSD59x18__DivOverflow(uint256 rAbs); /// @notice Emitted when the input is greater than 133.084258667509499441. error PRBMathSD59x18__ExpInputTooBig(int256 x); /// @notice Emitted when the input is greater than 192. error PRBMathSD59x18__Exp2InputTooBig(int256 x); /// @notice Emitted when flooring a number underflows SD59x18. error PRBMathSD59x18__FloorUnderflow(int256 x); /// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18. error PRBMathSD59x18__FromIntOverflow(int256 x); /// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18. error PRBMathSD59x18__FromIntUnderflow(int256 x); /// @notice Emitted when the product of the inputs is negative. error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y); /// @notice Emitted when multiplying the inputs overflows SD59x18. error PRBMathSD59x18__GmOverflow(int256 x, int256 y); /// @notice Emitted when the input is less than or equal to zero. error PRBMathSD59x18__LogInputTooSmall(int256 x); /// @notice Emitted when one of the inputs is MIN_SD59x18. error PRBMathSD59x18__MulInputTooSmall(); /// @notice Emitted when the intermediary absolute result overflows SD59x18. error PRBMathSD59x18__MulOverflow(uint256 rAbs); /// @notice Emitted when the intermediary absolute result overflows SD59x18. error PRBMathSD59x18__PowuOverflow(uint256 rAbs); /// @notice Emitted when the input is negative. error PRBMathSD59x18__SqrtNegativeInput(int256 x); /// @notice Emitted when the calculating the square root overflows SD59x18. error PRBMathSD59x18__SqrtOverflow(int256 x); /// @notice Emitted when addition overflows UD60x18. error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y); /// @notice Emitted when ceiling a number overflows UD60x18. error PRBMathUD60x18__CeilOverflow(uint256 x); /// @notice Emitted when the input is greater than 133.084258667509499441. error PRBMathUD60x18__ExpInputTooBig(uint256 x); /// @notice Emitted when the input is greater than 192. error PRBMathUD60x18__Exp2InputTooBig(uint256 x); /// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18. error PRBMathUD60x18__FromUintOverflow(uint256 x); /// @notice Emitted when multiplying the inputs overflows UD60x18. error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y); /// @notice Emitted when the input is less than 1. error PRBMathUD60x18__LogInputTooSmall(uint256 x); /// @notice Emitted when the calculating the square root overflows UD60x18. error PRBMathUD60x18__SqrtOverflow(uint256 x); /// @notice Emitted when subtraction underflows UD60x18. error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y); /// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library /// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point /// representation. When it does not, it is explicitly mentioned in the NatSpec documentation. library PRBMath { /// STRUCTS /// struct SD59x18 { int256 value; } struct UD60x18 { uint256 value; } /// STORAGE /// /// @dev How many trailing decimals can be represented. uint256 internal constant SCALE = 1e18; /// @dev Largest power of two divisor of SCALE. uint256 internal constant SCALE_LPOTD = 262144; /// @dev SCALE inverted mod 2^256. uint256 internal constant SCALE_INVERSE = 78156646155174841979727994598816262306175212592076161876661_508869554232690281; /// FUNCTIONS /// /// @notice Calculates the binary exponent of x using the binary fraction method. /// @dev Has to use 192.64-bit fixed-point numbers. /// See https://ethereum.stackexchange.com/a/96594/24693. /// @param x The exponent as an unsigned 192.64-bit fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function exp2(uint256 x) internal pure returns (uint256 result) { unchecked { // Start from 0.5 in the 192.64-bit fixed-point format. result = 0x800000000000000000000000000000000000000000000000; // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows // because the initial result is 2^191 and all magic factors are less than 2^65. if (x & 0x8000000000000000 > 0) { result = (result * 0x16A09E667F3BCC909) >> 64; } if (x & 0x4000000000000000 > 0) { result = (result * 0x1306FE0A31B7152DF) >> 64; } if (x & 0x2000000000000000 > 0) { result = (result * 0x1172B83C7D517ADCE) >> 64; } if (x & 0x1000000000000000 > 0) { result = (result * 0x10B5586CF9890F62A) >> 64; } if (x & 0x800000000000000 > 0) { result = (result * 0x1059B0D31585743AE) >> 64; } if (x & 0x400000000000000 > 0) { result = (result * 0x102C9A3E778060EE7) >> 64; } if (x & 0x200000000000000 > 0) { result = (result * 0x10163DA9FB33356D8) >> 64; } if (x & 0x100000000000000 > 0) { result = (result * 0x100B1AFA5ABCBED61) >> 64; } if (x & 0x80000000000000 > 0) { result = (result * 0x10058C86DA1C09EA2) >> 64; } if (x & 0x40000000000000 > 0) { result = (result * 0x1002C605E2E8CEC50) >> 64; } if (x & 0x20000000000000 > 0) { result = (result * 0x100162F3904051FA1) >> 64; } if (x & 0x10000000000000 > 0) { result = (result * 0x1000B175EFFDC76BA) >> 64; } if (x & 0x8000000000000 > 0) { result = (result * 0x100058BA01FB9F96D) >> 64; } if (x & 0x4000000000000 > 0) { result = (result * 0x10002C5CC37DA9492) >> 64; } if (x & 0x2000000000000 > 0) { result = (result * 0x1000162E525EE0547) >> 64; } if (x & 0x1000000000000 > 0) { result = (result * 0x10000B17255775C04) >> 64; } if (x & 0x800000000000 > 0) { result = (result * 0x1000058B91B5BC9AE) >> 64; } if (x & 0x400000000000 > 0) { result = (result * 0x100002C5C89D5EC6D) >> 64; } if (x & 0x200000000000 > 0) { result = (result * 0x10000162E43F4F831) >> 64; } if (x & 0x100000000000 > 0) { result = (result * 0x100000B1721BCFC9A) >> 64; } if (x & 0x80000000000 > 0) { result = (result * 0x10000058B90CF1E6E) >> 64; } if (x & 0x40000000000 > 0) { result = (result * 0x1000002C5C863B73F) >> 64; } if (x & 0x20000000000 > 0) { result = (result * 0x100000162E430E5A2) >> 64; } if (x & 0x10000000000 > 0) { result = (result * 0x1000000B172183551) >> 64; } if (x & 0x8000000000 > 0) { result = (result * 0x100000058B90C0B49) >> 64; } if (x & 0x4000000000 > 0) { result = (result * 0x10000002C5C8601CC) >> 64; } if (x & 0x2000000000 > 0) { result = (result * 0x1000000162E42FFF0) >> 64; } if (x & 0x1000000000 > 0) { result = (result * 0x10000000B17217FBB) >> 64; } if (x & 0x800000000 > 0) { result = (result * 0x1000000058B90BFCE) >> 64; } if (x & 0x400000000 > 0) { result = (result * 0x100000002C5C85FE3) >> 64; } if (x & 0x200000000 > 0) { result = (result * 0x10000000162E42FF1) >> 64; } if (x & 0x100000000 > 0) { result = (result * 0x100000000B17217F8) >> 64; } if (x & 0x80000000 > 0) { result = (result * 0x10000000058B90BFC) >> 64; } if (x & 0x40000000 > 0) { result = (result * 0x1000000002C5C85FE) >> 64; } if (x & 0x20000000 > 0) { result = (result * 0x100000000162E42FF) >> 64; } if (x & 0x10000000 > 0) { result = (result * 0x1000000000B17217F) >> 64; } if (x & 0x8000000 > 0) { result = (result * 0x100000000058B90C0) >> 64; } if (x & 0x4000000 > 0) { result = (result * 0x10000000002C5C860) >> 64; } if (x & 0x2000000 > 0) { result = (result * 0x1000000000162E430) >> 64; } if (x & 0x1000000 > 0) { result = (result * 0x10000000000B17218) >> 64; } if (x & 0x800000 > 0) { result = (result * 0x1000000000058B90C) >> 64; } if (x & 0x400000 > 0) { result = (result * 0x100000000002C5C86) >> 64; } if (x & 0x200000 > 0) { result = (result * 0x10000000000162E43) >> 64; } if (x & 0x100000 > 0) { result = (result * 0x100000000000B1721) >> 64; } if (x & 0x80000 > 0) { result = (result * 0x10000000000058B91) >> 64; } if (x & 0x40000 > 0) { result = (result * 0x1000000000002C5C8) >> 64; } if (x & 0x20000 > 0) { result = (result * 0x100000000000162E4) >> 64; } if (x & 0x10000 > 0) { result = (result * 0x1000000000000B172) >> 64; } if (x & 0x8000 > 0) { result = (result * 0x100000000000058B9) >> 64; } if (x & 0x4000 > 0) { result = (result * 0x10000000000002C5D) >> 64; } if (x & 0x2000 > 0) { result = (result * 0x1000000000000162E) >> 64; } if (x & 0x1000 > 0) { result = (result * 0x10000000000000B17) >> 64; } if (x & 0x800 > 0) { result = (result * 0x1000000000000058C) >> 64; } if (x & 0x400 > 0) { result = (result * 0x100000000000002C6) >> 64; } if (x & 0x200 > 0) { result = (result * 0x10000000000000163) >> 64; } if (x & 0x100 > 0) { result = (result * 0x100000000000000B1) >> 64; } if (x & 0x80 > 0) { result = (result * 0x10000000000000059) >> 64; } if (x & 0x40 > 0) { result = (result * 0x1000000000000002C) >> 64; } if (x & 0x20 > 0) { result = (result * 0x10000000000000016) >> 64; } if (x & 0x10 > 0) { result = (result * 0x1000000000000000B) >> 64; } if (x & 0x8 > 0) { result = (result * 0x10000000000000006) >> 64; } if (x & 0x4 > 0) { result = (result * 0x10000000000000003) >> 64; } if (x & 0x2 > 0) { result = (result * 0x10000000000000001) >> 64; } if (x & 0x1 > 0) { result = (result * 0x10000000000000001) >> 64; } // We're doing two things at the same time: // // 1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for // the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191 // rather than 192. // 2. Convert the result to the unsigned 60.18-decimal fixed-point format. // // This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n". result *= SCALE; result >>= (191 - (x >> 64)); } } /// @notice Finds the zero-based index of the first one in the binary representation of x. /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set /// @param x The uint256 number for which to find the index of the most significant bit. /// @return msb The index of the most significant bit as an uint256. function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) { if (x >= 2**128) { x >>= 128; msb += 128; } if (x >= 2**64) { x >>= 64; msb += 64; } if (x >= 2**32) { x >>= 32; msb += 32; } if (x >= 2**16) { x >>= 16; msb += 16; } if (x >= 2**8) { x >>= 8; msb += 8; } if (x >= 2**4) { x >>= 4; msb += 4; } if (x >= 2**2) { x >>= 2; msb += 2; } if (x >= 2**1) { // No need to shift x any more. msb += 1; } } /// @notice Calculates floor(x*y÷denominator) with full precision. /// /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv. /// /// Requirements: /// - The denominator cannot be zero. /// - The result must fit within uint256. /// /// Caveats: /// - This function does not work with fixed-point numbers. /// /// @param x The multiplicand as an uint256. /// @param y The multiplier as an uint256. /// @param denominator The divisor as an uint256. /// @return result The result as an uint256. function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { // 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) { unchecked { result = prod0 / denominator; } return result; } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (prod1 >= denominator) { revert PRBMath__MulDivOverflow(prod1, denominator); } /////////////////////////////////////////////// // 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. unchecked { // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 lpotdod = denominator & (~denominator + 1); assembly { // Divide denominator by lpotdod. denominator := div(denominator, lpotdod) // Divide [prod1 prod0] by lpotdod. prod0 := div(prod0, lpotdod) // Flip lpotdod such that it is 2^256 / lpotdod. If lpotdod is zero, then it becomes one. lpotdod := add(div(sub(0, lpotdod), lpotdod), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * lpotdod; // 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 floor(x*y÷1e18) with full precision. /// /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of /// being rounded to 1e-18. See "Listing 6" and text above it at https://accu.org/index.php/journals/1717. /// /// Requirements: /// - The result must fit within uint256. /// /// Caveats: /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works. /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations: /// 1. x * y = type(uint256).max * SCALE /// 2. (x * y) % SCALE >= SCALE / 2 /// /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number. /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) { uint256 prod0; uint256 prod1; assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } if (prod1 >= SCALE) { revert PRBMath__MulDivFixedPointOverflow(prod1); } uint256 remainder; uint256 roundUpUnit; assembly { remainder := mulmod(x, y, SCALE) roundUpUnit := gt(remainder, 499999999999999999) } if (prod1 == 0) { unchecked { result = (prod0 / SCALE) + roundUpUnit; return result; } } assembly { result := add( mul( or( div(sub(prod0, remainder), SCALE_LPOTD), mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1)) ), SCALE_INVERSE ), roundUpUnit ) } } /// @notice Calculates floor(x*y÷denominator) with full precision. /// /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately. /// /// Requirements: /// - None of the inputs can be type(int256).min. /// - The result must fit within int256. /// /// @param x The multiplicand as an int256. /// @param y The multiplier as an int256. /// @param denominator The divisor as an int256. /// @return result The result as an int256. function mulDivSigned( int256 x, int256 y, int256 denominator ) internal pure returns (int256 result) { if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) { revert PRBMath__MulDivSignedInputTooSmall(); } // Get hold of the absolute values of x, y and the denominator. uint256 ax; uint256 ay; uint256 ad; unchecked { ax = x < 0 ? uint256(-x) : uint256(x); ay = y < 0 ? uint256(-y) : uint256(y); ad = denominator < 0 ? uint256(-denominator) : uint256(denominator); } // Compute the absolute value of (x*y)÷denominator. The result must fit within int256. uint256 rAbs = mulDiv(ax, ay, ad); if (rAbs > uint256(type(int256).max)) { revert PRBMath__MulDivSignedOverflow(rAbs); } // Get the signs of x, y and the denominator. uint256 sx; uint256 sy; uint256 sd; assembly { sx := sgt(x, sub(0, 1)) sy := sgt(y, sub(0, 1)) sd := sgt(denominator, sub(0, 1)) } // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs. // If yes, the result should be negative. result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs); } /// @notice Calculates the square root of x, rounding down. /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. /// /// Caveats: /// - This function does not work with fixed-point numbers. /// /// @param x The uint256 number for which to calculate the square root. /// @return result The result as an uint256. function sqrt(uint256 x) internal pure returns (uint256 result) { if (x == 0) { return 0; } // Set the initial guess to the least power of two that is greater than or equal to sqrt(x). uint256 xAux = uint256(x); result = 1; if (xAux >= 0x100000000000000000000000000000000) { xAux >>= 128; result <<= 64; } if (xAux >= 0x10000000000000000) { xAux >>= 64; result <<= 32; } if (xAux >= 0x100000000) { xAux >>= 32; result <<= 16; } if (xAux >= 0x10000) { xAux >>= 16; result <<= 8; } if (xAux >= 0x100) { xAux >>= 8; result <<= 4; } if (xAux >= 0x10) { xAux >>= 4; result <<= 2; } if (xAux >= 0x8) { result <<= 1; } // The operations can never overflow because the result is max 2^127 when it enters this block. unchecked { result = (result + x / result) >> 1; result = (result + x / result) >> 1; result = (result + x / result) >> 1; result = (result + x / result) >> 1; result = (result + x / result) >> 1; result = (result + x / result) >> 1; result = (result + x / result) >> 1; // Seven iterations should be enough uint256 roundedDownResult = x / result; return result >= roundedDownResult ? roundedDownResult : result; } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Keep track of Vaults created through the Vault Factory interface IAutopoolRegistry { /////////////////////////////////////////////////////////////////// // Errors /////////////////////////////////////////////////////////////////// error VaultNotFound(address vaultAddress); error VaultAlreadyExists(address vaultAddress); /////////////////////////////////////////////////////////////////// // Events /////////////////////////////////////////////////////////////////// event VaultAdded(address indexed asset, address indexed vault); event VaultRemoved(address indexed asset, address indexed vault); /////////////////////////////////////////////////////////////////// // Functions /////////////////////////////////////////////////////////////////// /// @notice Checks if an address is a valid vault /// @param vaultAddress Vault address to be added function isVault(address vaultAddress) external view returns (bool); /// @notice Registers a vault /// @param vaultAddress Vault address to be added function addVault(address vaultAddress) external; /// @notice Removes vault registration /// @param vaultAddress Vault address to be removed function removeVault(address vaultAddress) external; /// @notice Returns a list of all registered vaults function listVaults() external view returns (address[] memory); /// @notice Returns a list of all registered vaults for a given asset /// @param asset Asset address function listVaultsForAsset(address asset) external view returns (address[] memory); /// @notice Returns a list of all registered vaults for a given type /// @param _vaultType Vault type function listVaultsForType(bytes32 _vaultType) external view returns (address[] memory); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAccessControlEnumerable } from "openzeppelin-contracts/access/IAccessControlEnumerable.sol"; interface IAccessController is IAccessControlEnumerable { error AccessDenied(); /** * @notice Setup a role for an account * @param role The role to setup * @param account The account to setup the role for */ function setupRole(bytes32 role, address account) external; /** * @notice Verify if an account is an owner. Reverts if not * @param account The account to verify */ function verifyOwner(address account) external view; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISyncSwapper } from "src/interfaces/swapper/ISyncSwapper.sol"; interface ISwapRouter { struct SwapData { address token; address pool; ISyncSwapper swapper; bytes data; } error MaxSlippageExceeded(); error SwapRouteLookupFailed(address from, address to); error SwapFailed(); event SwapRouteSet(address indexed token, SwapData[] routes); event SwapForQuoteSuccessful( address indexed assetToken, uint256 sellAmount, address indexed quoteToken, uint256 minBuyAmount, uint256 buyAmount ); /** * @notice Sets a new swap route for a given asset token. * @param assetToken The asset token for which the swap route is being set. * @param _swapRoute The new swap route as an array of SwapData. The last element represents the quoteToken. * @dev Each 'hop' in the swap route is validated using the respective swapper's validate function. The validate * function ensures that the encoded data contains the correct 'fromAddress' and 'toAddress' (swapData.token), and * verifies that these tokens are in the pool. */ function setSwapRoute(address assetToken, SwapData[] calldata _swapRoute) external; /** * @notice Swaps the asset token for the quote token. * @dev We're adopting an "exact in, variable out" model for all our swaps. This ensures that the entire sellAmount * is used, eliminating the need for additional balance checks and refunds. This model is expected to be followed by * all swapper implementations to maintain consistency and to optimize for gas efficiency. * @param assetToken The address of the asset token to swap. * @param sellAmount The exact amount of the asset token to swap. * @param quoteToken The address of the quote token. * @param minBuyAmount The minimum amount of the quote token expected to be received from the swap. * @return The amount received from the swap. */ function swapForQuote( address assetToken, uint256 sellAmount, address quoteToken, uint256 minBuyAmount ) external returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface ICurveResolver { /// @notice Resolve details of a Curve pool regardless of type or version /// @dev This resolves tokens without unwrapping to underlying in the case of meta pools. /// @param poolAddress pool address to lookup /// @return tokens tokens that make up the pool /// @return numTokens the number of tokens. tokens are not unwrapped. /// @return isStableSwap is this a StableSwap pool. false = CryptoSwap function resolve(address poolAddress) external view returns (address[8] memory tokens, uint256 numTokens, bool isStableSwap); /// @notice Resolve details of a Curve pool regardless of type or version /// @dev This resolves tokens without unwrapping to underlying in the case of meta pools. /// @dev Use the isStableSwap value to differentiate between StableSwap (V1) and CryptoSwap (V2) pools. /// @param poolAddress pool address to lookup /// @return tokens tokens that make up the pool /// @return numTokens the number of tokens. tokens are not unwrapped /// @return lpToken lp token of the pool /// @return isStableSwap is this a StableSwap pool. false = CryptoSwap function resolveWithLpToken(address poolAddress) external view returns (address[8] memory tokens, uint256 numTokens, address lpToken, bool isStableSwap); /// @notice Get the lp token of a Curve pool /// @param poolAddress pool address to lookup function getLpToken(address poolAddress) external view returns (address); /// @notice Get the reserves of a Curve pools' tokens /// @dev Actual balances length might differ from 8 and should be verified by the caller /// @param poolAddress pool address to lookup /// @return balances reserves of the pool tokens function getReservesInfo(address poolAddress) external view returns (uint256[8] memory balances); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IAutopilotRouterBase } from "src/interfaces/vault/IAutopilotRouterBase.sol"; import { IRewards } from "src/interfaces/rewarders/IRewards.sol"; import { SwapParams } from "src/interfaces/liquidation/IAsyncSwapper.sol"; /** * @title IAutopilotRouter Interface * @notice Extends the IAutopilotRouterBase with specific flows to save gas */ interface IAutopilotRouter is IAutopilotRouterBase { /** * *************************** Deposit ******************************** */ /** * @notice deposit available asset balance to a AutopoolETH. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function depositBalance(IAutopool vault, address to, uint256 minSharesOut) external returns (uint256 sharesOut); /** * @notice deposit max assets to a AutopoolETH. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function depositMax(IAutopool vault, address to, uint256 minSharesOut) external returns (uint256 sharesOut); /** * ************************* Withdraw ********************************** */ /** * @notice withdraw `amount` to a AutopoolETH. * @param fromVault The AutopoolETH to withdraw assets from. * @param toVault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param amount The amount of assets to withdraw from fromVault. * @param maxSharesIn The max amount of fromVault shares withdrawn by caller. * @param minSharesOut The min amount of toVault shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MaxSharesError, MinSharesError */ function withdrawToDeposit( IAutopool fromVault, IAutopool toVault, address to, uint256 amount, uint256 maxSharesIn, uint256 minSharesOut ) external returns (uint256 sharesOut); /** * ************************* Redeem ******************************** */ /** * @notice redeem `shares` to a AutopoolETH. * @param fromVault The AutopoolETH to redeem shares from. * @param toVault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param shares The amount of shares to redeem from fromVault. * @param minSharesOut The min amount of toVault shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinAmountError, MinSharesError */ function redeemToDeposit( IAutopool fromVault, IAutopool toVault, address to, uint256 shares, uint256 minSharesOut ) external returns (uint256 sharesOut); /** * @notice redeem max shares to a AutopoolETH. * @param vault The AutopoolETH to redeem shares from. * @param to The destination of assets. * @param minAmountOut The min amount of assets received by `to`. * @return amountOut the amount of assets received by `to`. * @dev throws MinAmountError */ function redeemMax(IAutopool vault, address to, uint256 minAmountOut) external returns (uint256 amountOut); /** * @notice swaps token * @param swapper Address of the swapper to use * @param swapParams Parameters for the swap * @return amountReceived Swap output amount */ function swapToken(address swapper, SwapParams memory swapParams) external returns (uint256 amountReceived); /** * @notice claims vault token rewards * @param rewarder Address of the rewarder to claim from * @param recipient Struct containing recipient details * @return amountReceived Swap output amount */ function claimRewards( IRewards rewarder, IRewards.Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s ) external returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IAutopoolFactory { /////////////////////////////////////////////////////////////////// // Vault Creation /////////////////////////////////////////////////////////////////// /** * @notice Spin up a new AutopoolETH * @param strategy Strategy template address * @param symbolSuffix Symbol suffix of the new token * @param descPrefix Description prefix of the new token * @param salt Vault creation salt * @param extraParams Any extra data needed for the vault */ function createVault( address strategy, string memory symbolSuffix, string memory descPrefix, bytes32 salt, bytes calldata extraParams ) external payable returns (address newVaultAddress); function addStrategyTemplate(address strategyTemplate) external; function removeStrategyTemplate(address strategyTemplate) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface ISystemSecurity { /// @notice Get the number of NAV/share operations currently in progress /// @return Number of operations function navOpsInProgress() external view returns (uint256); /// @notice Called at the start of any NAV/share changing operation function enterNavOperation() external; /// @notice Called at the end of any NAV/share changing operation function exitNavOperation() external; /// @notice Whether or not the system as a whole is paused function isSystemPaused() external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IDestinationAdapter } from "src/interfaces/destinations/IDestinationAdapter.sol"; interface IDestinationRegistry { event Register(bytes32[] indexed destinationTypes, address[] indexed targets); event Replace(bytes32[] indexed destinationTypes, address[] indexed targets); event Unregister(bytes32[] indexed destinationTypes); event Whitelist(bytes32[] indexed destinationTypes); event RemoveFromWhitelist(bytes32[] indexed destinationTypes); error InvalidAddress(address addr); error NotAllowedDestination(); error DestinationAlreadySet(); /** * @notice Adds a new addresses of the given destination types * @dev Fails if trying to overwrite previous value of the same destination type * @param destinationTypes Ones from the destination type whitelist * @param targets addresses of the deployed DestinationAdapters, cannot be 0 */ function register(bytes32[] calldata destinationTypes, address[] calldata targets) external; /** * @notice Replaces an addresses of the given destination types * @dev Fails if given destination type was not set previously * @param destinationTypes Ones from the destination type whitelist * @param targets addresses of the deployed DestinationAdapters, cannot be 0 */ function replace(bytes32[] calldata destinationTypes, address[] calldata targets) external; /** * @notice Removes an addresses of the given pre-registered destination types * @param destinationTypes Ones from the destination types whitelist */ function unregister(bytes32[] calldata destinationTypes) external; /** * @notice Gives an address of the given destination type * @dev Should revert on missing destination * @param destination One from the destination type whitelist */ function getAdapter(bytes32 destination) external returns (IDestinationAdapter); /** * @notice Adds given destination types to the whitelist * @param destinationTypes Types to whitelist */ function addToWhitelist(bytes32[] calldata destinationTypes) external; /** * @notice Removes given pre-whitelisted destination types * @param destinationTypes Ones from the destination type whitelist */ function removeFromWhitelist(bytes32[] calldata destinationTypes) external; /** * @notice Checks if the given destination type is whitelisted * @param destinationType Type to verify */ function isWhitelistedDestination(bytes32 destinationType) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @notice Retrieve a price for any token used in the system interface IRootPriceOracle { /// @notice Returns a fair price for the provided token in ETH /// @param token token to get the price of /// @return price the price of the token in ETH function getPriceInEth(address token) external returns (uint256 price); /// @notice Returns a spot price for the provided token in ETH, utilizing specified liquidity pool /// @param token token to get the spot price of /// @param pool liquidity pool to be used for price determination /// @return price the spot price of the token in ETH based on the provided pool function getSpotPriceInEth(address token, address pool) external returns (uint256); /// @notice Returns a price for base token in quote token. /// @dev Requires both tokens to be registered. /// @param base Address of base token. /// @param quote Address of quote token. /// @return price Price of the base token in quote token. function getPriceInQuote(address base, address quote) external returns (uint256 price); /// @notice Retrieve the price of LP token based on the reserves /// @param lpToken LP token to get the price of /// @param pool liquidity pool to be used for price determination /// @param quoteToken token to quote the price in function getRangePricesLP( address lpToken, address pool, address quoteToken ) external returns (uint256 spotPriceInQuote, uint256 safePriceInQuote, bool isSpotSafe); /// @notice Returns floor or ceiling price of the supplied lp token in terms of requested quote. /// @dev Floor price: the minimum price among all the spot prices and safe prices of the tokens in the pool. /// Ceiling price: the maximum price among all the spot prices and safe prices of the tokens in the pool. /// @param pool Address of pool to get spot pricing from. /// @param lpToken Address of the lp token to price. /// @param inQuote Address of desired quote token. /// @param ceiling Bool indicating whether to get floor or ceiling price. /// @return floorOrCeilingPerLpToken Floor or ceiling price of the lp token. function getFloorCeilingPrice( address pool, address lpToken, address inQuote, bool ceiling ) external returns (uint256 floorOrCeilingPerLpToken); function getFloorPrice(address, address, address) external returns (uint256 price); function getCeilingPrice(address, address, address) external returns (uint256 price); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IDestinationVaultFactory } from "src/interfaces/vault/IDestinationVaultFactory.sol"; /// @notice Tracks valid Destination Vaults for the system interface IDestinationVaultRegistry { /// @notice Determines if a given address is a valid Destination Vault in the system /// @param destinationVault address to check /// @return True if vault is registered function isRegistered(address destinationVault) external view returns (bool); /// @notice Registers a new Destination Vault /// @dev Should be locked down to only a factory /// @param newDestinationVault Address of the new vault function register(address newDestinationVault) external; /// @notice Checks if an address is a valid Destination Vault and reverts if not /// @param destinationVault Destination Vault address to checked function verifyIsRegistered(address destinationVault) external view; /// @notice Returns a list of all registered vaults function listVaults() external view returns (address[] memory); /// @notice Factory that is allowed to create and registry Destination Vaults function factory() external view returns (IDestinationVaultFactory); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IStatsCalculator } from "src/interfaces/stats/IStatsCalculator.sol"; /// @notice Track stat calculators for this instance of the system interface IStatsCalculatorRegistry { /// @notice Get a registered calculator /// @dev Should revert if missing /// @param aprId key of the calculator to get /// @return calculator instance of the calculator function getCalculator(bytes32 aprId) external view returns (IStatsCalculator calculator); /// @notice Register a new stats calculator /// @param calculator address of the calculator function register(address calculator) external; /// @notice Set the factory that can register calculators /// @param factory address of the factory function setCalculatorFactory(address factory) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IAsyncSwapperRegistry { event SwapperAdded(address indexed item); event SwapperRemoved(address indexed item); /// @notice Registers an item /// @param item Item address to be added function register(address item) external; /// @notice Removes item registration /// @param item Item address to be removed function unregister(address item) external; /// @notice Returns a list of all registered items function list() external view returns (address[] memory); /// @notice Checks if an address is a valid item /// @param item Item address to be checked function isRegistered(address item) external view returns (bool); /// @notice Checks if an address is a valid swapper and reverts if not /// @param item Swapper address to be checked function verifyIsRegistered(address item) external view; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title EWMA pricing for incentive tokens interface IIncentivesPricingStats { event TokenAdded(address indexed token); event TokenRemoved(address indexed token); event TokenSnapshot( address indexed token, uint40 lastSnapshot, uint256 fastFilterPrice, uint256 slowFilterPrice, uint256 initCount, bool initComplete ); error TokenAlreadyRegistered(address token); error TokenNotFound(address token); error IncentiveTokenPriceStale(address token); error TokenSnapshotNotReady(address token); struct TokenSnapshotInfo { uint40 lastSnapshot; bool _initComplete; uint8 _initCount; uint256 _initAcc; uint256 fastFilterPrice; uint256 slowFilterPrice; } /// @notice add a token to snapshot /// @dev the token must be configured in the RootPriceOracle before adding here /// @param token the address of the token to add function setRegisteredToken(address token) external; /// @notice remove a token from being snapshot /// @param token the address of the token to remove function removeRegisteredToken(address token) external; /// @notice get the addresses for all currently registered tokens /// @return tokens all of the registered token addresses function getRegisteredTokens() external view returns (address[] memory tokens); /// @notice get all of the registered tokens with the latest snapshot info /// @return tokenAddresses token addresses in the same order as info /// @return info a list of snapshot info for the tokens function getTokenPricingInfo() external view returns (address[] memory tokenAddresses, TokenSnapshotInfo[] memory info); /// @notice update the snapshot for the specified tokens /// @dev if a token is not ready to be snapshot the entire call will fail function snapshot(address[] calldata tokensToSnapshot) external; /// @notice get the latest prices for an incentive token. Reverts if token is not registered /// @return fastPrice the price based on the faster filter (weighted toward current prices) /// @return slowPrice the price based on the slower filter (weighted toward older prices, relative to fast) function getPrice(address token, uint40 staleCheck) external view returns (uint256 fastPrice, uint256 slowPrice); /// @notice get the latest prices for an incentive token or zero if the token is not registered /// @return fastPrice the price based on the faster filter (weighted toward current prices) /// @return slowPrice the price based on the slower filter (weighted toward older prices, relative to fast) function getPriceOrZero( address token, uint40 staleCheck ) external view returns (uint256 fastPrice, uint256 slowPrice); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Send messages to our systems on other chains interface IMessageProxy { function sendMessage(bytes32 messageType, bytes memory message) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @notice Stores a reference to the registry for this system interface ISystemComponent { /// @notice The system instance this contract is tied to function getSystemRegistry() external view returns (address registry); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISwapRouter } from "src/interfaces/swapper/ISwapRouter.sol"; interface ISyncSwapper { error DataMismatch(string element); error InvalidIndex(); /** * @notice Swaps sellToken for buyToken * @param pool The address of the pool for the swapper * @param sellTokenAddress The address of the token to sell * @param sellAmount The amount of sellToken to sell * @param buyTokenAddress The address of the token to buy * @param minBuyAmount The minimum amount of buyToken expected * @param data Additional data used differently by the different swappers * @return actualBuyAmount The actual amount received from the swap */ function swap( address pool, address sellTokenAddress, uint256 sellAmount, address buyTokenAddress, uint256 minBuyAmount, bytes memory data ) external returns (uint256 actualBuyAmount); /** * @notice Validates that the swapData contains the correct information, ensuring that the encoded data contains the * correct 'fromAddress' and 'toAddress' (swapData.token), and verifies that these tokens are in the pool * @dev This function should revert with a DataMismatch error if the swapData is invalid * @param fromAddress The address from which the swap originates * @param swapData The data associated with the swap that needs to be validated */ function validate(address fromAddress, ISwapRouter.SwapData memory swapData) external view; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { AutopoolDebt } from "src/vault/libs/AutopoolDebt.sol"; import { IERC4626 } from "src/interfaces/vault/IERC4626.sol"; import { Math } from "openzeppelin-contracts/utils/math/Math.sol"; import { IAutopoolStrategy } from "src/interfaces/strategy/IAutopoolStrategy.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IERC20Permit } from "openzeppelin-contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; interface IAutopool is IERC4626, IERC20Permit { enum VaultShutdownStatus { Active, Deprecated, Exploit } /// @param unlockPeriodInSeconds Time it takes for profit to unlock in seconds /// @param fullProfitUnlockTime Time at which all profit will have been unlocked /// @param lastProfitUnlockTime Last time profits were unlocked /// @param profitUnlockRate Per second rate at which profit shares unlocks. Rate when calculated is denominated in /// MAX_BPS_PROFIT. TODO: Get into uint112 struct ProfitUnlockSettings { uint48 unlockPeriodInSeconds; uint48 fullProfitUnlockTime; uint48 lastProfitUnlockTime; uint256 profitUnlockRate; } /// @param feeSink Where claimed fees are sent /// @param totalAssetsHighMark The last totalAssets amount we took fees at /// @param totalAssetsHighMarkTimestamp The last timestamp we updated the high water mark /// @param lastPeriodicFeeTake Timestamp of when the last periodic fee was taken. /// @param periodicFeeSink Address that receives periodic fee. /// @param periodicFeeBps Current periodic fee. 100% == 10000. /// @param streamingFeeBps Current streaming fee taken on profit. 100% == 10000 /// @param navPerShareLastFeeMark The last nav/share height we took fees at /// @param navPerShareLastFeeMarkTimestamp The last timestamp we took fees at /// @param rebalanceFeeHighWaterMarkEnabled Returns whether the nav/share high water mark is enabled for the /// rebalance fee struct AutopoolFeeSettings { address feeSink; uint256 totalAssetsHighMark; uint256 totalAssetsHighMarkTimestamp; uint256 lastPeriodicFeeTake; address periodicFeeSink; uint256 periodicFeeBps; uint256 streamingFeeBps; uint256 navPerShareLastFeeMark; uint256 navPerShareLastFeeMarkTimestamp; bool rebalanceFeeHighWaterMarkEnabled; } /// @param totalIdle The amount of baseAsset deposited into the contract pending deployment /// @param totalDebt The current (though cached) value of assets we've deployed /// @param totalDebtMin The current (though cached) value of assets we use for valuing during deposits /// @param totalDebtMax The current (though cached) value of assets we use for valuing during withdrawals struct AssetBreakdown { uint256 totalIdle; uint256 totalDebt; uint256 totalDebtMin; uint256 totalDebtMax; } enum TotalAssetPurpose { Global, Deposit, Withdraw } /* ******************************** */ /* Events */ /* ******************************** */ event TokensPulled(address[] tokens, uint256[] amounts, address[] destinations); event TokensRecovered(address[] tokens, uint256[] amounts, address[] destinations); event Nav(uint256 idle, uint256 debt, uint256 totalSupply); event RewarderSet(address newRewarder, address oldRewarder); event DestinationDebtReporting(address destination, uint256 debtValue, uint256 claimed, uint256 claimGasUsed); event FeeCollected(uint256 fees, address feeSink, uint256 mintedShares, uint256 profit, uint256 idle, uint256 debt); event PeriodicFeeCollected(uint256 fees, address feeSink, uint256 mintedShares); event Shutdown(VaultShutdownStatus reason); /* ******************************** */ /* Errors */ /* ******************************** */ error ERC4626MintExceedsMax(uint256 shares, uint256 maxMint); error ERC4626DepositExceedsMax(uint256 assets, uint256 maxDeposit); error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max); error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max); error InvalidShutdownStatus(VaultShutdownStatus status); error WithdrawalFailed(); error DepositFailed(); error InsufficientFundsInDestinations(uint256 deficit); error WithdrawalIncomplete(); error ValueSharesMismatch(uint256 value, uint256 shares); /// @notice A full unit of this pool // solhint-disable-next-line func-name-mixedcase function ONE() external view returns (uint256); /// @notice Query the type of vault function vaultType() external view returns (bytes32); /// @notice Strategy governing the pools rebalances function autoPoolStrategy() external view returns (IAutopoolStrategy); /// @notice Allow token recoverer to collect dust / unintended transfers (non-tracked assets only) function recover(address[] calldata tokens, uint256[] calldata amounts, address[] calldata destinations) external; /// @notice Set the order of destination vaults used for withdrawals // NOTE: will be done going directly to strategy (IStrategy) vault points to. // How it'll delegate is still being decided // function setWithdrawalQueue(address[] calldata destinations) external; /// @notice Get a list of destination vaults with pending assets to clear out function getRemovalQueue() external view returns (address[] memory); function getFeeSettings() external view returns (AutopoolFeeSettings memory); /// @notice Initiate the shutdown procedures for this vault function shutdown(VaultShutdownStatus reason) external; /// @notice True if the vault has been shutdown function isShutdown() external view returns (bool); /// @notice Returns the reason for shutdown (or `Active` if not shutdown) function shutdownStatus() external view returns (VaultShutdownStatus); /// @notice gets the list of supported destination vaults for the Autopool/Strategy /// @return _destinations List of supported destination vaults function getDestinations() external view returns (address[] memory _destinations); function convertToShares( uint256 assets, uint256 totalAssetsForPurpose, uint256 supply, Math.Rounding rounding ) external view returns (uint256 shares); function convertToAssets( uint256 shares, uint256 totalAssetsForPurpose, uint256 supply, Math.Rounding rounding ) external view returns (uint256 assets); function totalAssets(TotalAssetPurpose purpose) external view returns (uint256); function getAssetBreakdown() external view returns (AssetBreakdown memory); /// @notice get a destinations last reported debt value /// @param destVault the address of the target destination /// @return destinations last reported debt value function getDestinationInfo(address destVault) external view returns (AutopoolDebt.DestinationInfo memory); /// @notice check if a destination is registered with the vault function isDestinationRegistered(address destination) external view returns (bool); /// @notice get if a destinationVault is queued for removal by the AutopoolETH function isDestinationQueuedForRemoval(address destination) external view returns (bool); /// @notice Returns instance of vault rewarder. function rewarder() external view returns (IMainRewarder); /// @notice Returns all past rewarders. function getPastRewarders() external view returns (address[] memory _pastRewarders); /// @notice Returns boolean telling whether address passed in is past rewarder. function isPastRewarder(address _pastRewarder) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity >=0.8.7; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; /** * @title AutopoolETH Router Base Interface * @notice A canonical router between AutopoolETHs * * The base router is a multicall style router inspired by Uniswap v3 with built-in features for permit, * WETH9 wrap/unwrap, and ERC20 token pulling/sweeping/approving. It includes methods for the four mutable * ERC4626 functions deposit/mint/withdraw/redeem as well. * * These can all be arbitrarily composed using the multicall functionality of the router. * * NOTE the router is capable of pulling any approved token from your wallet. This is only possible when * your address is msg.sender, but regardless be careful when interacting with the router or ERC4626 Vaults. * The router makes no special considerations for unique ERC20 implementations such as fee on transfer. * There are no built in protections for unexpected behavior beyond enforcing the minSharesOut is received. */ interface IAutopilotRouterBase { /// @notice thrown when amount of assets received is below the min set by caller error MinAmountError(); /// @notice thrown when amount of shares received is below the min set by caller error MinSharesError(); /// @notice thrown when amount of assets received is above the max set by caller error MaxAmountError(); /// @notice thrown when amount of shares received is above the max set by caller error MaxSharesError(); /** * @notice mint `shares` from an ERC4626 vault. * @param vault The AutopoolETH to mint shares from. * @param to The destination of ownership shares. * @param shares The amount of shares to mint from `vault`. * @param maxAmountIn The max amount of assets used to mint. * @return amountIn the amount of assets used to mint by `to`. * @dev throws MaxAmountError */ function mint( IAutopool vault, address to, uint256 shares, uint256 maxAmountIn ) external payable returns (uint256 amountIn); /** * @notice deposit `amount` to an ERC4626 vault. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param amount The amount of assets to deposit to `vault`. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function deposit( IAutopool vault, address to, uint256 amount, uint256 minSharesOut ) external payable returns (uint256 sharesOut); /** * @notice withdraw `amount` from an ERC4626 vault. * @param vault The AutopoolETH to withdraw assets from. * @param to The destination of assets. * @param amount The amount of assets to withdraw from vault. * @param maxSharesOut The max amount of shares burned for assets requested. * @return sharesOut the amount of shares received by `to`. * @dev throws MaxSharesError */ function withdraw( IAutopool vault, address to, uint256 amount, uint256 maxSharesOut ) external payable returns (uint256 sharesOut); /** * @notice redeem `shares` shares from a AutopoolETH * @param vault The AutopoolETH to redeem shares from. * @param to The destination of assets. * @param shares The amount of shares to redeem from vault. * @param minAmountOut The min amount of assets received by `to`. * @return amountOut the amount of assets received by `to`. * @dev throws MinAmountError */ function redeem( IAutopool vault, address to, uint256 shares, uint256 minAmountOut ) external payable returns (uint256 amountOut); /// @notice Stakes vault token to corresponding rewarder. /// @param vault IERC20 instance of an Autopool to stake to. /// @param maxAmount Maximum amount for user to stake. Amount > balanceOf(user) will stake all present tokens. /// @return staked Returns total amount staked. function stakeVaultToken(IERC20 vault, uint256 maxAmount) external returns (uint256 staked); /// @notice Unstakes vault token from corresponding rewarder. /// @param vault IAutopool instance of the vault token to withdraw. /// @param rewarder Rewarder to withdraw from. /// @param maxAmount Amount of vault token to withdraw Amount > balanceOf(user) will withdraw all owned tokens. /// @param claim Claiming rewards or not on unstaking. /// @return withdrawn Amount of vault token withdrawn. function withdrawVaultToken( IAutopool vault, IMainRewarder rewarder, uint256 maxAmount, bool claim ) external returns (uint256 withdrawn); /// @notice Claims rewards on user stake of vault token. /// @param vault IAutopool instance of vault token to claim rewards for. /// @param rewarder Rewarder to claim rewards from. function claimAutopoolRewards(IAutopool vault, IMainRewarder rewarder) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2024 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; /** * @title Validates and distributes Vault token rewards based on the * the signed and submitted payloads */ interface IRewards { struct Recipient { uint256 chainId; uint256 cycle; address wallet; uint256 amount; } event SignerSet(address newSigner); event Claimed(uint256 cycle, address recipient, uint256 amount); /// @notice Get the underlying token rewards are paid in /// @return Token address function vaultToken() external view returns (IERC20); /// @notice Get the current payload signer; /// @return Signer address function rewardsSigner() external view returns (address); /// @notice Check the amount an account has already claimed /// @param account Account to check /// @return Amount already claimed function claimedAmounts(address account) external view returns (uint256); /// @notice Get the amount that is claimable based on the provided payload /// @param recipient Published rewards payload /// @return Amount claimable if the payload is signed function getClaimableAmount(Recipient calldata recipient) external view returns (uint256); /// @notice Change the signer used to validate payloads /// @param newSigner The new address that will be signing rewards payloads function setSigner(address newSigner) external; /// @notice Claim your rewards /// @param recipient Published rewards payload /// @param v v component of the payload signature /// @param r r component of the payload signature /// @param s s component of the payload signature function claim(Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s) external returns (uint256); /// @notice Claim rewards on behalf of another account , invoked primarily by the router /// @param recipient Published rewards payload /// @param v v component of the payload signature /// @param r r component of the payload signature /// @param s s component of the payload signature function claimFor(Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s) external returns (uint256); /// @notice Generate the hash of the payload /// @param recipient Published rewards payload /// @return Hash of the payload function genHash(Recipient memory recipient) external view returns (bytes32); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; struct SwapParams { /// @dev The address of the token to be sold. address sellTokenAddress; /// @dev The amount of tokens to be sold. uint256 sellAmount; /// @dev The address of the token to be bought. address buyTokenAddress; /// @dev The expected minimum amount of tokens to be bought. uint256 buyAmount; /// @dev Data payload to be used for complex swap operations. bytes data; /// @dev Extra data payload reserved for future development. This field allows for additional information /// or functionality to be added without changing the struct and interface. bytes extraData; } interface IAsyncSwapper { error TokenAddressZero(); error SwapFailed(); error InsufficientBuyAmountReceived(uint256 buyTokenAmountReceived, uint256 buyAmount); error InsufficientSellAmount(); error InsufficientBuyAmount(); error InsufficientBalance(uint256 balanceNeeded, uint256 balanceAvailable); event Swapped( address indexed sellTokenAddress, address indexed buyTokenAddress, uint256 sellAmount, uint256 buyAmount, uint256 buyTokenAmountReceived ); /** * @notice Swaps sellToken for buyToken * @param swapParams Encoded swap data * @return buyTokenAmountReceived The amount of buyToken received from the swap */ function swap(SwapParams memory swapParams) external returns (uint256 buyTokenAmountReceived); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; /** * @title IDestinationAdapter * @dev This is a super-interface to unify different types of adapters to be registered in Destination Registry. * Specific interface type is defined by extending from this interface. */ interface IDestinationAdapter { error MustBeMoreThanZero(); error ArraysLengthMismatch(); error BalanceMustIncrease(); error MinLpAmountNotReached(); error LpTokenAmountMismatch(); error NoNonZeroAmountProvided(); error InvalidBalanceChange(); error InvalidAddress(address); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISystemComponent } from "src/interfaces/ISystemComponent.sol"; /// @notice Creates and registers Destination Vaults for the system interface IDestinationVaultFactory is ISystemComponent { /// @notice Creates a vault of the specified type /// @dev vaultType will be bytes32 encoded and checked that a template is registered /// @param vaultType human readable key of the vault template /// @param baseAsset Base asset of the system. WETH/USDC/etc /// @param underlyer Underlying asset the vault will wrap /// @param incentiveCalculator Incentive calculator of the vault /// @param additionalTrackedTokens Any tokens in addition to base and underlyer that should be tracked /// @param salt Contracts are created via CREATE2 with this value /// @param params params to be passed to vaults initialize function /// @return vault address of the newly created destination vault function create( string memory vaultType, address baseAsset, address underlyer, address incentiveCalculator, address[] memory additionalTrackedTokens, bytes32 salt, bytes memory params ) external returns (address vault); /// @notice Sets the default reward ratio /// @param rewardRatio new default reward ratio function setDefaultRewardRatio(uint256 rewardRatio) external; /// @notice Sets the default reward block duration /// @param blockDuration new default reward block duration function setDefaultRewardBlockDuration(uint256 blockDuration) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Capture information about a pool or destination interface IStatsCalculator { /// @notice thrown when no snapshot is taken error NoSnapshotTaken(); /// @notice The id for this instance of a calculator function getAprId() external view returns (bytes32); /// @notice The id of the underlying asset/pool/destination this calculator represents /// @dev This may be a generated address function getAddressId() external view returns (address); /// @notice Setup the calculator after it has been copied /// @dev Should only be executed one time /// @param dependentAprIds apr ids that cover the dependencies of this calculator /// @param initData setup data specific to this type of calculator function initialize(bytes32[] calldata dependentAprIds, bytes calldata initData) external; /// @notice Capture stat data about this setup function snapshot() external; /// @notice Indicates if a snapshot should be taken /// @return takeSnapshot if true then a snapshot should be taken. If false, calling snapshot will do nothing function shouldSnapshot() external view returns (bool takeSnapshot); /// @dev Enum representing the snapshot status for a given rewarder (Convex and Aura) or reward token (Maverick) enum SnapshotStatus { noSnapshot, // Indicates that no snapshot has been taken yet for the rewarder. tooSoon, // Indicates that it's too soon to take another snapshot since the last one. shouldFinalize, // Indicates that the conditions are met for finalizing a snapshot. shouldRestart // Indicates that the conditions are met for restarting a snapshot. } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { Errors } from "src/utils/Errors.sol"; import { LibAdapter } from "src/libs/LibAdapter.sol"; import { IDestinationVault } from "src/interfaces/vault/IDestinationVault.sol"; import { Math } from "openzeppelin-contracts/utils/math/Math.sol"; import { EnumerableSet } from "openzeppelin-contracts/utils/structs/EnumerableSet.sol"; import { IStrategy } from "src/interfaces/strategy/IStrategy.sol"; import { SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol"; import { IERC20Metadata as IERC20 } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IERC3156FlashBorrower } from "openzeppelin-contracts/interfaces/IERC3156FlashBorrower.sol"; import { IAutopoolStrategy } from "src/interfaces/strategy/IAutopoolStrategy.sol"; import { StructuredLinkedList } from "src/strategy/StructuredLinkedList.sol"; import { WithdrawalQueue } from "src/strategy/WithdrawalQueue.sol"; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { AutopoolToken } from "src/vault/libs/AutopoolToken.sol"; library AutopoolDebt { using Math for uint256; using SafeERC20 for IERC20; using WithdrawalQueue for StructuredLinkedList.List; using EnumerableSet for EnumerableSet.AddressSet; using AutopoolToken for AutopoolToken.TokenData; /// @notice Max time a cached debt report can be used uint256 public constant MAX_DEBT_REPORT_AGE_SECONDS = 1 days; error VaultShutdown(); error WithdrawShareCalcInvalid(uint256 currentShares, uint256 cachedShares); error RebalanceDestinationsMatch(address destinationVault); error RebalanceFailed(string message); error InvalidPrices(); error InvalidTotalAssetPurpose(); error InvalidDestination(address destination); error TooFewAssets(uint256 requested, uint256 actual); error SharesAndAssetsReceived(uint256 assets, uint256 shares); error AmountExceedsAllowance(uint256 shares, uint256 allowed); event DestinationDebtReporting( address destination, AutopoolDebt.IdleDebtUpdates debtInfo, uint256 claimed, uint256 claimGasUsed ); event NewNavShareFeeMark(uint256 navPerShare, uint256 timestamp); event Nav(uint256 idle, uint256 debt, uint256 totalSupply); event Withdraw( address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); struct DestinationInfo { /// @notice Current underlying value at the destination vault /// @dev Used for calculating totalDebt, mid point of min and max uint256 cachedDebtValue; /// @notice Current minimum underlying value at the destination vault /// @dev Used for calculating totalDebt during withdrawal uint256 cachedMinDebtValue; /// @notice Current maximum underlying value at the destination vault /// @dev Used for calculating totalDebt of the deposit uint256 cachedMaxDebtValue; /// @notice Last block timestamp this info was updated uint256 lastReport; /// @notice How many shares of the destination vault we owned at last report uint256 ownedShares; } struct IdleDebtUpdates { bool pricesWereSafe; uint256 totalIdleDecrease; uint256 totalIdleIncrease; uint256 totalDebtIncrease; uint256 totalDebtDecrease; uint256 totalMinDebtIncrease; uint256 totalMinDebtDecrease; uint256 totalMaxDebtIncrease; uint256 totalMaxDebtDecrease; } struct RebalanceOutParams { /// Address that will received the withdrawn underlyer address receiver; /// The "out" destination vault address destinationOut; /// The amount of tokenOut that will be withdrawn uint256 amountOut; /// The underlyer for destinationOut address tokenOut; IERC20 _baseAsset; bool _shutdown; } /// @dev In memory struct only for managing vars in _withdraw struct WithdrawInfo { uint256 currentIdle; uint256 assetsFromIdle; uint256 totalAssetsToPull; uint256 assetsToPull; uint256 assetsPulled; uint256 idleIncrease; uint256 debtDecrease; uint256 debtMinDecrease; uint256 debtMaxDecrease; uint256 totalMinDebt; uint256 destinationRound; uint256 lastRoundSlippage; uint256 expectedAssets; } struct FlashRebalanceParams { uint256 totalIdle; uint256 totalDebt; IERC20 baseAsset; bool shutdown; } struct FlashResultInfo { uint256 tokenInBalanceBefore; uint256 tokenInBalanceAfter; bytes32 flashResult; } function flashRebalance( DestinationInfo storage destInfoOut, DestinationInfo storage destInfoIn, IERC3156FlashBorrower receiver, IStrategy.RebalanceParams memory params, IStrategy.SummaryStats memory destSummaryOut, IAutopoolStrategy autoPoolStrategy, FlashRebalanceParams memory flashParams, bytes calldata data ) external returns (IdleDebtUpdates memory result) { // Handle decrease (shares going "Out", cashing in shares and sending underlying back to swapper) // If the tokenOut is _asset we assume they are taking idle // which is already in the contract result = _handleRebalanceOut( AutopoolDebt.RebalanceOutParams({ receiver: address(receiver), destinationOut: params.destinationOut, amountOut: params.amountOut, tokenOut: params.tokenOut, _baseAsset: flashParams.baseAsset, _shutdown: flashParams.shutdown }), destInfoOut ); if (!result.pricesWereSafe) { revert InvalidPrices(); } // Handle increase (shares coming "In", getting underlying from the swapper and trading for new shares) if (params.amountIn > 0) { FlashResultInfo memory flashResultInfo; // get "before" counts flashResultInfo.tokenInBalanceBefore = IERC20(params.tokenIn).balanceOf(address(this)); // Give control back to the solver so they can make use of the "out" assets // and get our "in" asset flashResultInfo.flashResult = receiver.onFlashLoan(msg.sender, params.tokenIn, params.amountIn, 0, data); // We assume the solver will send us the assets flashResultInfo.tokenInBalanceAfter = IERC20(params.tokenIn).balanceOf(address(this)); // Make sure the call was successful and verify we have at least the assets we think // we were getting if ( flashResultInfo.flashResult != keccak256("ERC3156FlashBorrower.onFlashLoan") || flashResultInfo.tokenInBalanceAfter < flashResultInfo.tokenInBalanceBefore + params.amountIn ) { revert Errors.FlashLoanFailed(params.tokenIn, params.amountIn); } { // make sure we have a valid path (bool success, string memory message) = autoPoolStrategy.verifyRebalance(params, destSummaryOut); if (!success) { revert RebalanceFailed(message); } } if (params.tokenIn != address(flashParams.baseAsset)) { IdleDebtUpdates memory inDebtResult = _handleRebalanceIn( destInfoIn, IDestinationVault(params.destinationIn), params.tokenIn, flashResultInfo.tokenInBalanceAfter ); if (!inDebtResult.pricesWereSafe) { revert InvalidPrices(); } result.totalDebtDecrease += inDebtResult.totalDebtDecrease; result.totalDebtIncrease += inDebtResult.totalDebtIncrease; result.totalMinDebtDecrease += inDebtResult.totalMinDebtDecrease; result.totalMinDebtIncrease += inDebtResult.totalMinDebtIncrease; result.totalMaxDebtDecrease += inDebtResult.totalMaxDebtDecrease; result.totalMaxDebtIncrease += inDebtResult.totalMaxDebtIncrease; } else { result.totalIdleIncrease += flashResultInfo.tokenInBalanceAfter - flashResultInfo.tokenInBalanceBefore; } } } /// @notice Perform deposit and debt info update for the "in" destination during a rebalance /// @dev This "in" function performs less validations than its "out" version /// @param dvIn The "in" destination vault /// @param tokenIn The underlyer for dvIn /// @param depositAmount The amount of tokenIn that will be deposited /// @return result Changes in debt values function _handleRebalanceIn( DestinationInfo storage destInfo, IDestinationVault dvIn, address tokenIn, uint256 depositAmount ) private returns (IdleDebtUpdates memory result) { LibAdapter._approve(IERC20(tokenIn), address(dvIn), depositAmount); // Snapshot our current shares so we know how much to back out uint256 originalShareBal = dvIn.balanceOf(address(this)); // deposit to dv uint256 newShares = dvIn.depositUnderlying(depositAmount); // Update the debt info snapshot result = _recalculateDestInfo(destInfo, dvIn, originalShareBal, originalShareBal + newShares); } /** * @notice Perform withdraw and debt info update for the "out" destination during a rebalance * @dev This "out" function performs more validations and handles idle as opposed to "in" which does not * debtDecrease The previous amount of debt destinationOut accounted for in totalDebt * debtIncrease The current amount of debt destinationOut should account for in totalDebt * idleDecrease Amount of baseAsset that was sent from the vault. > 0 only when tokenOut == baseAsset * idleIncrease Amount of baseAsset that was claimed from Destination Vault * @param params Rebalance out params * @param destOutInfo The "out" destination vault info * @return assetChange debt and idle change data */ function _handleRebalanceOut( RebalanceOutParams memory params, DestinationInfo storage destOutInfo ) private returns (IdleDebtUpdates memory assetChange) { // Handle decrease (shares going "Out", cashing in shares and sending underlying back to swapper) // If the tokenOut is _asset we assume they are taking idle // which is already in the contract if (params.amountOut > 0) { if (params.tokenOut != address(params._baseAsset)) { IDestinationVault dvOut = IDestinationVault(params.destinationOut); // Snapshot our current shares so we know how much to back out uint256 originalShareBal = dvOut.balanceOf(address(this)); // Burning our shares will claim any pending baseAsset // rewards and send them to us. // Get our starting balance uint256 beforeBaseAssetBal = params._baseAsset.balanceOf(address(this)); // Withdraw underlying from the destination vault // Shares are sent directly to the flashRebalance receiver // slither-disable-next-line unused-return dvOut.withdrawUnderlying(params.amountOut, params.receiver); // Update the debt info snapshot assetChange = _recalculateDestInfo(destOutInfo, dvOut, originalShareBal, originalShareBal - params.amountOut); // Capture any rewards we may have claimed as part of withdrawing assetChange.totalIdleIncrease = params._baseAsset.balanceOf(address(this)) - beforeBaseAssetBal; } else { // If we are shutdown then the only operations we should be performing are those that get // the base asset back to the vault. We shouldn't be sending out more if (params._shutdown) { revert VaultShutdown(); } // Working with idle baseAsset which should be in the vault already // Just send it out IERC20(params.tokenOut).safeTransfer(params.receiver, params.amountOut); assetChange.totalIdleDecrease = params.amountOut; // We weren't dealing with any debt or pricing, just idle, so we can just mark // it as safe assetChange.pricesWereSafe = true; } } } function recalculateDestInfo( DestinationInfo storage destInfo, IDestinationVault destVault, uint256 originalShares, uint256 currentShares ) external returns (IdleDebtUpdates memory result) { result = _recalculateDestInfo(destInfo, destVault, originalShares, currentShares); } /// @dev Will not revert on unsafe prices. Up to the caller. function _recalculateDestInfo( DestinationInfo storage destInfo, IDestinationVault destVault, uint256 originalShares, uint256 currentShares ) private returns (IdleDebtUpdates memory result) { // TODO: Trace the use of this fn and ensure that every is handling is pricesWereSafe // Figure out what to back out of our totalDebt number. // We could have had withdraws since the last snapshot which means our // cached currentDebt number should be decreased based on the remaining shares // totalDebt is decreased using the same proportion of shares method during withdrawals // so this should represent whatever is remaining. // Prices are per LP token and whether or not the prices are safe to use // If they aren't safe then just continue and we'll get it on the next go around (uint256 spotPrice, uint256 safePrice, bool isSpotSafe) = destVault.getRangePricesLP(); // Calculate what we're backing out based on the original shares uint256 minPrice = spotPrice > safePrice ? safePrice : spotPrice; uint256 maxPrice = spotPrice > safePrice ? spotPrice : safePrice; // If we previously had shares, calculate how much of our cached numbers // still remain as this will be deducted from the overall debt numbers // TODO: Evaluate whether to round these up so we don't accumulate small amounts // over time uint256 prevOwnedShares = destInfo.ownedShares; if (prevOwnedShares > 0) { result.totalDebtDecrease = (destInfo.cachedDebtValue * originalShares) / prevOwnedShares; result.totalMinDebtDecrease = (destInfo.cachedMinDebtValue * originalShares) / prevOwnedShares; result.totalMaxDebtDecrease = (destInfo.cachedMaxDebtValue * originalShares) / prevOwnedShares; } // The overall debt value is the mid point of min and max uint256 div = 10 ** destVault.decimals(); uint256 newDebtValue = (minPrice * currentShares + maxPrice * currentShares) / (div * 2); result.pricesWereSafe = isSpotSafe; result.totalDebtIncrease = newDebtValue; result.totalMinDebtIncrease = minPrice * currentShares / div; result.totalMaxDebtIncrease = maxPrice * currentShares / div; // Save our current new values destInfo.cachedDebtValue = newDebtValue; destInfo.cachedMinDebtValue = result.totalMinDebtIncrease; destInfo.cachedMaxDebtValue = result.totalMaxDebtIncrease; destInfo.lastReport = block.timestamp; destInfo.ownedShares = currentShares; } function totalAssetsTimeChecked( StructuredLinkedList.List storage debtReportQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo, IAutopool.TotalAssetPurpose purpose ) external returns (uint256) { IDestinationVault destVault = IDestinationVault(debtReportQueue.peekHead()); uint256 recalculatedTotalAssets = IAutopool(address(this)).totalAssets(purpose); while (address(destVault) != address(0)) { uint256 lastReport = destinationInfo[address(destVault)].lastReport; if (lastReport + MAX_DEBT_REPORT_AGE_SECONDS > block.timestamp) { // Its not stale // This report is OK, we don't need to recalculate anything break; } else { // It is stale, recalculate //slither-disable-next-line unused-return uint256 currentShares = destVault.balanceOf(address(this)); uint256 staleDebt; uint256 extremePrice; // Figure out exactly which price to use based on its purpose if (purpose == IAutopool.TotalAssetPurpose.Deposit) { // We use max value so that anything deposited is worth less extremePrice = destVault.getUnderlyerCeilingPrice(); // Round down. We are subtracting this value out of the total so some left // behind just increases the value which is what we want staleDebt = destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( currentShares, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Down ); } else if (purpose == IAutopool.TotalAssetPurpose.Withdraw) { // We use min value so that we value the shares as worth less extremePrice = destVault.getUnderlyerFloorPrice(); // Round up. We are subtracting this value out of the total so if we take a little // extra it just decreases the value which is what we want staleDebt = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( currentShares, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); } else { revert InvalidTotalAssetPurpose(); } // Back out our stale debt, add in its new value // Our goal is to find the most conservative value in each situation. If the current // value we have represents that, then use it. Otherwise, use the new one. uint256 newValue = (currentShares * extremePrice) / destVault.ONE(); if (purpose == IAutopool.TotalAssetPurpose.Deposit && staleDebt > newValue) { newValue = staleDebt; } else if (purpose == IAutopool.TotalAssetPurpose.Withdraw && staleDebt < newValue) { newValue = staleDebt; } recalculatedTotalAssets = recalculatedTotalAssets + newValue - staleDebt; } destVault = IDestinationVault(debtReportQueue.getAdjacent(address(destVault), true)); } return recalculatedTotalAssets; } function _updateDebtReporting( StructuredLinkedList.List storage debtReportQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo, uint256 numToProcess ) external returns (IdleDebtUpdates memory result) { numToProcess = Math.min(numToProcess, debtReportQueue.sizeOf()); for (uint256 i = 0; i < numToProcess; ++i) { IDestinationVault destVault = IDestinationVault(debtReportQueue.popHead()); // Get the reward value we've earned. DV rewards are always in terms of base asset // We track the gas used purely for off-chain stats purposes // Main rewarder on DV's store the earned and liquidated rewards // Extra rewarders are disabled at the DV level uint256 claimGasUsed = gasleft(); uint256 beforeBaseAsset = IERC20(IAutopool(address(this)).asset()).balanceOf(address(this)); IMainRewarder(destVault.rewarder()).getReward(address(this), false); uint256 claimedRewardValue = IERC20(IAutopool(address(this)).asset()).balanceOf(address(this)) - beforeBaseAsset; result.totalIdleIncrease += claimedRewardValue; // Recalculate the debt info figuring out the change in // total debt value we can roll up later uint256 currentShareBalance = destVault.balanceOf(address(this)); AutopoolDebt.IdleDebtUpdates memory debtResult = _recalculateDestInfo( destinationInfo[address(destVault)], destVault, currentShareBalance, currentShareBalance ); result.totalDebtDecrease += debtResult.totalDebtDecrease; result.totalDebtIncrease += debtResult.totalDebtIncrease; result.totalMinDebtDecrease += debtResult.totalMinDebtDecrease; result.totalMinDebtIncrease += debtResult.totalMinDebtIncrease; result.totalMaxDebtDecrease += debtResult.totalMaxDebtDecrease; result.totalMaxDebtIncrease += debtResult.totalMaxDebtIncrease; // If we no longer have shares, then there's no reason to continue reporting on the destination. // The strategy will only call for the info if its moving "out" of the destination // and that will only happen if we have shares. // A rebalance where we move "in" to the position will refresh the data at that time if (currentShareBalance > 0) { debtReportQueue.addToTail(address(destVault)); } claimGasUsed -= gasleft(); emit DestinationDebtReporting(address(destVault), debtResult, claimedRewardValue, claimGasUsed); } } function _initiateWithdrawInfo( uint256 assets, IAutopool.AssetBreakdown storage assetBreakdown ) private view returns (WithdrawInfo memory) { uint256 idle = assetBreakdown.totalIdle; WithdrawInfo memory info = WithdrawInfo({ currentIdle: idle, // If idle can cover the full amount, then we want to pull all assets from there // Otherwise, we want to pull from the market and only get idle if we exhaust the market assetsFromIdle: assets > idle ? 0 : assets, totalAssetsToPull: 0, assetsToPull: 0, assetsPulled: 0, idleIncrease: 0, debtDecrease: 0, debtMinDecrease: 0, debtMaxDecrease: 0, totalMinDebt: assetBreakdown.totalDebtMin, destinationRound: 0, lastRoundSlippage: 0, expectedAssets: 0 }); info.totalAssetsToPull = assets - info.assetsFromIdle; // This var we use to track our progress later info.assetsToPull = assets - info.assetsFromIdle; // Idle + minDebt is the maximum amount of assets/debt we could burn during a withdraw. // If the user is request more than that (like during a withdraw) we can just revert // early without trying if (info.totalAssetsToPull > info.currentIdle + info.totalMinDebt) { revert TooFewAssets(assets, info.currentIdle + info.totalMinDebt); } return info; } function withdraw( uint256 assets, uint256 applicableTotalAssets, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) public returns (uint256 actualAssets, uint256 actualShares, uint256 debtBurned) { WithdrawInfo memory info = _initiateWithdrawInfo(assets, assetBreakdown); // Pull the market if there aren't enough funds in idle to cover the entire amount // This flow is not bounded by a set number of shares. The user has requested X assets // and a variable number of shares to burn so we don't have easy break out points like we do // during redeem (like using debt burned). When we get slippage here and don't meet the requested assets // we need to keep going if we can. This is tricky if we consider that (most of) our destinations are // LP positions and we'll be swapping assets, so we can expect some slippage. Even // if our minDebtValue numbers are up to date and perfectly accurate slippage could ensure we // are always receiving less than we expect/calculate and we never hit the requested assets // even though the owner would have shares to cover it. Under normal/expected conditions, our // minDebtValue is lower than actual and we expect overall value to be going up, so we burn a tad // more than we should and receive a tad more than we expect. This should cover us. However, // in other conditions we have to be sure we aren't endlessly trying to approach 0 so we are tracking // the slippage we received on the last pull, repricing, and applying an increasing multiplier until we either // pull enough to cover or pull them all and/or move to the next destination. uint256 dvSharesToBurn; while (info.assetsToPull > 0) { IDestinationVault destVault = IDestinationVault(withdrawalQueue.peekHead()); if (address(destVault) == address(0)) { // TODO: This may be some NULL value too, check the underlying library break; } uint256 dvShares = destVault.balanceOf(address(this)); { uint256 dvSharesValue; if (info.destinationRound == 0) { // First time pulling // We use the min debt value here because its a withdrawal and we're trying to cover an amount // of assets. Undervaluing the shares may mean we pull more but given that we expect slippage // that is desirable. dvSharesValue = destinationInfo[address(destVault)].cachedMinDebtValue * dvShares / destinationInfo[address(destVault)].ownedShares; } else { // When we've pulled from this destination before, i.e. destinationRound > 0, then we // know a more accurate exchange rate and its worse than we were expecting. // We even will pad it a bit as we want to account for any additional slippage we // may receive by say being farther down an AMM curve. // dvSharesToBurn is the last value we used when pulling from this destination // info.expectedAssets is how much we expected to get on that last pull // info.expectedAssets - info.lastRoundSlippage is how much we actually received uint256 paddedSlippage = info.lastRoundSlippage * (info.destinationRound + 10_000) / 10_000; if (paddedSlippage < info.expectedAssets) { dvSharesValue = (info.expectedAssets - paddedSlippage) * dvShares / dvSharesToBurn; } else { // This will just mean we pull all shares dvSharesValue = 0; } } if (dvSharesValue > info.assetsToPull) { dvSharesToBurn = (dvShares * info.assetsToPull) / dvSharesValue; // Only need to set it here because the only time we'll use it is if // we don't exhaust all shares and have to try the destination again info.expectedAssets = info.assetsToPull; } else { dvSharesToBurn = dvShares; } } // Destination Vaults always burn the exact amount we instruct them to uint256 pulledAssets = destVault.withdrawBaseAsset(dvSharesToBurn, address(this)); info.assetsPulled += pulledAssets; // Calculate the totalDebt we'll need to remove based on the shares we're burning // We're rounding up here so take care when actually applying to totalDebt // The assets we calculated to pull are from the minDebt number we track so // we'll use that one to ensure we properly account for slippage (the `pulled` var below) // The other two debt numbers we just need to keep up to date. uint256 debtMinDecrease = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMinDecrease += debtMinDecrease; info.debtDecrease += destinationInfo[address(destVault)].cachedDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMaxDecrease += destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If we've exhausted all shares we can remove the withdrawal from the queue // We need to leave it in the debt report queue though so that our destination specific // debt tracking values can be updated if (dvShares == dvSharesToBurn) { withdrawalQueue.popAddress(address(destVault)); info.destinationRound = 0; info.lastRoundSlippage = 0; } else { // If we didn't burn all the shares and we received enough to cover our // expected that means we'll break out below as we've hit our target unchecked { if (pulledAssets < info.expectedAssets) { info.lastRoundSlippage = info.expectedAssets - pulledAssets; if (info.destinationRound == 0) { info.destinationRound = 100; } else { info.destinationRound *= 2; } } } } // It's possible we'll get back more assets than we anticipate from a swap // so if we do, throw it in idle and stop processing. You don't get more than we've calculated if (info.assetsPulled >= info.totalAssetsToPull) { info.idleIncrease += info.assetsPulled - info.totalAssetsToPull; info.assetsPulled = info.totalAssetsToPull; break; } info.assetsToPull -= pulledAssets; } // info.assetsToPull isn't safe to use past this point. // It may or may not be accurate from the previous loop // We didn't get enough assets from the debt pull // See if we can get the rest from idle if (info.assetsPulled < assets && info.currentIdle > 0) { uint256 remaining = assets - info.assetsPulled; if (remaining <= info.currentIdle) { info.assetsFromIdle = remaining; } // We don't worry about the else case because if currentIdle can't // cover remaining then we'll fail the `actualAssets < assets` // check below and revert } debtBurned = info.assetsFromIdle + info.debtMinDecrease; actualAssets = info.assetsFromIdle + info.assetsPulled; if (actualAssets < assets) { revert TooFewAssets(assets, actualAssets); } actualShares = IAutopool(address(this)).convertToShares( Math.max(actualAssets, debtBurned), applicableTotalAssets, IAutopool(address(this)).totalSupply(), Math.Rounding.Up ); // Subtract what's taken out of idle from totalIdle // We may also have some increase to account for it we over pulled // or received better execution than we were anticipating // slither-disable-next-line events-maths assetBreakdown.totalIdle = info.currentIdle + info.idleIncrease - info.assetsFromIdle; // Save off our various debt numbers if (info.debtDecrease > assetBreakdown.totalDebt) { assetBreakdown.totalDebt = 0; } else { assetBreakdown.totalDebt -= info.debtDecrease; } if (info.debtMinDecrease > info.totalMinDebt) { assetBreakdown.totalDebtMin = 0; } else { assetBreakdown.totalDebtMin -= info.debtMinDecrease; } if (info.debtMaxDecrease > assetBreakdown.totalDebtMax) { assetBreakdown.totalDebtMax = 0; } else { assetBreakdown.totalDebtMax -= info.debtMaxDecrease; } } /// @notice Perform a removal of assets via the redeem path where the shares are the limiting factor. /// This means we break out whenever we reach either `assets` retrieved or debt value equivalent to `assets` burned function redeem( uint256 assets, uint256 applicableTotalAssets, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) public returns (uint256 actualAssets, uint256 actualShares, uint256 debtBurned) { WithdrawInfo memory info = _initiateWithdrawInfo(assets, assetBreakdown); // If not enough funds in idle, then pull what we need from destinations bool exhaustedDestinations = false; while (info.assetsToPull > 0) { IDestinationVault destVault = IDestinationVault(withdrawalQueue.peekHead()); if (address(destVault) == address(0)) { exhaustedDestinations = true; break; } uint256 dvShares = destVault.balanceOf(address(this)); uint256 dvSharesToBurn = dvShares; { // Valuing these shares higher, rounding up, will result in us burning less of them // in the event we don't burn all of them. Good thing. uint256 dvSharesValue = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If the dv shares we own are worth more than we need, limit the shares to burn // Any extra we get will be dropped into idle if (dvSharesValue > info.assetsToPull) { uint256 limitedShares = (dvSharesToBurn * info.assetsToPull) / dvSharesValue; // Final set for the actual shares we'll burn later dvSharesToBurn = limitedShares; } } // Destination Vaults always burn the exact amount we instruct them to uint256 pulledAssets = destVault.withdrawBaseAsset(dvSharesToBurn, address(this)); info.assetsPulled += pulledAssets; // Calculate the totalDebt we'll need to remove based on the shares we're burning // We're rounding up here so take care when actually applying to totalDebt // The assets we calculated to pull are from the minDebt number we track so // we'll use that one to ensure we properly account for slippage (the `pulled` var below) // The other two debt numbers we just need to keep up to date. uint256 debtMinDecrease = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMinDecrease += debtMinDecrease; info.debtDecrease += destinationInfo[address(destVault)].cachedDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMaxDecrease += destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If we've exhausted all shares we can remove the withdrawal from the queue // We need to leave it in the debt report queue though so that our destination specific // debt tracking values can be updated if (dvShares == dvSharesToBurn) { withdrawalQueue.popAddress(address(destVault)); } // It's possible we'll get back more assets than we anticipate from a swap // so if we do, throw it in idle and stop processing. You don't get more than we've calculated if (info.assetsPulled >= info.totalAssetsToPull) { info.idleIncrease += info.assetsPulled - info.totalAssetsToPull; info.assetsPulled = info.totalAssetsToPull; break; } // Any deficiency in the amount we received is slippage. debtDecrease is what we expected // to receive. If we received any extra, that's great we'll roll it forward so we burn // less on the next loop. uint256 pulled = Math.max(debtMinDecrease, pulledAssets); if (pulled >= info.assetsToPull) { // We either have enough assets, or we've burned the max debt we're allowed break; } else { info.assetsToPull -= pulled; } // If we didn't exhaust all of the shares from the destination it means we // assume we will get everything we need from there and everything else is slippage if (dvShares != dvSharesToBurn) { break; } } // info.assetsToPull isn't safe to use past this point. // It may or may not be accurate from the previous loop // We didn't get enough assets from the debt pull // See if we can get the rest from idle // Check the debt burned though to ensure that we don't try to make up // slippage incurred out of idle if ( info.assetsPulled < assets && info.debtMinDecrease < assets && info.currentIdle > 0 && exhaustedDestinations ) { uint256 remaining = assets - Math.max(info.assetsPulled, info.debtMinDecrease); if (remaining < info.currentIdle) { info.assetsFromIdle = remaining; } else { info.assetsFromIdle = info.currentIdle; } } debtBurned = info.assetsFromIdle + info.debtMinDecrease; actualAssets = info.assetsFromIdle + info.assetsPulled; actualShares = IAutopool(address(this)).convertToShares( debtBurned, applicableTotalAssets, IAutopool(address(this)).totalSupply(), Math.Rounding.Up ); // Subtract what's taken out of idle from totalIdle // We may also have some increase to account for it we over pulled // or received better execution than we were anticipating // slither-disable-next-line events-maths assetBreakdown.totalIdle = info.currentIdle + info.idleIncrease - info.assetsFromIdle; // Save off our various debt numbers if (info.debtDecrease > assetBreakdown.totalDebt) { assetBreakdown.totalDebt = 0; } else { assetBreakdown.totalDebt -= info.debtDecrease; } if (info.debtMinDecrease > info.totalMinDebt) { assetBreakdown.totalDebtMin = 0; } else { assetBreakdown.totalDebtMin -= info.debtMinDecrease; } if (info.debtMaxDecrease > assetBreakdown.totalDebtMax) { assetBreakdown.totalDebtMax = 0; } else { assetBreakdown.totalDebtMax -= info.debtMaxDecrease; } } /** * @notice Function to complete a withdrawal or redeem. This runs after shares to be burned and assets to be * transferred are calculated. * @param assets Amount of assets to be transferred to receiver. * @param shares Amount of shares to be burned from owner. * @param owner Owner of shares, user to burn shares from. * @param receiver The receiver of the baseAsset. * @param baseAsset Base asset of the Autopool. * @param assetBreakdown Asset breakdown for the Autopool. * @param tokenData Token data for the Autopool. */ function completeWithdrawal( uint256 assets, uint256 shares, address owner, address receiver, IERC20 baseAsset, IAutopool.AssetBreakdown storage assetBreakdown, AutopoolToken.TokenData storage tokenData ) external { if (msg.sender != owner) { uint256 allowed = IAutopool(address(this)).allowance(owner, msg.sender); if (allowed != type(uint256).max) { if (shares > allowed) revert AmountExceedsAllowance(shares, allowed); unchecked { tokenData.approve(owner, msg.sender, allowed - shares); } } } tokenData.burn(owner, shares); uint256 ts = IAutopool(address(this)).totalSupply(); emit Withdraw(msg.sender, receiver, owner, assets, shares); emit Nav(assetBreakdown.totalIdle, assetBreakdown.totalDebt, ts); baseAsset.safeTransfer(receiver, assets); } /** * @notice A helper function to get estimates of what would happen on a withdraw or redeem. * @dev Reverts all changing state. * @param previewWithdraw Bool denoting whether to preview a redeem or withdrawal. * @param assets Assets to be withdrawn or redeemed. * @param applicableTotalAssets Operation dependent assets in the Autopool. * @param functionCallEncoded Abi encoded function signature for recursive call. * @param assetBreakdown Breakdown of vault assets from Autopool storage. * @param withdrawalQueue Destination vault withdrawal queue from Autopool storage. * @param destinationInfo Mapping of information for destinations. * @return assetsAmount Preview of amount of assets to send to receiver. * @return sharesAmount Preview of amount of assets to burn from owner. */ function preview( bool previewWithdraw, uint256 assets, uint256 applicableTotalAssets, bytes memory functionCallEncoded, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) external returns (uint256 assetsAmount, uint256 sharesAmount) { if (msg.sender != address(this)) { // Perform a recursive call the function in `funcCallEncoded`. This will result in a call back to // the Autopool, and then this function. The intention is to reach the "else" block in this function. // solhint-disable avoid-low-level-calls // slither-disable-next-line missing-zero-check,low-level-calls (bool success, bytes memory returnData) = address(this).call(functionCallEncoded); // solhint-enable avoid-low-level-calls // If the recursive call is successful, it means an unintended code path was taken. if (success) { revert Errors.UnreachableError(); } bytes4 sharesAmountSig = bytes4(keccak256("SharesAndAssetsReceived(uint256,uint256)")); // Extract the error signature (first 4 bytes) from the revert reason. bytes4 errorSignature; // solhint-disable no-inline-assembly assembly { errorSignature := mload(add(returnData, 0x20)) } // If the error matches the expected signature, extract the amount from the revert reason and return. if (errorSignature == sharesAmountSig) { // Extract subsequent bytes for uint256. assembly { assetsAmount := mload(add(returnData, 0x24)) sharesAmount := mload(add(returnData, 0x44)) } } else { // If the error is not the expected one, forward the original revert reason. assembly { revert(add(32, returnData), mload(returnData)) } } // solhint-enable no-inline-assembly } // This branch is taken during the recursive call. else { // Perform the actual withdrawal or redeem logic to compute the amount. This will be reverted to // simulate the action. uint256 previewAssets; uint256 previewShares; if (previewWithdraw) { (previewAssets, previewShares,) = withdraw(assets, applicableTotalAssets, assetBreakdown, withdrawalQueue, destinationInfo); } else { (previewAssets, previewShares,) = redeem(assets, applicableTotalAssets, assetBreakdown, withdrawalQueue, destinationInfo); } // Revert with the computed amount as an error. revert SharesAndAssetsReceived(previewAssets, previewShares); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; /// @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in https://eips.ethereum.org/EIPS/eip-4626 /// @dev Due to the nature of obtaining estimates for previewing withdraws and redeems, a few functions are not /// view and therefore do not conform to eip 4626. These functions use state changing operations /// to get accurate estimates, reverting after the preview amounts have been obtained. interface IERC4626 is IERC20Metadata { event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares); event Withdraw( address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); /// @notice Returns the address of the underlying token used for the Vault for accounting, depositing, and /// withdrawing. /// @dev /// - MUST be an ERC-20 token contract. /// - MUST NOT revert. function asset() external view returns (address assetTokenAddress); /// @notice Returns the total amount of the underlying asset that is “managed” by Vault. /// @dev /// - SHOULD include any compounding that occurs from yield. /// - MUST be inclusive of any fees that are charged against assets in the Vault. /// - MUST NOT revert. function totalAssets() external view returns (uint256 totalManagedAssets); /// @notice Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an /// ideal /// scenario where all the conditions are met. /// @dev /// - MUST NOT be inclusive of any fees that are charged against assets in the Vault. /// - MUST NOT show any variations depending on the caller. /// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. /// - MUST NOT revert. /// /// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the /// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and /// from. function convertToShares(uint256 assets) external view returns (uint256 shares); /// @notice Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an /// ideal /// scenario where all the conditions are met. /// @dev /// - MUST NOT be inclusive of any fees that are charged against assets in the Vault. /// - MUST NOT show any variations depending on the caller. /// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. /// - MUST NOT revert. /// /// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the /// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and /// from. function convertToAssets(uint256 shares) external view returns (uint256 assets); /// @notice Returns the maximum amount of the underlying asset that can be deposited into the Vault for the /// receiver, /// through a deposit call. /// @dev /// - MUST return a limited value if receiver is subject to some deposit limit. /// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited. /// - MUST NOT revert. function maxDeposit(address receiver) external returns (uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, /// given /// current on-chain conditions. /// @dev /// - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit /// call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called /// in the same transaction. /// - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the /// deposit would be accepted, regardless if the user has enough tokens approved, etc. /// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. /// - MUST NOT revert. /// /// NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in /// share price or some other type of condition, meaning the depositor will lose assets by depositing. function previewDeposit(uint256 assets) external returns (uint256 shares); /// @notice Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens. /// @dev /// - MUST emit the Deposit event. /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the /// deposit execution, and are accounted for during deposit. /// - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not /// approving enough underlying tokens to the Vault contract, etc). /// /// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. function deposit(uint256 assets, address receiver) external returns (uint256 shares); /// @notice Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call. /// @dev /// - MUST return a limited value if receiver is subject to some mint limit. /// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted. /// - MUST NOT revert. function maxMint(address receiver) external returns (uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given /// current on-chain conditions. /// @dev /// - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call /// in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the /// same transaction. /// - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint /// would be accepted, regardless if the user has enough tokens approved, etc. /// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. /// - MUST NOT revert. /// /// NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in /// share price or some other type of condition, meaning the depositor will lose assets by minting. function previewMint(uint256 shares) external returns (uint256 assets); /// @notice Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens. /// @dev /// - MUST emit the Deposit event. /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint /// execution, and are accounted for during mint. /// - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not /// approving enough underlying tokens to the Vault contract, etc). /// /// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. function mint(uint256 shares, address receiver) external returns (uint256 assets); /// @notice Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the /// Vault, through a withdraw call. /// @dev /// - MUST return a limited value if owner is subject to some withdrawal limit or timelock. /// - MUST NOT revert. function maxWithdraw(address owner) external returns (uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, /// given current on-chain conditions. /// @dev /// - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw /// call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if /// called /// in the same transaction. /// - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though /// the withdrawal would be accepted, regardless if the user has enough shares, etc. /// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. /// - MUST NOT revert. /// /// NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in /// share price or some other type of condition, meaning the depositor will lose assets by depositing. function previewWithdraw(uint256 assets) external returns (uint256 shares); /// @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver. /// @dev /// - MUST emit the Withdraw event. /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the /// withdraw execution, and are accounted for during withdraw. /// - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner /// not having enough shares, etc). /// /// Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed. /// Those methods should be performed separately. function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares); /// @notice Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, /// through a redeem call. /// @dev /// - MUST return a limited value if owner is subject to some withdrawal limit or timelock. /// - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock. /// - MUST NOT revert. function maxRedeem(address owner) external returns (uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, /// given current on-chain conditions. /// @dev /// - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call /// in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the /// same transaction. /// - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the /// redemption would be accepted, regardless if the user has enough shares, etc. /// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. /// - MUST NOT revert. /// /// NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in /// share price or some other type of condition, meaning the depositor will lose assets by redeeming. function previewRedeem(uint256 shares) external returns (uint256 assets); /// @notice Burns exactly shares from owner and sends assets of underlying tokens to receiver. /// @dev /// - MUST emit the Withdraw event. /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the /// redeem execution, and are accounted for during redeem. /// - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner /// not having enough shares, etc). /// /// NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed. /// Those methods should be performed separately. function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IStrategy } from "src/interfaces/strategy/IStrategy.sol"; interface IAutopoolStrategy { enum RebalanceDirection { In, Out } /// @notice verify that a rebalance (swap between destinations) meets all the strategy constraints /// @dev Signature identical to IStrategy.verifyRebalance function verifyRebalance( IStrategy.RebalanceParams memory, IStrategy.SummaryStats memory ) external returns (bool, string memory message); /// @notice called by the Autopool when NAV is updated /// @dev can only be called by the strategy's registered Autopool /// @param navPerShare The navPerShare to record function navUpdate(uint256 navPerShare) external; /// @notice called by the Autopool when a rebalance is completed /// @dev can only be called by the strategy's registered Autopool /// @param rebalanceParams The parameters for the rebalance that was executed function rebalanceSuccessfullyExecuted(IStrategy.RebalanceParams memory rebalanceParams) external; /// @notice called by the Autopool during rebalance process /// @param rebalanceParams The parameters for the rebalance that was executed function getRebalanceOutSummaryStats(IStrategy.RebalanceParams memory rebalanceParams) external returns (IStrategy.SummaryStats memory outSummary); /// @notice the number of days to pause rebalancing due to NAV decay function pauseRebalancePeriodInDays() external view returns (uint16); /// @notice the number of seconds gap between consecutive rebalances function rebalanceTimeGapInSeconds() external view returns (uint256); /// @notice destinations trading a premium above maxPremium will be blocked from new capital deployments function maxPremium() external view returns (int256); // 100% = 1e18 /// @notice destinations trading a discount above maxDiscount will be blocked from new capital deployments function maxDiscount() external view returns (int256); // 100% = 1e18 /// @notice the allowed staleness of stats data before a revert occurs function staleDataToleranceInSeconds() external view returns (uint40); /// @notice the swap cost offset period to initialize the strategy with function swapCostOffsetInitInDays() external view returns (uint16); /// @notice the number of violations required to trigger a tightening of the swap cost offset period (1 to 10) function swapCostOffsetTightenThresholdInViolations() external view returns (uint16); /// @notice the number of days to decrease the swap offset period for each tightening step function swapCostOffsetTightenStepInDays() external view returns (uint16); /// @notice the number of days since a rebalance required to trigger a relaxing of the swap cost offset period function swapCostOffsetRelaxThresholdInDays() external view returns (uint16); /// @notice the number of days to increase the swap offset period for each relaxing step function swapCostOffsetRelaxStepInDays() external view returns (uint16); // slither-disable-start similar-names /// @notice the maximum the swap cost offset period can reach. This is the loosest the strategy will be function swapCostOffsetMaxInDays() external view returns (uint16); /// @notice the minimum the swap cost offset period can reach. This is the most conservative the strategy will be function swapCostOffsetMinInDays() external view returns (uint16); /// @notice the number of days for the first NAV decay comparison (e.g., 30 days) function navLookback1InDays() external view returns (uint8); /// @notice the number of days for the second NAV decay comparison (e.g., 60 days) function navLookback2InDays() external view returns (uint8); /// @notice the number of days for the third NAV decay comparison (e.g., 90 days) function navLookback3InDays() external view returns (uint8); // slither-disable-end similar-names /// @notice the maximum slippage that is allowed for a normal rebalance function maxNormalOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when a destination is trimmed due to constraint violations /// recommend setting this higher than maxNormalOperationSlippage function maxTrimOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when a destinationVault has been shutdown /// shutdown for a vault is abnormal and means there is an issue at that destination /// recommend setting this higher than maxNormalOperationSlippage function maxEmergencyOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when the Autopool has been shutdown function maxShutdownOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum discount used for price return function maxAllowedDiscount() external view returns (int256); // 18 precision /// @notice model weight used for LSTs base yield, 1e6 is the highest function weightBase() external view returns (uint256); /// @notice model weight used for DEX fee yield, 1e6 is the highest function weightFee() external view returns (uint256); /// @notice model weight used for incentive yield function weightIncentive() external view returns (uint256); /// @notice model weight used slashing costs function weightSlashing() external view returns (uint256); /// @notice model weight applied to an LST discount when exiting the position function weightPriceDiscountExit() external view returns (int256); /// @notice model weight applied to an LST discount when entering the position function weightPriceDiscountEnter() external view returns (int256); /// @notice model weight applied to an LST premium when entering or exiting the position function weightPricePremium() external view returns (int256); /// @notice initial value of the swap cost offset to use function swapCostOffsetInit() external view returns (uint16); /// @notice initial lst price gap tolerance function defaultLstPriceGapTolerance() external view returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IBaseRewarder } from "src/interfaces/rewarders/IBaseRewarder.sol"; import { IExtraRewarder } from "src/interfaces/rewarders/IExtraRewarder.sol"; interface IMainRewarder is IBaseRewarder { error ExtraRewardsNotAllowed(); event ExtraRewardAdded(address reward); event ExtraRewardsCleared(); event ExtraRewardRemoved(address reward); /** * @notice Adds an ExtraRewarder contract address to the extraRewards array. * @param reward The address of the ExtraRewarder contract. */ function addExtraReward(address reward) external; /** * @notice Removes a list of ExtraRewarder contract addresses from the extraRewards array. */ function removeExtraRewards(address[] calldata _rewards) external; /** * @notice Withdraws the specified amount of tokens from the vault for the specified account, and transfers all * rewards for the account from this contract and any linked extra reward contracts. * @param account The address of the account to withdraw tokens and claim rewards for. * @param amount The amount of tokens to withdraw. * @param claim If true, claims all rewards for the account from this contract and any linked extra reward * contracts. */ function withdraw(address account, uint256 amount, bool claim) external; /** * @notice Clears the extraRewards array. */ function clearExtraRewards() external; /** * @notice Claims and transfers all rewards for the specified account from this contract and any linked extra reward * contracts. * @dev If claimExtras is true, also claims all rewards from linked extra reward contracts. * @param account The address of the account to claim rewards for. * @param claimExtras If true, claims rewards from linked extra reward contracts. */ function getReward(address account, bool claimExtras) external; /** * @notice Number of extra rewards currently registered */ function extraRewardsLength() external view returns (uint256); /** * @notice Get the extra rewards array values */ function extraRewards() external view returns (address[] memory); /** * @notice Get the rewarder at the specified index */ function getExtraRewarder(uint256 index) external view returns (IExtraRewarder); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; import { SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol"; library LibAdapter { using SafeERC20 for IERC20; address public constant CURVE_REGISTRY_ETH_ADDRESS_POINTER = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; error MinLpAmountNotReached(); error LpTokenAmountMismatch(); error NoNonZeroAmountProvided(); error InvalidBalanceChange(); // Utils function _approve(IERC20 token, address spender, uint256 amount) internal { uint256 currentAllowance = token.allowance(address(this), spender); if (currentAllowance > 0) { token.safeDecreaseAllowance(spender, currentAllowance); } token.safeIncreaseAllowance(spender, amount); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20Metadata as IERC20 } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IBaseAssetVault } from "src/interfaces/vault/IBaseAssetVault.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IDexLSTStats } from "src/interfaces/stats/IDexLSTStats.sol"; interface IDestinationVault is IBaseAssetVault, IERC20 { enum VaultShutdownStatus { Active, Deprecated, Exploit } error LogicDefect(); error BaseAmountReceived(uint256 amount); /* ******************************** */ /* View */ /* ******************************** */ /// @notice A full unit of this vault // solhint-disable-next-line func-name-mixedcase function ONE() external view returns (uint256); /// @notice The asset that is deposited into the vault function underlying() external view returns (address); /// @notice The asset that rewards and withdrawals to the Autopool are denominated in /// @inheritdoc IBaseAssetVault function baseAsset() external view override returns (address); /// @notice Debt balance of underlying asset that is in contract. This /// value includes only assets that are known as debt by the rest of the /// system (i.e. transferred in on rebalance), and does not include /// extraneous amounts of underlyer that may have ended up in this contract. function internalDebtBalance() external view returns (uint256); /// @notice Debt balance of underlyering asset staked externally. This value only /// includes assets known as debt to the rest of the system, and does not include /// any assets staked on behalf of the DV in external contracts. function externalDebtBalance() external view returns (uint256); /// @notice Returns true value of _underlyer in DV. Debt + tokens that may have /// been transferred into the contract outside of rebalance. function internalQueriedBalance() external view returns (uint256); /// @notice Returns true value of staked _underlyer in external contract. This /// will include any _underlyer that has been staked on behalf of the DV. function externalQueriedBalance() external view returns (uint256); /// @notice Balance of underlying debt, sum of `externalDebtBalance()` and `internalDebtBalance()`. function balanceOfUnderlyingDebt() external view returns (uint256); /// @notice Rewarder for this vault function rewarder() external view returns (address); /// @notice Exchange this destination vault points to function exchangeName() external view returns (string memory); /// @notice The type of pool associated with this vault function poolType() external view returns (string memory); /// @notice If the pool only deals in ETH when adding or removing liquidity function poolDealInEth() external view returns (bool); /// @notice Tokens that base asset can be swapped into function underlyingTokens() external view returns (address[] memory); /* ******************************** */ /* Events */ /* ******************************** */ event Donated(address sender, uint256 amount); event Withdraw( uint256 target, uint256 actual, uint256 debtLoss, uint256 claimLoss, uint256 fromIdle, uint256 fromDebt ); event UpdateSignedMessage(bytes32 hash, bool flag); /* ******************************** */ /* Errors */ /* ******************************** */ error ZeroAddress(string paramName); error InvalidShutdownStatus(VaultShutdownStatus status); /* ******************************** */ /* Functions */ /* ******************************** */ /// @notice Setup the contract. These will be cloned so no constructor /// @param baseAsset_ Base asset of the system. WETH/USDC/etc /// @param underlyer_ Underlying asset the vault will wrap /// @param rewarder_ Reward tracker for this vault /// @param incentiveCalculator_ Incentive calculator for this vault /// @param additionalTrackedTokens_ Additional tokens that should be considered 'tracked' /// @param params_ Any extra parameters needed to setup the contract function initialize( IERC20 baseAsset_, IERC20 underlyer_, IMainRewarder rewarder_, address incentiveCalculator_, address[] memory additionalTrackedTokens_, bytes memory params_ ) external; function getRangePricesLP() external returns (uint256 spotPrice, uint256 safePrice, bool isSpotSafe); /// @notice Calculates the current value of a portion of the debt based on shares /// @dev Queries the current value of all tokens we have deployed, whether its a single place, multiple, staked, etc /// @param shares The number of shares to value /// @return value The current value of our debt in terms of the baseAsset function debtValue(uint256 shares) external returns (uint256 value); /// @notice Collects any earned rewards from staking, incentives, etc. Transfers to sender /// @dev Should be limited to LIQUIDATOR_MANAGER. Rewards must be collected before claimed /// @return amounts amount of rewards claimed for each token /// @return tokens tokens claimed function collectRewards() external returns (uint256[] memory amounts, address[] memory tokens); /// @notice Pull any non-tracked token to the specified destination /// @dev Should be limited to TOKEN_RECOVERY_MANAGER function recover(address[] calldata tokens, uint256[] calldata amounts, address[] calldata destinations) external; /// @notice Recovers any extra underlying both in DV and staked externally not tracked as debt. /// @dev Should be limited to TOKEN_SAVER_ROLE. /// @param destination The address to send excess underlyer to. function recoverUnderlying(address destination) external; /// @notice Deposit underlying to receive destination vault shares /// @param amount amount of base lp asset to deposit function depositUnderlying(uint256 amount) external returns (uint256 shares); /// @notice Withdraw underlying by burning destination vault shares /// @param shares amount of destination vault shares to burn /// @param to destination of the underlying asset /// @return amount underlyer amount 'to' received function withdrawUnderlying(uint256 shares, address to) external returns (uint256 amount); /// @notice Burn specified shares for underlyer swapped to base asset /// @param shares amount of vault shares to burn /// @param to destination of the base asset /// @return amount base asset amount 'to' received function withdrawBaseAsset(uint256 shares, address to) external returns (uint256 amount); /// @notice Mark this vault as shutdown so that autoPools can react function shutdown(VaultShutdownStatus reason) external; /// @notice True if the vault has been shutdown function isShutdown() external view returns (bool); /// @notice Returns the reason for shutdown (or `Active` if not shutdown) function shutdownStatus() external view returns (VaultShutdownStatus); /// @notice Stats contract for this vault function getStats() external view returns (IDexLSTStats); /// @notice get the marketplace rewards /// @return rewardTokens list of reward token addresses /// @return rewardRates list of reward rates function getMarketplaceRewards() external returns (uint256[] memory rewardTokens, uint256[] memory rewardRates); /// @notice Get the address of the underlying pool the vault points to /// @return poolAddress address of the underlying pool function getPool() external view returns (address poolAddress); /// @notice Gets the spot price of the underlying LP token /// @dev Price validated to be inside our tolerance against safe price. Will revert if outside. /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getValidatedSpotPrice() external returns (uint256 price); /// @notice Gets the safe price of the underlying LP token /// @dev Price validated to be inside our tolerance against spot price. Will revert if outside. /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getValidatedSafePrice() external returns (uint256 price); /// @notice Get the lowest price we can get for the LP token /// @dev This price can be attacked is not validate to be in any range /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getUnderlyerFloorPrice() external returns (uint256 price); /// @notice Get the highest price we can get for the LP token /// @dev This price can be attacked is not validate to be in any range /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getUnderlyerCeilingPrice() external returns (uint256 price); /// @notice Set or unset a hash as a signed message /// @dev Should be limited to DESTINATION_VAULTS_UPDATER. The set hash is used to vaildate a signature. /// This signature can be potentially used to claim offchain rewards earned by Destination Vaults. /// @param hash bytes32 hash of a payload /// @param flag boolean flag to indicate a validity of hash function setMessage(bytes32 hash, bool flag) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC3156FlashBorrower } from "openzeppelin-contracts/interfaces/IERC3156FlashBorrower.sol"; interface IStrategy { /* ******************************** */ /* Events */ /* ******************************** */ event DestinationVaultAdded(address destination); event DestinationVaultRemoved(address destination); event WithdrawalQueueSet(address[] destinations); event AddedToRemovalQueue(address destination); event RemovedFromRemovalQueue(address destination); error InvalidDestinationVault(); error RebalanceFailed(string message); /// @notice gets the list of supported destination vaults for the Autopool/Strategy /// @return _destinations List of supported destination vaults function getDestinations() external view returns (address[] memory _destinations); /// @notice add supported destination vaults for the Autopool/Strategy /// @param _destinations The list of destination vaults to add function addDestinations(address[] calldata _destinations) external; /// @notice remove supported destination vaults for the Autopool/Strategy /// @param _destinations The list of destination vaults to remove function removeDestinations(address[] calldata _destinations) external; /// @param destinationIn The address / lp token of the destination vault that will increase /// @param tokenIn The address of the underlyer token that will be provided by the swapper /// @param amountIn The amount of the underlying LP tokens that will be received /// @param destinationOut The address of the destination vault that will decrease /// @param tokenOut The address of the underlyer token that will be received by the swapper /// @param amountOut The amount of the tokenOut that will be received by the swapper struct RebalanceParams { address destinationIn; address tokenIn; uint256 amountIn; address destinationOut; address tokenOut; uint256 amountOut; } /// @param destination The address / lp token of the destination vault /// @param baseApr Base Apr is the yield generated by staking rewards /// @param feeApr Yield for pool trading fees /// @param incentiveApr Incentives for LP /// @param safeTotalSupply Safe supply for LP tokens /// @param priceReturn Return from price movement to & away from peg /// @param maxDiscount Max discount to peg /// @param maxPremium Max premium to peg /// @param ownedShares Shares owned for this destination /// @param compositeReturn Total return combined from the individual yield components /// @param pricePerShare Price per share /// @param slashingCost The loss due to slashing of the backing struct SummaryStats { address destination; uint256 baseApr; uint256 feeApr; uint256 incentiveApr; uint256 safeTotalSupply; int256 priceReturn; int256 maxDiscount; int256 maxPremium; uint256 ownedShares; int256 compositeReturn; uint256 pricePerShare; uint256 slashingCost; } /// @notice rebalance the Autopool from the tokenOut (decrease) to the tokenIn (increase) /// This uses a flash loan to receive the tokenOut to reduce the working capital requirements of the swapper /// @param receiver The contract receiving the tokens, needs to implement the /// `onFlashLoan(address user, address token, uint256 amount, uint256 fee, bytes calldata)` interface /// @param params Parameters by which to perform the rebalance /// @param data A data parameter to be passed on to the `receiver` for any custom use function flashRebalance( IERC3156FlashBorrower receiver, RebalanceParams calldata params, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC3156FlashBorrower.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC3156 FlashBorrower, as defined in * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. * * _Available since v4.1._ */ interface IERC3156FlashBorrower { /** * @dev Receive a flash loan. * @param initiator The initiator of the loan. * @param token The loan currency. * @param amount The amount of tokens lent. * @param fee The additional amount of tokens to repay. * @param data Arbitrary data structure, intended to contain user-defined parameters. * @return The keccak256 hash of "IERC3156FlashBorrower.onFlashLoan" */ function onFlashLoan( address initiator, address token, uint256 amount, uint256 fee, bytes calldata data ) external returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity =0.8.17; /** * @title StructuredLinkedList * @author Vittorio Minacori (https://github.com/vittominacori) * @dev An utility library for using sorted linked list data structures in your Solidity project. * @notice Adapted from * https://github.com/Layr-Labs/eigenlayer-contracts/blob/master/src/contracts/libraries/StructuredLinkedList.sol */ library StructuredLinkedList { uint256 private constant _NULL = 0; uint256 private constant _HEAD = 0; bool private constant _PREV = false; bool private constant _NEXT = true; struct List { uint256 size; mapping(uint256 => mapping(bool => uint256)) list; } /** * @dev Checks if the list exists * @param self stored linked list from contract * @return bool true if list exists, false otherwise */ function listExists(List storage self) public view returns (bool) { // if the head nodes previous or next pointers both point to itself, then there are no items in the list if (self.list[_HEAD][_PREV] != _HEAD || self.list[_HEAD][_NEXT] != _HEAD) { return true; } else { return false; } } /** * @dev Checks if the node exists * @param self stored linked list from contract * @param _node a node to search for * @return bool true if node exists, false otherwise */ function nodeExists(List storage self, uint256 _node) public view returns (bool) { if (self.list[_node][_PREV] == _HEAD && self.list[_node][_NEXT] == _HEAD) { if (self.list[_HEAD][_NEXT] == _node) { return true; } else { return false; } } else { return true; } } /** * @dev Returns the number of elements in the list * @param self stored linked list from contract * @return uint256 */ // slither-disable-next-line dead-code function sizeOf(List storage self) public view returns (uint256) { return self.size; } /** * @dev Gets the head of the list * @param self stored linked list from contract * @return uint256 the head of the list */ function getHead(List storage self) public view returns (uint256) { return self.list[_HEAD][_NEXT]; } /** * @dev Gets the head of the list * @param self stored linked list from contract * @return uint256 the head of the list */ function getTail(List storage self) public view returns (uint256) { return self.list[_HEAD][_PREV]; } /** * @dev Returns the links of a node as a tuple * @param self stored linked list from contract * @param _node id of the node to get * @return bool, uint256, uint256 true if node exists or false otherwise, previous node, next node */ // slither-disable-next-line dead-code function getNode(List storage self, uint256 _node) public view returns (bool, uint256, uint256) { if (!nodeExists(self, _node)) { return (false, 0, 0); } else { return (true, self.list[_node][_PREV], self.list[_node][_NEXT]); } } /** * @dev Returns the link of a node `_node` in direction `_direction`. * @param self stored linked list from contract * @param _node id of the node to step from * @param _direction direction to step in * @return bool, uint256 true if node exists or false otherwise, node in _direction */ // slither-disable-next-line dead-code function getAdjacent(List storage self, uint256 _node, bool _direction) public view returns (bool, uint256) { if (!nodeExists(self, _node)) { return (false, 0); } else { uint256 adjacent = self.list[_node][_direction]; return (adjacent != _HEAD, adjacent); } } /** * @dev Returns the link of a node `_node` in direction `_NEXT`. * @param self stored linked list from contract * @param _node id of the node to step from * @return bool, uint256 true if node exists or false otherwise, next node */ // slither-disable-next-line dead-code function getNextNode(List storage self, uint256 _node) public view returns (bool, uint256) { return getAdjacent(self, _node, _NEXT); } /** * @dev Returns the link of a node `_node` in direction `_PREV`. * @param self stored linked list from contract * @param _node id of the node to step from * @return bool, uint256 true if node exists or false otherwise, previous node */ // slither-disable-next-line dead-code function getPreviousNode(List storage self, uint256 _node) public view returns (bool, uint256) { return getAdjacent(self, _node, _PREV); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_NEXT`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @return bool true if success, false otherwise */ // slither-disable-next-line dead-code function insertAfter(List storage self, uint256 _node, uint256 _new) public returns (bool) { return _insert(self, _node, _new, _NEXT); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_PREV`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @return bool true if success, false otherwise */ // slither-disable-next-line dead-code function insertBefore(List storage self, uint256 _node, uint256 _new) public returns (bool) { return _insert(self, _node, _new, _PREV); } /** * @dev Removes an entry from the linked list * @param self stored linked list from contract * @param _node node to remove from the list * @return uint256 the removed node */ function remove(List storage self, uint256 _node) public returns (uint256) { if ((_node == _NULL) || (!nodeExists(self, _node))) { return 0; } _createLink(self, self.list[_node][_PREV], self.list[_node][_NEXT], _NEXT); delete self.list[_node][_PREV]; delete self.list[_node][_NEXT]; self.size -= 1; return _node; } /** * @dev Pushes an entry to the head of the linked list * @param self stored linked list from contract * @param _node new entry to push to the head * @return bool true if success, false otherwise */ function pushFront(List storage self, uint256 _node) public returns (bool) { return _push(self, _node, _NEXT); } /** * @dev Pushes an entry to the tail of the linked list * @param self stored linked list from contract * @param _node new entry to push to the tail * @return bool true if success, false otherwise */ function pushBack(List storage self, uint256 _node) public returns (bool) { return _push(self, _node, _PREV); } /** * @dev Pops the first entry from the head of the linked list * @param self stored linked list from contract * @return uint256 the removed node */ // slither-disable-next-line dead-code function popFront(List storage self) public returns (uint256) { return _pop(self, _NEXT); } /** * @dev Pops the first entry from the tail of the linked list * @param self stored linked list from contract * @return uint256 the removed node */ // slither-disable-next-line dead-code function popBack(List storage self) public returns (uint256) { return _pop(self, _PREV); } /** * @dev Pushes an entry to the head of the linked list * @param self stored linked list from contract * @param _node new entry to push to the head * @param _direction push to the head (_NEXT) or tail (_PREV) * @return bool true if success, false otherwise */ function _push(List storage self, uint256 _node, bool _direction) private returns (bool) { return _insert(self, _HEAD, _node, _direction); } /** * @dev Pops the first entry from the linked list * @param self stored linked list from contract * @param _direction pop from the head (_NEXT) or the tail (_PREV) * @return uint256 the removed node */ // slither-disable-next-line dead-code function _pop(List storage self, bool _direction) private returns (uint256) { uint256 adj; (, adj) = getAdjacent(self, _HEAD, _direction); return remove(self, adj); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_direction`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @param _direction direction to insert node in * @return bool true if success, false otherwise */ function _insert(List storage self, uint256 _node, uint256 _new, bool _direction) private returns (bool) { if (!nodeExists(self, _new) && nodeExists(self, _node)) { uint256 c = self.list[_node][_direction]; _createLink(self, _node, _new, _direction); _createLink(self, _new, c, _direction); self.size += 1; return true; } return false; } /** * @dev Creates a bidirectional link between two nodes on direction `_direction` * @param self stored linked list from contract * @param _node existing node * @param _link node to link to in the _direction * @param _direction direction to insert node in */ function _createLink(List storage self, uint256 _node, uint256 _link, bool _direction) private { self.list[_link][!_direction] = _node; self.list[_node][_direction] = _link; } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; // their version was using 8.12? import { StructuredLinkedList } from "src/strategy/StructuredLinkedList.sol"; // https://github.com/Layr-Labs/eigenlayer-contracts/blob/master/src/contracts/libraries/StructuredLinkedList.sol library WithdrawalQueue { using StructuredLinkedList for StructuredLinkedList.List; error CannotInsertZeroAddress(); error UnexpectedNodeRemoved(); error AddToHeadFailed(); error AddToTailFailed(); error NodeDoesNotExist(); /// @notice Returns true if the address is in the queue. function addressExists(StructuredLinkedList.List storage queue, address addr) public view returns (bool) { return StructuredLinkedList.nodeExists(queue, _addressToUint(addr)); } /// @notice Returns the current head. function peekHead(StructuredLinkedList.List storage queue) public view returns (address) { return _uintToAddress(StructuredLinkedList.getHead(queue)); } /// @notice Returns the current tail. function peekTail(StructuredLinkedList.List storage queue) public view returns (address) { return _uintToAddress(StructuredLinkedList.getTail(queue)); } /// @notice Returns the number of items in the queue function sizeOf(StructuredLinkedList.List storage queue) public view returns (uint256) { return StructuredLinkedList.sizeOf(queue); } /// @notice Return all items in the queue /// @dev Enumerates from head to tail function getList(StructuredLinkedList.List storage self) public view returns (address[] memory list) { uint256 size = self.sizeOf(); list = new address[](size); if (size > 0) { uint256 lastNode = self.getHead(); list[0] = _uintToAddress(lastNode); for (uint256 i = 1; i < size; ++i) { (bool exists, uint256 node) = self.getAdjacent(lastNode, true); if (!exists) { revert NodeDoesNotExist(); } list[i] = _uintToAddress(node); lastNode = node; } } } /// @notice Returns the current tail. function popHead(StructuredLinkedList.List storage queue) public returns (address) { return _uintToAddress(StructuredLinkedList.popFront(queue)); } /// @notice remove address toRemove from queue if it exists. function popAddress(StructuredLinkedList.List storage queue, address toRemove) public { uint256 addrAsUint = _addressToUint(toRemove); uint256 _removedNode = StructuredLinkedList.remove(queue, addrAsUint); if (!((_removedNode == addrAsUint) || (_removedNode == 0))) { revert UnexpectedNodeRemoved(); } } /// @notice returns true if there are no addresses in queue. function isEmpty(StructuredLinkedList.List storage queue) public view returns (bool) { return !StructuredLinkedList.listExists(queue); } /// @notice if addr in queue, move it to the top // if addr not in queue, add it to the top of the queue. // if queue is empty, make a new queue with addr as the only node function addToHead(StructuredLinkedList.List storage queue, address addr) public { if (addr == address(0)) { revert CannotInsertZeroAddress(); } popAddress(queue, addr); bool success = StructuredLinkedList.pushFront(queue, _addressToUint(addr)); if (!success) { revert AddToHeadFailed(); } } function getAdjacent( StructuredLinkedList.List storage queue, address addr, bool direction ) public view returns (address) { (bool exists, uint256 addrNum) = queue.getAdjacent(_addressToUint(addr), direction); if (!exists) { return address(0); } return _uintToAddress(addrNum); } /// @notice if addr in queue, move it to the end // if addr not in queue, add it to the end of the queue. // if queue is empty, make a new queue with addr as the only node function addToTail(StructuredLinkedList.List storage queue, address addr) public { if (addr == address(0)) { revert CannotInsertZeroAddress(); } popAddress(queue, addr); bool success = StructuredLinkedList.pushBack(queue, _addressToUint(addr)); if (!success) { revert AddToTailFailed(); } } function _addressToUint(address addr) private pure returns (uint256) { return uint256(uint160(addr)); } function _uintToAddress(uint256 x) private pure returns (address) { return address(uint160(x)); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ECDSA } from "openzeppelin-contracts/utils/cryptography/ECDSA.sol"; import { IERC20Permit } from "openzeppelin-contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; /// @notice ERC20 token functionality converted into a library. Based on OZ's v5 /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/token/ERC20/ERC20.sol library AutopoolToken { struct TokenData { /// @notice Token balances /// @dev account => balance mapping(address => uint256) balances; /// @notice Account spender allowances /// @dev account => spender => allowance mapping(address => mapping(address => uint256)) allowances; /// @notice Total supply of the pool. Be careful when using this directly from the struct. The pool itself /// modifies this number based on unlocked profited shares uint256 totalSupply; /// @notice ERC20 Permit nonces /// @dev account -> nonce. Exposed via `nonces(owner)` mapping(address => uint256) nonces; } /// @notice EIP2612 permit type hash bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /// @notice EIP712 domain type hash bytes32 public constant TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); /// @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. /// @param sender Address whose tokens are being transferred. /// @param balance Current balance for the interacting account. /// @param needed Minimum amount required to perform a transfer. error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /// @dev Indicates a failure with the token `sender`. Used in transfers. /// @param sender Address whose tokens are being transferred. error ERC20InvalidSender(address sender); /// @dev Indicates a failure with the token `receiver`. Used in transfers. /// @param receiver Address to which tokens are being transferred. error ERC20InvalidReceiver(address receiver); /// @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. ///@param spender Address that may be allowed to operate on tokens without being their owner. /// @param allowance Amount of tokens a `spender` is allowed to operate with. ///@param needed Minimum amount required to perform a transfer. error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /// @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. /// @param approver Address initiating an approval operation. error ERC20InvalidApprover(address approver); /// @dev Indicates a failure with the `spender` to be approved. Used in approvals. /// @param spender Address that may be allowed to operate on tokens without being their owner. error ERC20InvalidSpender(address spender); /// @dev Permit deadline has expired. error ERC2612ExpiredSignature(uint256 deadline); /// @dev Mismatched signature. error ERC2612InvalidSigner(address signer, address owner); /// @dev The nonce used for an `account` is not the expected current nonce. error InvalidAccountNonce(address account, uint256 currentNonce); /// @dev Emitted when `value` tokens are moved from one account `from` to another `to`. 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 Sets a `value` amount of tokens as the allowance of `spender` over the caller's tokens. function approve(TokenData storage data, address spender, uint256 value) external returns (bool) { address owner = msg.sender; approve(data, owner, spender, value); return true; } /// @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. function approve(TokenData storage data, address owner, address spender, uint256 value) public { _approve(data, owner, spender, value, true); } function transfer(TokenData storage data, address to, uint256 value) external returns (bool) { address owner = msg.sender; _transfer(data, owner, to, value); return true; } /// @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism. /// value` is then deducted from the caller's allowance. function transferFrom(TokenData storage data, address from, address to, uint256 value) external returns (bool) { address spender = msg.sender; _spendAllowance(data, from, spender, value); _transfer(data, from, to, value); return true; } /// @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). function mint(TokenData storage data, address account, uint256 value) external { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(data, address(0), account, value); } /// @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. function burn(TokenData storage data, address account, uint256 value) external { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(data, account, address(0), value); } function permit( TokenData storage data, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external { if (block.timestamp > deadline) { revert ERC2612ExpiredSignature(deadline); } uint256 nonce; // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be // decremented or reset. This guarantees that the nonce never overflows. unchecked { // It is important to do x++ and not ++x here. Nonces starts at 0 nonce = data.nonces[owner]++; } bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonce, deadline)); bytes32 hash = ECDSA.toTypedDataHash(IERC20Permit(address(this)).DOMAIN_SEPARATOR(), structHash); address signer = ECDSA.recover(hash, v, r, s); if (signer != owner) { revert ERC2612InvalidSigner(signer, owner); } approve(data, owner, spender, value); } /// @dev Moves a `value` amount of tokens from `from` to `to`. function _transfer(TokenData storage data, address from, address to, uint256 value) private { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(data, from, to, value); } /// @dev Updates `owner` s allowance for `spender` based on spent `value`. function _spendAllowance(TokenData storage data, address owner, address spender, uint256 value) private { uint256 currentAllowance = data.allowances[owner][spender]; if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(data, owner, spender, currentAllowance - value, false); } } } /// @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` /// (or `to`) is the zero address. function _update(TokenData storage data, address from, address to, uint256 value) private { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows data.totalSupply += value; } else { uint256 fromBalance = data.balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. data.balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. data.totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. data.balances[to] += value; } } emit Transfer(from, to, value); } /// @dev Variant of `_approve` with an optional flag to enable or disable the Approval event. function _approve(TokenData storage data, address owner, address spender, uint256 value, bool emitEvent) private { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } data.allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IBaseRewarder { event RewardAdded( uint256 reward, uint256 rewardRate, uint256 lastUpdateBlock, uint256 periodInBlockFinish, uint256 historicalRewards ); event UserRewardUpdated( address indexed user, uint256 amount, uint256 rewardPerTokenStored, uint256 lastUpdateBlock ); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event QueuedRewardsUpdated(uint256 startingQueuedRewards, uint256 startingNewRewards, uint256 queuedRewards); event AddedToWhitelist(address indexed wallet); event RemovedFromWhitelist(address indexed wallet); event TokeLockDurationUpdated(uint256 newDuration); /** * @notice Claims and transfers all rewards for the specified account */ function getReward() external; /** * @notice Stakes the specified amount of tokens for the specified account. * @param account The address of the account to stake tokens for. * @param amount The amount of tokens to stake. */ function stake(address account, uint256 amount) external; /** * @notice Calculate the earned rewards for an account. * @param account Address of the account. * @return The earned rewards for the given account. */ function earned(address account) external view returns (uint256); /** * @notice Calculates the rewards per token for the current block. * @dev The total amount of rewards available in the system is fixed, and it needs to be distributed among the users * based on their token balances and staking duration. * Rewards per token represent the amount of rewards that each token is entitled to receive at the current block. * The calculation takes into account the reward rate, the time duration since the last update, * and the total supply of tokens in the staking pool. * @return The updated rewards per token value for the current block. */ function rewardPerToken() external view returns (uint256); /** * @notice Get the current reward rate per block. * @return The current reward rate per block. */ function rewardRate() external view returns (uint256); /** * @notice Get the current TOKE lock duration. * @return The current TOKE lock duration. */ function tokeLockDuration() external view returns (uint256); /** * @notice Get the last block where rewards are applicable. * @return The last block number where rewards are applicable. */ function lastBlockRewardApplicable() external view returns (uint256); /** * @notice The total amount of tokens staked */ function totalSupply() external view returns (uint256); /** * @notice The amount of tokens staked for the specified account * @param account The address of the account to get the balance of */ function balanceOf(address account) external view returns (uint256); /** * @notice Queue new rewards to be distributed. * @param newRewards The amount of new rewards to be queued. */ function queueNewRewards(uint256 newRewards) external; /** * @notice Token distributed as rewards * @return reward token address */ function rewardToken() external view returns (address); /** * @notice Add an address to the whitelist. * @param wallet The address to be added to the whitelist. */ function addToWhitelist(address wallet) external; /** * @notice Remove an address from the whitelist. * @param wallet The address to be removed from the whitelist. */ function removeFromWhitelist(address wallet) external; /** * @notice Check if an address is whitelisted. * @param wallet The address to be checked. * @return bool indicating if the address is whitelisted. */ function isWhitelisted(address wallet) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IBaseRewarder } from "src/interfaces/rewarders/IBaseRewarder.sol"; interface IExtraRewarder is IBaseRewarder { /** * @notice Withdraws the specified amount of tokens from the vault for the specified account. * @param account The address of the account to withdraw tokens for. * @param amount The amount of tokens to withdraw. */ function withdraw(address account, uint256 amount) external; /** * @notice Claims and transfers all rewards for the specified account from this contract. * @param account The address of the account to claim rewards for. */ function getReward(address account) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IBaseAssetVault { /// @notice Asset that this Vault primarily manages /// @dev Vault decimals should be the same as the baseAsset function baseAsset() external view returns (address); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ILSTStats } from "src/interfaces/stats/ILSTStats.sol"; /// @title Return stats DEXs with LSTs interface IDexLSTStats { event DexSnapshotTaken(uint256 snapshotTimestamp, uint256 priorFeeApr, uint256 newFeeApr, uint256 unfilteredFeeApr); struct StakingIncentiveStats { // time-weighted average total supply to prevent spikes/attacks from impacting rebalancing uint256 safeTotalSupply; // rewardTokens, annualizedRewardAmounts, and periodFinishForRewards will match indexes // they are split to workaround an issue with forge having nested structs // address of the reward tokens address[] rewardTokens; // the annualized reward rate for the reward token uint256[] annualizedRewardAmounts; // the timestamp for when the rewards are set to terminate uint40[] periodFinishForRewards; // incentive rewards score. max 48, min 0 uint8 incentiveCredits; } struct DexLSTStatsData { uint256 lastSnapshotTimestamp; uint256 feeApr; uint256[] reservesInEth; StakingIncentiveStats stakingIncentiveStats; ILSTStats.LSTStatsData[] lstStatsData; } /// @notice Get the current stats for the DEX with underlying LST tokens /// @dev Returned data is a combination of current data and filtered snapshots /// @return dexLSTStatsData current data on the DEX function current() external returns (DexLSTStatsData memory dexLSTStatsData); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Return stats on base LSTs interface ILSTStats { struct LSTStatsData { uint256 lastSnapshotTimestamp; uint256 baseApr; int256 discount; // positive number is a discount, negative is a premium uint24[10] discountHistory; // 7 decimal precision uint40[5] discountTimestampByPercent; // each index is the timestamp that the token reached that discount uint256[] slashingCosts; uint256[] slashingTimestamps; } /// @notice Used to transfer LST snapshot data to other chain. struct LSTDestinationInfo { uint256 snapshotTimestamp; uint256 newBaseApr; uint256 currentEthPerToken; } /// @notice Get the current stats for the LST /// @dev Returned data is a combination of current data and filtered snapshots /// @return lstStatsData current data on the LST function current() external returns (LSTStatsData memory lstStatsData); /// @notice Get the EthPerToken (or Share) for the LST /// @return ethPerShare the backing eth for the LST function calculateEthPerToken() external view returns (uint256 ethPerShare); /// @notice Get if the underlying LST token is rebasing /// @return rebasing is true if the lst is a rebasing token function isRebasing() external view returns (bool rebasing); }
{ "remappings": [ "forge-std/=lib/forge-std/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "src/=src/", "test/=test/", "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/", "erc4626-tests/=lib/erc4626-tests/", "prb-math/=lib/prb-math/", "crytic/properties/=lib/properties/", "ERC4626/=lib/properties/lib/ERC4626/contracts/", "properties/=lib/properties/contracts/", "solmate/=lib/properties/lib/solmate/src/", "usingtellor/=lib/usingtellor/contracts/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract ISystemRegistry","name":"_systemRegistry","type":"address"},{"internalType":"uint256","name":"_startEpoch","type":"uint256"},{"internalType":"uint256","name":"_minStakeDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessDenied","type":"error"},{"inputs":[],"name":"AlreadyUnlocked","type":"error"},{"inputs":[],"name":"ExtendDurationTooShort","type":"error"},{"inputs":[],"name":"IncorrectStakingAmount","type":"error"},{"inputs":[],"name":"InsufficientAmount","type":"error"},{"inputs":[],"name":"InsufficientFunds","type":"error"},{"inputs":[],"name":"InvalidDurationLength","type":"error"},{"inputs":[],"name":"InvalidLockupIds","type":"error"},{"inputs":[{"internalType":"string","name":"paramName","type":"string"}],"name":"InvalidParam","type":"error"},{"inputs":[],"name":"LockupDoesNotExist","type":"error"},{"inputs":[],"name":"NoRewardsToClaim","type":"error"},{"inputs":[],"name":"NotUnlockableYet","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__Exp2InputTooBig","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__LogInputTooSmall","type":"error"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"}],"name":"PRBMath__MulDivFixedPointOverflow","type":"error"},{"inputs":[],"name":"StakingDurationTooLong","type":"error"},{"inputs":[],"name":"StakingDurationTooShort","type":"error"},{"inputs":[],"name":"StakingPointsExceeded","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"TransfersDisabled","type":"error"},{"inputs":[],"name":"UndefinedAddress","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[{"internalType":"string","name":"paramName","type":"string"}],"name":"ZeroAddress","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":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldEnd","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newEnd","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldPoints","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPoints","type":"uint256"}],"name":"Extend","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accRewardPerShare","type":"uint256"}],"name":"RewardsAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldDuration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"SetMaxStakeDuration","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"end","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"points","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"end","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"points","type":"uint256"}],"name":"Unstake","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_STAKE_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_STAKE_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accessController","outputs":[{"internalType":"contract IAccessController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"addWETHRewards","outputs":[],"stateMutability":"nonpayable","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":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"collectRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"lockupIds","type":"uint256[]"},{"internalType":"uint256[]","name":"durations","type":"uint256[]"}],"name":"extend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getLockups","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"points","type":"uint256"}],"internalType":"struct IAccToke.Lockup[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSystemRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"uint256","name":"amount","type":"uint256"}],"name":"isStakeableAmount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockups","outputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"points","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxStakeDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minStakeDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"previewPoints","outputs":[{"internalType":"uint256","name":"points","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"previewRewards","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"previewRewards","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardDebtPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardsClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxStakeDuration","type":"uint256"}],"name":"setMaxStakeDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toke","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"lockupIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000b20193f43c9a7184f3cbed9bad59154da01488b4000000000000000000000000000000000000000000000000000000006643c0eb0000000000000000000000000000000000000000000000000000000000278d00
-----Decoded View---------------
Arg [0] : _systemRegistry (address): 0xB20193f43C9a7184F3cbeD9bAD59154da01488b4
Arg [1] : _startEpoch (uint256): 1715716331
Arg [2] : _minStakeDuration (uint256): 2592000
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000b20193f43c9a7184f3cbed9bad59154da01488b4
Arg [1] : 000000000000000000000000000000000000000000000000000000006643c0eb
Arg [2] : 0000000000000000000000000000000000000000000000000000000000278d00
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 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.