ERC-20
Overview
Max Total Supply
100.991992453239576599 YSFRAX6MJD
Holders
2
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
0.991992453239576599 YSFRAX6MJDValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Strategy
Compiler Version
v0.8.15+commit.e14f2714
Optimization Enabled:
Yes with 100 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity >=0.8.13; import "@yield-protocol/utils-v2/contracts/access/AccessControl.sol"; import "@yield-protocol/utils-v2/contracts/token/SafeERC20Namer.sol"; import "@yield-protocol/utils-v2/contracts/token/MinimalTransferHelper.sol"; import "@yield-protocol/utils-v2/contracts/token/IERC20.sol"; import "@yield-protocol/utils-v2/contracts/token/ERC20Rewards.sol"; import "@yield-protocol/utils-v2/contracts/cast/CastU256I128.sol"; import "@yield-protocol/utils-v2/contracts/cast/CastU128I128.sol"; import "@yield-protocol/vault-v2/contracts/interfaces/DataTypes.sol"; import "@yield-protocol/vault-v2/contracts/interfaces/ICauldron.sol"; import "@yield-protocol/vault-v2/contracts/interfaces/ILadle.sol"; import "@yield-protocol/yieldspace-tv/src/interfaces/IPool.sol"; library DivUp { /// @dev Divide a between b, rounding up function divUp(uint256 a, uint256 b) internal pure returns(uint256 c) { // % 0 panics even inside the unchecked, and so prevents / 0 afterwards // https://docs.soliditylang.org/en/v0.8.9/types.html unchecked { a % b == 0 ? c = a / b : c = a / b + 1; } } } /// @dev The Pool contract exchanges base for fyToken at a price defined by a specific formula. contract Strategy is AccessControl, ERC20Rewards { using DivUp for uint256; using MinimalTransferHelper for IERC20; using CastU256U128 for uint256; // Inherited from ERC20Rewards using CastU256I128 for uint256; using CastU128I128 for uint128; event YieldSet(ILadle ladle, ICauldron cauldron); event TokenJoinReset(address join); event TokenIdSet(bytes6 id); event NextPoolSet(IPool indexed pool, bytes6 indexed seriesId); event PoolEnded(address pool); event PoolStarted(address pool); IERC20 public immutable base; // Base token for this strategy bytes6 public baseId; // Identifier for the base token in Yieldv2 address public baseJoin; // Yield v2 Join to deposit token when borrowing ILadle public ladle; // Gateway to the Yield v2 Collateralized Debt Engine ICauldron public cauldron; // Accounts in the Yield v2 Collateralized Debt Engine IPool public pool; // Current pool that this strategy invests in bytes6 public seriesId; // SeriesId for the current pool in Yield v2 IFYToken public fyToken; // Current fyToken for this strategy IPool public nextPool; // Next pool that this strategy will invest in bytes6 public nextSeriesId; // SeriesId for the next pool in Yield v2 uint256 public cached; // LP tokens owned by the strategy after the last operation constructor(string memory name, string memory symbol, ILadle ladle_, IERC20 base_, bytes6 baseId_,address baseJoin_) ERC20Rewards(name, symbol, SafeERC20Namer.tokenDecimals(address(base_))) { // The strategy asset inherits the decimals of its base, that matches the decimals of the fyToken and pool base = base_; baseId = baseId_; baseJoin = baseJoin_; ladle = ladle_; cauldron = ladle_.cauldron(); } modifier poolSelected() { require ( pool != IPool(address(0)), "Pool not selected" ); _; } modifier poolNotSelected() { require ( pool == IPool(address(0)), "Pool selected" ); _; } modifier afterMaturity() { require ( uint32(block.timestamp) >= fyToken.maturity(), "Only after maturity" ); _; } /// @dev Set a new Ladle and Cauldron /// @notice Use with extreme caution, only for Ladle replacements function setYield(ILadle ladle_) external poolNotSelected auth { ladle = ladle_; ICauldron cauldron_ = ladle_.cauldron(); cauldron = cauldron_; emit YieldSet(ladle_, cauldron_); } /// @dev Set a new base token id /// @notice Use with extreme caution, only for token reconfigurations in Cauldron function setTokenId(bytes6 baseId_) external poolNotSelected auth { require( ladle.cauldron().assets(baseId_) == address(base), "Mismatched baseId" ); baseId = baseId_; emit TokenIdSet(baseId_); } /// @dev Reset the base token join /// @notice Use with extreme caution, only for Join replacements function resetTokenJoin() external poolNotSelected auth { baseJoin = address(ladle.joins(baseId)); emit TokenJoinReset(baseJoin); } /// @dev Set the next pool to invest in function setNextPool(IPool pool_, bytes6 seriesId_) external auth { require( base == pool_.base(), "Mismatched base" ); DataTypes.Series memory series = cauldron.series(seriesId_); require( address(series.fyToken) == address(pool_.fyToken()), "Mismatched seriesId" ); nextPool = pool_; nextSeriesId = seriesId_; emit NextPoolSet(pool_, seriesId_); } /// @dev Start the strategy investments in the next pool /// @param minRatio Minimum allowed ratio between the reserves of the next pool, as a fixed point number with 18 decimals (base/fyToken) /// @param maxRatio Maximum allowed ratio between the reserves of the next pool, as a fixed point number with 18 decimals (base/fyToken) /// @notice When calling this function for the first pool, some underlying needs to be transferred to the strategy first, using a batchable router. function startPool(uint256 minRatio, uint256 maxRatio) external auth poolNotSelected { IPool nextPool_ = nextPool; require(nextPool_ != IPool(address(0)), "Next pool not set"); // Caching IPool pool_ = nextPool_; IFYToken fyToken_ = IFYToken(address(pool_.fyToken())); bytes6 seriesId_ = nextSeriesId; pool = pool_; fyToken = fyToken_; seriesId = seriesId_; delete nextPool; delete nextSeriesId; // Find pool proportion p = tokenReserves/(tokenReserves + fyTokenReserves) // Deposit (investment * p) base to borrow (investment * p) fyToken // (investment * p) fyToken + (investment * (1 - p)) base = investment // (investment * p) / ((investment * p) + (investment * (1 - p))) = p // (investment * (1 - p)) / ((investment * p) + (investment * (1 - p))) = 1 - p uint256 baseBalance = base.balanceOf(address(this)); require(baseBalance > 0, "No funds to start with"); // The Pool mints based on cached values, not actual ones. Consider bundling a `pool.sync` // call if they differ. A griefing attack exists by donating one fyToken wei to the pool // before `startPool`, solved the same way. uint256 baseInPool = base.balanceOf(address(pool_)); uint256 fyTokenInPool = fyToken_.balanceOf(address(pool_)); uint256 baseToPool = (baseBalance * baseInPool).divUp(baseInPool + fyTokenInPool); // Rounds up uint256 fyTokenToPool = baseBalance - baseToPool; // fyTokenToPool is rounded down // Mint fyToken with underlying base.safeTransfer(baseJoin, fyTokenToPool); fyToken.mintWithUnderlying(address(pool_), fyTokenToPool); // Mint LP tokens with (investment * p) fyToken and (investment * (1 - p)) base base.safeTransfer(address(pool_), baseToPool); (,, cached) = pool_.mint(address(this), address(this), minRatio, maxRatio); if (_totalSupply == 0) _mint(msg.sender, cached); // Initialize the strategy if needed emit PoolStarted(address(pool_)); } /// @dev Divest out of a pool once it has matured function endPool() external afterMaturity { // Caching IPool pool_ = pool; IFYToken fyToken_ = fyToken; uint256 toDivest = pool_.balanceOf(address(this)); // Burn lpTokens IERC20(address(pool_)).safeTransfer(address(pool_), toDivest); (,, uint256 fyTokenDivested) = pool_.burn(address(this), address(this), 0, type(uint256).max); // We don't care about slippage, because the strategy holds to maturity // Redeem any fyToken IERC20(address(fyToken_)).safeTransfer(address(fyToken_), fyTokenDivested); fyToken_.redeem(address(this), fyTokenDivested); emit PoolEnded(address(pool_)); // Clear up delete pool; delete fyToken; delete seriesId; delete cached; } /// @dev Mint strategy tokens. /// @notice The lp tokens that the user contributes need to have been transferred previously, using a batchable router. function mint(address to) external poolSelected returns (uint256 minted) { // minted = supply * value(deposit) / value(strategy) uint256 cached_ = cached; uint256 deposit = pool.balanceOf(address(this)) - cached_; minted = _totalSupply * deposit / cached_; cached = cached_ + deposit; _mint(to, minted); } /// @dev Burn strategy tokens to withdraw lp tokens. The lp tokens obtained won't be of the same pool that the investor deposited, /// if the strategy has swapped to another pool. /// @notice The strategy tokens that the user burns need to have been transferred previously, using a batchable router. function burn(address to) external poolSelected returns (uint256 withdrawal) { // strategy * burnt/supply = withdrawal uint256 cached_ = cached; uint256 burnt = _balanceOf[address(this)]; withdrawal = cached_ * burnt / _totalSupply; cached = cached_ - withdrawal; _burn(address(this), burnt); IERC20(address(pool)).safeTransfer(to, withdrawal); } /// @dev Burn strategy tokens to withdraw base tokens. It can be called only when a pool is not selected. /// @notice The strategy tokens that the user burns need to have been transferred previously, using a batchable router. function burnForBase(address to) external poolNotSelected returns (uint256 withdrawal) { // strategy * burnt/supply = withdrawal uint256 burnt = _balanceOf[address(this)]; withdrawal = base.balanceOf(address(this)) * burnt / _totalSupply; _burn(address(this), burnt); base.safeTransfer(to, withdrawal); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.5.0; import "../token/IERC20Metadata.sol"; import "../utils/AddressStringUtil.sol"; // produces token descriptors from inconsistent or absent ERC20 symbol implementations that can return string or bytes32 // this library will always produce a string symbol to represent the token library SafeERC20Namer { function bytes32ToString(bytes32 x) private pure returns (string memory) { bytes memory bytesString = new bytes(32); uint256 charCount = 0; for (uint256 j = 0; j < 32; j++) { bytes1 char = x[j]; if (char != 0) { bytesString[charCount] = char; charCount++; } } bytes memory bytesStringTrimmed = new bytes(charCount); for (uint256 j = 0; j < charCount; j++) { bytesStringTrimmed[j] = bytesString[j]; } return string(bytesStringTrimmed); } // assumes the data is in position 2 function parseStringData(bytes memory b) private pure returns (string memory) { uint256 charCount = 0; // first parse the charCount out of the data for (uint256 i = 32; i < 64; i++) { charCount <<= 8; charCount += uint8(b[i]); } bytes memory bytesStringTrimmed = new bytes(charCount); for (uint256 i = 0; i < charCount; i++) { bytesStringTrimmed[i] = b[i + 64]; } return string(bytesStringTrimmed); } // uses a heuristic to produce a token name from the address // the heuristic returns the full hex of the address string in upper case function addressToName(address token) private pure returns (string memory) { return AddressStringUtil.toAsciiString(token, 40); } // uses a heuristic to produce a token symbol from the address // the heuristic returns the first 6 hex of the address string in upper case function addressToSymbol(address token) private pure returns (string memory) { return AddressStringUtil.toAsciiString(token, 6); } // calls an external view token contract method that returns a symbol or name, and parses the output into a string function callAndParseStringReturn(address token, bytes4 selector) private view returns (string memory) { (bool success, bytes memory data) = token.staticcall(abi.encodeWithSelector(selector)); // if not implemented, or returns empty data, return empty string if (!success || data.length == 0) { return ""; } // bytes32 data always has length 32 if (data.length == 32) { bytes32 decoded = abi.decode(data, (bytes32)); return bytes32ToString(decoded); } else if (data.length > 64) { return abi.decode(data, (string)); } return ""; } // attempts to extract the token symbol. if it does not implement symbol, returns a symbol derived from the address function tokenSymbol(address token) public view returns (string memory) { string memory symbol = callAndParseStringReturn(token, IERC20Metadata.symbol.selector); if (bytes(symbol).length == 0) { // fallback to 6 uppercase hex of address return addressToSymbol(token); } return symbol; } // attempts to extract the token name. if it does not implement name, returns a name derived from the address function tokenName(address token) public view returns (string memory) { string memory name = callAndParseStringReturn(token, IERC20Metadata.name.selector); if (bytes(name).length == 0) { // fallback to full hex of address return addressToName(token); } return name; } /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value. /// @param token The address of the ERC-20 token contract. /// @return (uint8) Token decimals. function tokenDecimals(address token) public view returns (uint8) { (bool success, bytes memory data) = token.staticcall(abi.encodeWithSelector(IERC20Metadata.decimals.selector)); return success && data.length == 32 ? abi.decode(data, (uint8)) : 18; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. * * Roles are referred to by their `bytes4` identifier. These are expected to be the * signatures for all the functions in the contract. Special roles should be exposed * in the external API and be unique: * * ``` * bytes4 public constant ROOT = 0x00000000; * ``` * * Roles represent restricted access to a function call. For that purpose, use {auth}: * * ``` * function foo() public auth { * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `ROOT`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {setRoleAdmin}. * * WARNING: The `ROOT` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ contract AccessControl { struct RoleData { mapping (address => bool) members; bytes4 adminRole; } mapping (bytes4 => RoleData) private _roles; bytes4 public constant ROOT = 0x00000000; bytes4 public constant ROOT4146650865 = 0x00000000; // Collision protection for ROOT, test with ROOT12007226833() bytes4 public constant LOCK = 0xFFFFFFFF; // Used to disable further permissioning of a function bytes4 public constant LOCK8605463013 = 0xFFFFFFFF; // Collision protection for LOCK, test with LOCK10462387368() /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role * * `ROOT` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes4 indexed role, bytes4 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call. */ event RoleGranted(bytes4 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(bytes4 indexed role, address indexed account, address indexed sender); /** * @dev Give msg.sender the ROOT role and create a LOCK role with itself as the admin role and no members. * Calling setRoleAdmin(msg.sig, LOCK) means no one can grant that msg.sig role anymore. */ constructor () { _grantRole(ROOT, msg.sender); // Grant ROOT to msg.sender _setRoleAdmin(LOCK, LOCK); // Create the LOCK role by setting itself as its own admin, creating an independent role tree } /** * @dev Each function in the contract has its own role, identified by their msg.sig signature. * ROOT can give and remove access to each function, lock any further access being granted to * a specific action, or even create other roles to delegate admin control over a function. */ modifier auth() { require (_hasRole(msg.sig, msg.sender), "Access denied"); _; } /** * @dev Allow only if the caller has been granted the admin role of `role`. */ modifier admin(bytes4 role) { require (_hasRole(_getRoleAdmin(role), msg.sender), "Only admin"); _; } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes4 role, address account) external view returns (bool) { return _hasRole(role, account); } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes4 role) external view returns (bytes4) { return _getRoleAdmin(role); } /** * @dev Sets `adminRole` as ``role``'s admin role. * If ``role``'s admin role is not `adminRole` emits a {RoleAdminChanged} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function setRoleAdmin(bytes4 role, bytes4 adminRole) external virtual admin(role) { _setRoleAdmin(role, adminRole); } /** * @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(bytes4 role, address account) external virtual admin(role) { _grantRole(role, account); } /** * @dev Grants all of `role` in `roles` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - For each `role` in `roles`, the caller must have ``role``'s admin role. */ function grantRoles(bytes4[] memory roles, address account) external virtual { for (uint256 i = 0; i < roles.length; i++) { require (_hasRole(_getRoleAdmin(roles[i]), msg.sender), "Only admin"); _grantRole(roles[i], account); } } /** * @dev Sets LOCK as ``role``'s admin role. LOCK has no members, so this disables admin management of ``role``. * Emits a {RoleAdminChanged} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function lockRole(bytes4 role) external virtual admin(role) { _setRoleAdmin(role, LOCK); } /** * @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(bytes4 role, address account) external virtual admin(role) { _revokeRole(role, account); } /** * @dev Revokes all of `role` in `roles` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - For each `role` in `roles`, the caller must have ``role``'s admin role. */ function revokeRoles(bytes4[] memory roles, address account) external virtual { for (uint256 i = 0; i < roles.length; i++) { require (_hasRole(_getRoleAdmin(roles[i]), msg.sender), "Only admin"); _revokeRole(roles[i], account); } } /** * @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(bytes4 role, address account) external virtual { require(account == msg.sender, "Renounce only for self"); _revokeRole(role, account); } function _hasRole(bytes4 role, address account) internal view returns (bool) { return _roles[role].members[account]; } function _getRoleAdmin(bytes4 role) internal view returns (bytes4) { return _roles[role].adminRole; } function _setRoleAdmin(bytes4 role, bytes4 adminRole) internal virtual { if (_getRoleAdmin(role) != adminRole) { _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, adminRole); } } function _grantRole(bytes4 role, address account) internal { if (!_hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, msg.sender); } } function _revokeRole(bytes4 role, address account) internal { if (_hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, msg.sender); } } }
// SPDX-License-Identifier: MIT // Taken from https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol pragma solidity >=0.6.0; import "./IERC20.sol"; import "../utils/RevertMsgExtractor.sol"; // helper methods for transferring ERC20 tokens that do not consistently return true/false library MinimalTransferHelper { /// @notice Transfers tokens from msg.sender to a recipient /// @dev Errors with the underlying revert message if transfer fails /// @param token The contract address of the token which will be transferred /// @param to The recipient of the transfer /// @param value The value of the transfer function safeTransfer( IERC20 token, address to, uint256 value ) internal { (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(IERC20.transfer.selector, to, value)); if (!(success && (data.length == 0 || abi.decode(data, (bool))))) revert(RevertMsgExtractor.getRevertMsg(data)); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; library CastU256I128 { /// @dev Safe casting from uint256 to int256 function i128(uint256 x) internal pure returns(int128) { require(x <= uint256(int256(type(int128).max)), "Cast overflow"); return int128(int256(x)); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool); /** * @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); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IFYToken.sol"; import "./IOracle.sol"; library DataTypes { // ======== Cauldron data types ======== struct Series { IFYToken fyToken; // Redeemable token for the series. bytes6 baseId; // Asset received on redemption. uint32 maturity; // Unix time at which redemption becomes possible. // bytes2 free } struct Debt { uint96 max; // Maximum debt accepted for a given underlying, across all series uint24 min; // Minimum debt accepted for a given underlying, across all series uint8 dec; // Multiplying factor (10**dec) for max and min uint128 sum; // Current debt for a given underlying, across all series } struct SpotOracle { IOracle oracle; // Address for the spot price oracle uint32 ratio; // Collateralization ratio to multiply the price for // bytes8 free } struct Vault { address owner; bytes6 seriesId; // Each vault is related to only one series, which also determines the underlying. bytes6 ilkId; // Asset accepted as collateral } struct Balances { uint128 art; // Debt amount uint128 ink; // Collateral amount } // ======== Witch data types ======== struct Auction { address owner; uint32 start; bytes6 baseId; // We cache the baseId here uint128 ink; uint128 art; address auctioneer; bytes6 ilkId; // We cache the ilkId here bytes6 seriesId; // We cache the seriesId here } struct Line { uint32 duration; // Time that auctions take to go to minimal price and stay there uint64 vaultProportion; // Proportion of the vault that is available each auction (1e18 = 100%) uint64 collateralProportion; // Proportion of collateral that is sold at auction start (1e18 = 100%) } struct Limits { uint128 max; // Maximum concurrent auctioned collateral uint128 sum; // Current concurrent auctioned collateral } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IERC20.sol"; import "./ERC20Permit.sol"; import "../access/AccessControl.sol"; import "../utils/RevertMsgExtractor.sol"; import "../token/MinimalTransferHelper.sol"; import "../cast/CastU256U128.sol"; import "../cast/CastU256U32.sol"; /// @dev A token inheriting from ERC20Rewards will reward token holders with a rewards token. /// The rewarded amount will be a fixed wei per second, distributed proportionally to token holders /// by the size of their holdings. contract ERC20Rewards is AccessControl, ERC20Permit { using MinimalTransferHelper for IERC20; using CastU256U32 for uint256; using CastU256U128 for uint256; event RewardsTokenSet(IERC20 token); event RewardsSet(uint32 start, uint32 end, uint256 rate); event RewardsPerTokenUpdated(uint256 accumulated); event UserRewardsUpdated(address user, uint256 userRewards, uint256 paidRewardPerToken); event Claimed(address receiver, uint256 claimed); struct RewardsPeriod { uint32 start; // Start time for the current rewardsToken schedule uint32 end; // End time for the current rewardsToken schedule } struct RewardsPerToken { uint128 accumulated; // Accumulated rewards per token for the period, scaled up by 1e18 uint32 lastUpdated; // Last time the rewards per token accumulator was updated uint96 rate; // Wei rewarded per second among all token holders } struct UserRewards { uint128 accumulated; // Accumulated rewards for the user until the checkpoint uint128 checkpoint; // RewardsPerToken the last time the user rewards were updated } IERC20 public rewardsToken; // Token used as rewards RewardsPeriod public rewardsPeriod; // Period in which rewards are accumulated by users RewardsPerToken public rewardsPerToken; // Accumulator to track rewards per token mapping (address => UserRewards) public rewards; // Rewards accumulated by users constructor(string memory name, string memory symbol, uint8 decimals) ERC20Permit(name, symbol, decimals) { } /// @dev Return the earliest of two timestamps function earliest(uint32 x, uint32 y) internal pure returns (uint32 z) { z = (x < y) ? x : y; } /// @dev Set a rewards token. /// @notice Careful, this can only be done once. function setRewardsToken(IERC20 rewardsToken_) external auth { require(rewardsToken == IERC20(address(0)), "Rewards token already set"); rewardsToken = rewardsToken_; emit RewardsTokenSet(rewardsToken_); } /// @dev Set a rewards schedule function setRewards(uint32 start, uint32 end, uint96 rate) external auth { require( start <= end, "Incorrect input" ); require( rewardsToken != IERC20(address(0)), "Rewards token not set" ); // A new rewards program can be set if one is not running require( block.timestamp.u32() < rewardsPeriod.start || block.timestamp.u32() > rewardsPeriod.end, "Ongoing rewards" ); rewardsPeriod.start = start; rewardsPeriod.end = end; // If setting up a new rewards program, the rewardsPerToken.accumulated is used and built upon // New rewards start accumulating from the new rewards program start // Any unaccounted rewards from last program can still be added to the user rewards // Any unclaimed rewards can still be claimed rewardsPerToken.lastUpdated = start; rewardsPerToken.rate = rate; emit RewardsSet(start, end, rate); } /// @dev Update the rewards per token accumulator. /// @notice Needs to be called on each liquidity event function _updateRewardsPerToken() internal { RewardsPerToken memory rewardsPerToken_ = rewardsPerToken; RewardsPeriod memory rewardsPeriod_ = rewardsPeriod; uint256 totalSupply_ = _totalSupply; // We skip the update if the program hasn't started if (block.timestamp.u32() < rewardsPeriod_.start) return; // Find out the unaccounted time uint32 end = earliest(block.timestamp.u32(), rewardsPeriod_.end); uint256 unaccountedTime = end - rewardsPerToken_.lastUpdated; // Cast to uint256 to avoid overflows later on if (unaccountedTime == 0) return; // We skip the storage changes if already updated in the same block // Calculate and update the new value of the accumulator. unaccountedTime casts it into uint256, which is desired. // If the first mint happens mid-program, we don't update the accumulator, no one gets the rewards for that period. if (totalSupply_ != 0) rewardsPerToken_.accumulated = (rewardsPerToken_.accumulated + 1e18 * unaccountedTime * rewardsPerToken_.rate / totalSupply_).u128(); // The rewards per token are scaled up for precision rewardsPerToken_.lastUpdated = end; rewardsPerToken = rewardsPerToken_; emit RewardsPerTokenUpdated(rewardsPerToken_.accumulated); } /// @dev Accumulate rewards for an user. /// @notice Needs to be called on each liquidity event, or when user balances change. function _updateUserRewards(address user) internal returns (uint128) { UserRewards memory userRewards_ = rewards[user]; RewardsPerToken memory rewardsPerToken_ = rewardsPerToken; // Calculate and update the new value user reserves. _balanceOf[user] casts it into uint256, which is desired. userRewards_.accumulated = (userRewards_.accumulated + _balanceOf[user] * (rewardsPerToken_.accumulated - userRewards_.checkpoint) / 1e18).u128(); // We must scale down the rewards by the precision factor userRewards_.checkpoint = rewardsPerToken_.accumulated; rewards[user] = userRewards_; emit UserRewardsUpdated(user, userRewards_.accumulated, userRewards_.checkpoint); return userRewards_.accumulated; } /// @dev Mint tokens, after accumulating rewards for an user and update the rewards per token accumulator. function _mint(address dst, uint256 wad) internal virtual override returns (bool) { _updateRewardsPerToken(); _updateUserRewards(dst); return super._mint(dst, wad); } /// @dev Burn tokens, after accumulating rewards for an user and update the rewards per token accumulator. function _burn(address src, uint256 wad) internal virtual override returns (bool) { _updateRewardsPerToken(); _updateUserRewards(src); return super._burn(src, wad); } /// @dev Transfer tokens, after updating rewards for source and destination. function _transfer(address src, address dst, uint wad) internal virtual override returns (bool) { _updateRewardsPerToken(); _updateUserRewards(src); _updateUserRewards(dst); return super._transfer(src, dst, wad); } /// @dev Claim all rewards from caller into a given address function claim(address to) external returns (uint256 claiming) { _updateRewardsPerToken(); claiming = _updateUserRewards(msg.sender); rewards[msg.sender].accumulated = 0; // A Claimed event implies the rewards were set to zero rewardsToken.safeTransfer(to, claiming); emit Claimed(to, claiming); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; library CastU128I128 { /// @dev Safely cast an uint128 to an int128 function i128(uint128 x) internal pure returns (int128 y) { require (x <= uint128(type(int128).max), "Cast overflow"); y = int128(x); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IFYToken.sol"; import "./IOracle.sol"; import "./DataTypes.sol"; interface ICauldron { /// @dev Variable rate lending oracle for an underlying function lendingOracles(bytes6 baseId) external view returns (IOracle); /// @dev An user can own one or more Vaults, with each vault being able to borrow from a single series. function vaults(bytes12 vault) external view returns (DataTypes.Vault memory); /// @dev Series available in Cauldron. function series(bytes6 seriesId) external view returns (DataTypes.Series memory); /// @dev Assets available in Cauldron. function assets(bytes6 assetsId) external view returns (address); /// @dev Each vault records debt and collateral balances_. function balances(bytes12 vault) external view returns (DataTypes.Balances memory); /// @dev Max, min and sum of debt per underlying and collateral. function debt(bytes6 baseId, bytes6 ilkId) external view returns (DataTypes.Debt memory); // @dev Spot price oracle addresses and collateralization ratios function spotOracles(bytes6 baseId, bytes6 ilkId) external returns (DataTypes.SpotOracle memory); /// @dev Create a new vault, linked to a series (and therefore underlying) and up to 5 collateral types function build( address owner, bytes12 vaultId, bytes6 seriesId, bytes6 ilkId ) external returns (DataTypes.Vault memory); /// @dev Destroy an empty vault. Used to recover gas costs. function destroy(bytes12 vault) external; /// @dev Change a vault series and/or collateral types. function tweak( bytes12 vaultId, bytes6 seriesId, bytes6 ilkId ) external returns (DataTypes.Vault memory); /// @dev Give a vault to another user. function give(bytes12 vaultId, address receiver) external returns (DataTypes.Vault memory); /// @dev Move collateral and debt between vaults. function stir( bytes12 from, bytes12 to, uint128 ink, uint128 art ) external returns (DataTypes.Balances memory, DataTypes.Balances memory); /// @dev Manipulate a vault debt and collateral. function pour( bytes12 vaultId, int128 ink, int128 art ) external returns (DataTypes.Balances memory); /// @dev Change series and debt of a vault. /// The module calling this function also needs to buy underlying in the pool for the new series, and sell it in pool for the old series. function roll( bytes12 vaultId, bytes6 seriesId, int128 art ) external returns (DataTypes.Vault memory, DataTypes.Balances memory); /// @dev Reduce debt and collateral from a vault, ignoring collateralization checks. function slurp( bytes12 vaultId, uint128 ink, uint128 art ) external returns (DataTypes.Balances memory); // ==== Helpers ==== /// @dev Convert a debt amount for a series from base to fyToken terms. /// @notice Think about rounding if using, since we are dividing. function debtFromBase(bytes6 seriesId, uint128 base) external returns (uint128 art); /// @dev Convert a debt amount for a series from fyToken to base terms function debtToBase(bytes6 seriesId, uint128 art) external returns (uint128 base); // ==== Accounting ==== /// @dev Record the borrowing rate at maturity for a series function mature(bytes6 seriesId) external; /// @dev Retrieve the rate accrual since maturity, maturing if necessary. function accrual(bytes6 seriesId) external returns (uint256); /// @dev Return the collateralization level of a vault. It will be negative if undercollateralized. function level(bytes12 vaultId) external returns (int256); }
// SPDX-License-Identifier: MIT pragma solidity >= 0.8.0; import "@yield-protocol/utils-v2/contracts/token/IERC20.sol"; import "@yield-protocol/utils-v2/contracts/token/IERC2612.sol"; import {IMaturingToken} from "./IMaturingToken.sol"; import {IERC20Metadata} from "@yield-protocol/utils-v2/contracts/token/ERC20.sol"; interface IPool is IERC20, IERC2612 { function baseToken() external view returns(IERC20Metadata); function base() external view returns(IERC20); function burn(address baseTo, address fyTokenTo, uint256 minRatio, uint256 maxRatio) external returns (uint256, uint256, uint256); function burnForBase(address to, uint256 minRatio, uint256 maxRatio) external returns (uint256, uint256); function buyBase(address to, uint128 baseOut, uint128 max) external returns(uint128); function buyBasePreview(uint128 baseOut) external view returns(uint128); function buyFYToken(address to, uint128 fyTokenOut, uint128 max) external returns(uint128); function buyFYTokenPreview(uint128 fyTokenOut) external view returns(uint128); function currentCumulativeRatio() external view returns (uint256 currentCumulativeRatio_, uint256 blockTimestampCurrent); function cumulativeRatioLast() external view returns (uint256); function fyToken() external view returns(IMaturingToken); function g1() external view returns(int128); function g2() external view returns(int128); function getC() external view returns (int128); function getCurrentSharePrice() external view returns (uint256); function getCache() external view returns (uint104 baseCached, uint104 fyTokenCached, uint32 blockTimestampLast, uint16 g1Fee_); function getBaseBalance() external view returns(uint128); function getFYTokenBalance() external view returns(uint128); function getSharesBalance() external view returns(uint128); function init(address to) external returns (uint256, uint256, uint256); function maturity() external view returns(uint32); function mint(address to, address remainder, uint256 minRatio, uint256 maxRatio) external returns (uint256, uint256, uint256); function mu() external view returns (int128); function mintWithBase(address to, address remainder, uint256 fyTokenToBuy, uint256 minRatio, uint256 maxRatio) external returns (uint256, uint256, uint256); function retrieveBase(address to) external returns(uint128 retrieved); function retrieveFYToken(address to) external returns(uint128 retrieved); function retrieveShares(address to) external returns(uint128 retrieved); function scaleFactor() external view returns(uint96); function sellBase(address to, uint128 min) external returns(uint128); function sellBasePreview(uint128 baseIn) external view returns(uint128); function sellFYToken(address to, uint128 min) external returns(uint128); function sellFYTokenPreview(uint128 fyTokenIn) external view returns(uint128); function setFees(uint16 g1Fee_) external; function sharesToken() external view returns(IERC20Metadata); function ts() external view returns(int128); function wrap(address receiver) external returns (uint256 shares); function wrapPreview(uint256 assets) external view returns (uint256 shares); function unwrap(address receiver) external returns (uint256 assets); function unwrapPreview(uint256 shares) external view returns (uint256 assets); /// Returns the max amount of FYTokens that can be sold to the pool function maxFYTokenIn() external view returns (uint128) ; /// Returns the max amount of FYTokens that can be bought from the pool function maxFYTokenOut() external view returns (uint128) ; /// Returns the max amount of Base that can be sold to the pool function maxBaseIn() external view returns (uint128) ; /// Returns the max amount of Base that can be bought from the pool function maxBaseOut() external view returns (uint128); /// Returns the result of the total supply invariant function function invariant() external view returns (uint128); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IJoin.sol"; import "./ICauldron.sol"; interface ILadle { function joins(bytes6) external view returns (IJoin); function pools(bytes6) external returns (address); function cauldron() external view returns (ICauldron); function build( bytes6 seriesId, bytes6 ilkId, uint8 salt ) external returns (bytes12 vaultId, DataTypes.Vault memory vault); function destroy(bytes12 vaultId) external; function pour( bytes12 vaultId, address to, int128 ink, int128 art ) external payable; function serve( bytes12 vaultId, address to, uint128 ink, uint128 base, uint128 max ) external payable returns (uint128 art); function close( bytes12 vaultId, address to, int128 ink, int128 art ) external; }
// SPDX-License-Identifier: MIT pragma solidity >=0.5.0; library AddressStringUtil { // converts an address to the uppercase hex string, extracting only len bytes (up to 20, multiple of 2) function toAsciiString(address addr, uint256 len) internal pure returns (string memory) { require(len % 2 == 0 && len > 0 && len <= 40, "AddressStringUtil: INVALID_LEN"); bytes memory s = new bytes(len); uint256 addrNum = uint256(uint160(addr)); for (uint256 ii = 0; ii < len ; ii +=2) { uint8 b = uint8(addrNum >> (4 * (38 - ii))); s[ii] = char(b >> 4); s[ii + 1] = char(b & 0x0f); } return string(s); } // hi and lo are only 4 bits and between 0 and 16 // this method converts those values to the unicode/ascii code point for the hex representation // uses upper case for the characters function char(uint8 b) private pure returns (bytes1 c) { if (b < 10) { return bytes1(b + 0x30); } else { return bytes1(b + 0x37); } } }
// SPDX-License-Identifier: MIT // Taken from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol pragma solidity ^0.8.0; import "./IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // Taken from https://github.com/sushiswap/BoringSolidity/blob/441e51c0544cf2451e6116fe00515e71d7c42e2c/contracts/BoringBatchable.sol pragma solidity >=0.6.0; library RevertMsgExtractor { /// @dev Helper function to extract a useful revert message from a failed call. /// If the returned data is malformed or not correctly abi encoded then this call can fail itself. function getRevertMsg(bytes memory returnData) internal pure returns (string memory) { // If the _res length is less than 68, then the transaction failed silently (without a revert message) if (returnData.length < 68) return "Transaction reverted silently"; assembly { // Slice the sighash. returnData := add(returnData, 0x04) } return abi.decode(returnData, (string)); // All that remains is the revert string } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@yield-protocol/utils-v2/contracts/token/IERC20.sol"; import "./IJoin.sol"; interface IFYToken is IERC20 { /// @dev Asset that is returned on redemption. function underlying() external view returns (address); /// @dev Source of redemption funds. function join() external view returns (IJoin); /// @dev Unix time at which redemption of fyToken for underlying are possible function maturity() external view returns (uint256); /// @dev Record price data at maturity function mature() external; /// @dev Mint fyToken providing an equal amount of underlying to the protocol function mintWithUnderlying(address to, uint256 amount) external; /// @dev Burn fyToken after maturity for an amount of underlying. function redeem(address to, uint256 amount) external returns (uint256); /// @dev Mint fyToken. /// This function can only be called by other Yield contracts, not users directly. /// @param to Wallet to mint the fyToken in. /// @param fyTokenAmount Amount of fyToken to mint. function mint(address to, uint256 fyTokenAmount) external; /// @dev Burn fyToken. /// This function can only be called by other Yield contracts, not users directly. /// @param from Wallet to burn the fyToken from. /// @param fyTokenAmount Amount of fyToken to burn. function burn(address from, uint256 fyTokenAmount) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IOracle { /** * @notice Doesn't refresh the price, but returns the latest value available without doing any transactional operations: * @return value in wei */ function peek( bytes32 base, bytes32 quote, uint256 amount ) external view returns (uint256 value, uint256 updateTime); /** * @notice Does whatever work or queries will yield the most up-to-date price, and returns it. * @return value in wei */ function get( bytes32 base, bytes32 quote, uint256 amount ) external returns (uint256 value, uint256 updateTime); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@yield-protocol/utils-v2/contracts/token/IERC20.sol"; interface IJoin { /// @dev asset managed by this contract function asset() external view returns (address); /// @dev Add tokens to this contract. function join(address user, uint128 wad) external returns (uint128); /// @dev Remove tokens to this contract. function exit(address user, uint128 wad) external returns (uint128); }
// SPDX-License-Identifier: MIT // Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/53516bc555a454862470e7860a9b5254db4d00f5/contracts/token/ERC20/ERC20Permit.sol pragma solidity ^0.8.0; import "./ERC20.sol"; import "./IERC2612.sol"; /** * @dev Extension of {ERC20} that allows token holders to use their tokens * without sending any transactions by setting {IERC20-allowance} with a * signature using the {permit} method, and then spend them via * {IERC20-transferFrom}. * * The {permit} signature mechanism conforms to the {IERC2612} interface. */ abstract contract ERC20Permit is ERC20, IERC2612 { mapping (address => uint256) public override nonces; bytes32 public immutable PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); bytes32 private immutable _DOMAIN_SEPARATOR; uint256 public immutable deploymentChainId; constructor(string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_, decimals_) { deploymentChainId = block.chainid; _DOMAIN_SEPARATOR = _calculateDomainSeparator(block.chainid); } /// @dev Calculate the DOMAIN_SEPARATOR. function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256(bytes(version())), chainId, address(this) ) ); } /// @dev Return the DOMAIN_SEPARATOR. function DOMAIN_SEPARATOR() external view returns (bytes32) { return block.chainid == deploymentChainId ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(block.chainid); } /// @dev Setting the version as a function so that it can be overriden function version() public pure virtual returns(string memory) { return "1"; } /** * @dev See {IERC2612-permit}. * * In cases where the free option is not a concern, deadline can simply be * set to uint(-1), so it should be seen as an optional parameter */ function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external virtual override { require(deadline >= block.timestamp, "ERC20Permit: expired deadline"); bytes32 hashStruct = keccak256( abi.encode( PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline ) ); bytes32 hash = keccak256( abi.encodePacked( "\x19\x01", block.chainid == deploymentChainId ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(block.chainid), hashStruct ) ); address signer = ecrecover(hash, v, r, s); require( signer != address(0) && signer == owner, "ERC20Permit: invalid signature" ); _setAllowance(owner, spender, amount); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; library CastU256U128 { /// @dev Safely cast an uint256 to an uint128 function u128(uint256 x) internal pure returns (uint128 y) { require (x <= type(uint128).max, "Cast overflow"); y = uint128(x); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; library CastU256U32 { /// @dev Safely cast an uint256 to an u32 function u32(uint256 x) internal pure returns (uint32 y) { require (x <= type(uint32).max, "Cast overflow"); y = uint32(x); } }
// SPDX-License-Identifier: MIT // Inspired on token.sol from DappHub. Natspec adpated from OpenZeppelin. pragma solidity ^0.8.0; import "./IERC20Metadata.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}. * * We have followed general OpenZeppelin guidelines: functions revert instead * of 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. * * Calls to {transferFrom} do not check for allowance if the caller is the owner * of the funds. This allows to reduce the number of approvals that are necessary. * * Finally, {transferFrom} does not decrease the allowance if it is set to * type(uint256).max. This reduces the gas costs without any likely impact. */ contract ERC20 is IERC20Metadata { uint256 internal _totalSupply; mapping (address => uint256) internal _balanceOf; mapping (address => mapping (address => uint256)) internal _allowance; string public override name = "???"; string public override symbol = "???"; uint8 public override decimals = 18; /** * @dev Sets the values for {name}, {symbol} and {decimals}. */ constructor(string memory name_, string memory symbol_, uint8 decimals_) { name = name_; symbol = symbol_; decimals = decimals_; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() external view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address guy) external view virtual override returns (uint256) { return _balanceOf[guy]; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) external view virtual override returns (uint256) { return _allowance[owner][spender]; } /** * @dev See {IERC20-approve}. */ function approve(address spender, uint wad) external virtual override returns (bool) { return _setAllowance(msg.sender, spender, wad); } /** * @dev See {IERC20-transfer}. * * Requirements: * * - the caller must have a balance of at least `wad`. */ function transfer(address dst, uint wad) external virtual override returns (bool) { return _transfer(msg.sender, dst, wad); } /** * @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}. * * Requirements: * * - `src` must have a balance of at least `wad`. * - the caller is not `src`, it must have allowance for ``src``'s tokens of at least * `wad`. */ /// if_succeeds {:msg "TransferFrom - decrease allowance"} msg.sender != src ==> old(_allowance[src][msg.sender]) >= wad; function transferFrom(address src, address dst, uint wad) external virtual override returns (bool) { _decreaseAllowance(src, wad); return _transfer(src, dst, wad); } /** * @dev Moves tokens `wad` from `src` to `dst`. * * Emits a {Transfer} event. * * Requirements: * * - `src` must have a balance of at least `amount`. */ /// if_succeeds {:msg "Transfer - src decrease"} old(_balanceOf[src]) >= _balanceOf[src]; /// if_succeeds {:msg "Transfer - dst increase"} _balanceOf[dst] >= old(_balanceOf[dst]); /// if_succeeds {:msg "Transfer - supply"} old(_balanceOf[src]) + old(_balanceOf[dst]) == _balanceOf[src] + _balanceOf[dst]; function _transfer(address src, address dst, uint wad) internal virtual returns (bool) { require(_balanceOf[src] >= wad, "ERC20: Insufficient balance"); unchecked { _balanceOf[src] = _balanceOf[src] - wad; } _balanceOf[dst] = _balanceOf[dst] + wad; emit Transfer(src, dst, wad); return true; } /** * @dev Sets the allowance granted to `spender` by `owner`. * * Emits an {Approval} event indicating the updated allowance. */ function _setAllowance(address owner, address spender, uint wad) internal virtual returns (bool) { _allowance[owner][spender] = wad; emit Approval(owner, spender, wad); return true; } /** * @dev Decreases the allowance granted to the caller by `src`, unless src == msg.sender or _allowance[src][msg.sender] == MAX * * Emits an {Approval} event indicating the updated allowance, if the allowance is updated. * * Requirements: * * - `spender` must have allowance for the caller of at least * `wad`, unless src == msg.sender */ /// if_succeeds {:msg "Decrease allowance - underflow"} old(_allowance[src][msg.sender]) <= _allowance[src][msg.sender]; function _decreaseAllowance(address src, uint wad) internal virtual returns (bool) { if (src != msg.sender) { uint256 allowed = _allowance[src][msg.sender]; if (allowed != type(uint).max) { require(allowed >= wad, "ERC20: Insufficient approval"); unchecked { _setAllowance(src, msg.sender, allowed - wad); } } } return true; } /** @dev Creates `wad` tokens and assigns them to `dst`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. */ /// if_succeeds {:msg "Mint - balance overflow"} old(_balanceOf[dst]) >= _balanceOf[dst]; /// if_succeeds {:msg "Mint - supply overflow"} old(_totalSupply) >= _totalSupply; function _mint(address dst, uint wad) internal virtual returns (bool) { _balanceOf[dst] = _balanceOf[dst] + wad; _totalSupply = _totalSupply + wad; emit Transfer(address(0), dst, wad); return true; } /** * @dev Destroys `wad` tokens from `src`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `src` must have at least `wad` tokens. */ /// if_succeeds {:msg "Burn - balance underflow"} old(_balanceOf[src]) <= _balanceOf[src]; /// if_succeeds {:msg "Burn - supply underflow"} old(_totalSupply) <= _totalSupply; function _burn(address src, uint wad) internal virtual returns (bool) { unchecked { require(_balanceOf[src] >= wad, "ERC20: Insufficient balance"); _balanceOf[src] = _balanceOf[src] - wad; _totalSupply = _totalSupply - wad; emit Transfer(src, address(0), wad); } return true; } }
// SPDX-License-Identifier: MIT // Code adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/ pragma solidity ^0.8.0; /** * @dev Interface of the ERC2612 standard as defined in the EIP. * * Adds the {permit} method, which can be used to change one's * {IERC20-allowance} without having to send a transaction, by signing a * message. This allows users to spend tokens without having to hold Ether. * * See https://eips.ethereum.org/EIPS/eip-2612. */ interface IERC2612 { /** * @dev Sets `amount` 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: * * - `owner` cannot be the zero address. * - `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 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; /** * @dev Returns the current ERC2612 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); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.15; import "@yield-protocol/utils-v2/contracts/token/IERC20.sol"; interface IMaturingToken is IERC20 { function maturity() external view returns (uint256); }
{ "optimizer": { "enabled": true, "runs": 100 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": { "@yield-protocol/utils-v2/contracts/token/SafeERC20Namer.sol": { "SafeERC20Namer": "0x39bb9cBe0221D769E30bD08d185842065BcE1706" } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"contract ILadle","name":"ladle_","type":"address"},{"internalType":"contract IERC20","name":"base_","type":"address"},{"internalType":"bytes6","name":"baseId_","type":"bytes6"},{"internalType":"address","name":"baseJoin_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimed","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IPool","name":"pool","type":"address"},{"indexed":true,"internalType":"bytes6","name":"seriesId","type":"bytes6"}],"name":"NextPoolSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"PoolEnded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"PoolStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"accumulated","type":"uint256"}],"name":"RewardsPerTokenUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"start","type":"uint32"},{"indexed":false,"internalType":"uint32","name":"end","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"rate","type":"uint256"}],"name":"RewardsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IERC20","name":"token","type":"address"}],"name":"RewardsTokenSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"role","type":"bytes4"},{"indexed":true,"internalType":"bytes4","name":"newAdminRole","type":"bytes4"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"role","type":"bytes4"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"role","type":"bytes4"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes6","name":"id","type":"bytes6"}],"name":"TokenIdSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"join","type":"address"}],"name":"TokenJoinReset","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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"userRewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paidRewardPerToken","type":"uint256"}],"name":"UserRewardsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract ILadle","name":"ladle","type":"address"},{"indexed":false,"internalType":"contract ICauldron","name":"cauldron","type":"address"}],"name":"YieldSet","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LOCK","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LOCK8605463013","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROOT","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROOT4146650865","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"guy","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"base","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseId","outputs":[{"internalType":"bytes6","name":"","type":"bytes6"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseJoin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"burn","outputs":[{"internalType":"uint256","name":"withdrawal","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"burnForBase","outputs":[{"internalType":"uint256","name":"withdrawal","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cached","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cauldron","outputs":[{"internalType":"contract ICauldron","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"claim","outputs":[{"internalType":"uint256","name":"claiming","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deploymentChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fyToken","outputs":[{"internalType":"contract IFYToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4[]","name":"roles","type":"bytes4[]"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRoles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ladle","outputs":[{"internalType":"contract ILadle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"}],"name":"lockRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextPool","outputs":[{"internalType":"contract IPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextSeriesId","outputs":[{"internalType":"bytes6","name":"","type":"bytes6"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","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":[],"name":"pool","outputs":[{"internalType":"contract IPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resetTokenJoin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4[]","name":"roles","type":"bytes4[]"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRoles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint128","name":"accumulated","type":"uint128"},{"internalType":"uint128","name":"checkpoint","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsPerToken","outputs":[{"internalType":"uint128","name":"accumulated","type":"uint128"},{"internalType":"uint32","name":"lastUpdated","type":"uint32"},{"internalType":"uint96","name":"rate","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsPeriod","outputs":[{"internalType":"uint32","name":"start","type":"uint32"},{"internalType":"uint32","name":"end","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seriesId","outputs":[{"internalType":"bytes6","name":"","type":"bytes6"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IPool","name":"pool_","type":"address"},{"internalType":"bytes6","name":"seriesId_","type":"bytes6"}],"name":"setNextPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"start","type":"uint32"},{"internalType":"uint32","name":"end","type":"uint32"},{"internalType":"uint96","name":"rate","type":"uint96"}],"name":"setRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"rewardsToken_","type":"address"}],"name":"setRewardsToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"role","type":"bytes4"},{"internalType":"bytes4","name":"adminRole","type":"bytes4"}],"name":"setRoleAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes6","name":"baseId_","type":"bytes6"}],"name":"setTokenId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ILadle","name":"ladle_","type":"address"}],"name":"setYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minRatio","type":"uint256"},{"internalType":"uint256","name":"maxRatio","type":"uint256"}],"name":"startPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000006cb18ff2a33e981d1e38a663ca056c0a5265066a000000000000000000000000853d955acef822db058eb8505911ed77f175b99e31380000000000000000000000000000000000000000000000000000000000000000000000000000000000005655a973a49e1f9c1408bb9a617fd0dbd0352464000000000000000000000000000000000000000000000000000000000000001e5969656c64205374726174656779204652415820364d204a756e204465630000000000000000000000000000000000000000000000000000000000000000000a595346524158364d4a4400000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name (string): Yield Strategy FRAX 6M Jun Dec
Arg [1] : symbol (string): YSFRAX6MJD
Arg [2] : ladle_ (address): 0x6cB18fF2A33e981D1e38A663Ca056c0a5265066A
Arg [3] : base_ (address): 0x853d955aCEf822Db058eb8505911ED77F175b99e
Arg [4] : baseId_ (bytes6): 0x313800000000
Arg [5] : baseJoin_ (address): 0x5655A973A49e1F9c1408bb9A617Fd0DBD0352464
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000006cb18ff2a33e981d1e38a663ca056c0a5265066a
Arg [3] : 000000000000000000000000853d955acef822db058eb8505911ed77f175b99e
Arg [4] : 3138000000000000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000005655a973a49e1f9c1408bb9a617fd0dbd0352464
Arg [6] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [7] : 5969656c64205374726174656779204652415820364d204a756e204465630000
Arg [8] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [9] : 595346524158364d4a4400000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.