Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-01-23
*/

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;

/**
 * @title: Idle Perpertual Yield Tranches wrapper for senior tranche of the Euler staking PYT
 * @summary: Used for interacting with Idle senior PYTs. Has
 *           a common interface with all other protocol wrappers.
 *           This contract holds assets only during a tx, after tx it should be empty
 * @author: Idle Labs Inc., idle.finance
 */

/**
 * @title: Idle Perpertual Yield Tranches wrapper for senior tranche
 * @summary: Used for interacting with Idle senior PYTs. Has
 *           a common interface with all other protocol wrappers.
 *           This contract holds assets only during a tx, after tx it should be empty
 * @author: Idle Labs Inc., idle.finance
 */

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20PermitUpgradeable {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return 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 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);
        }
    }
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20Upgradeable {
    using AddressUpgradeable for address;

    function safeTransfer(
        IERC20Upgradeable token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20Upgradeable token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20Upgradeable token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20Upgradeable token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20Upgradeable token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20PermitUpgradeable token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

interface ILendingProtocol {
  function mint() external returns (uint256);
  function redeem(address account) external returns (uint256);
  function nextSupplyRate(uint256 amount) external view returns (uint256);
  function getAPR() external view returns (uint256);
  function getPriceInToken() external view returns (uint256);
  function token() external view returns (address);
  function underlying() external view returns (address);
  function availableLiquidity() external view returns (uint256);
}

interface IIdleCDO {
  function AATranche() external view returns(address);
  function BBTranche() external view returns(address);
  function AAStaking() external view returns(address);
  function BBStaking() external view returns(address);
  function strategy() external view returns(address);
  function strategyToken() external view returns(address);
  function token() external view returns(address);

  function allowAAWithdraw() external view returns(bool);
  function allowBBWithdraw() external view returns(bool);
  function fee() external view returns(uint256);
  function getApr(address _tranche) external view returns(uint256);
  function getContractValue() external view returns(uint256);
  function trancheAPRSplitRatio() external view returns(uint256);
  function minAprSplitAYS() external view returns(uint256);
  function getCurrentAARatio() external view returns(uint256);
  function tranchePrice(address _tranche) external view returns(uint256);
  function virtualPrice(address _tranche) external view returns(uint256);
  function getIncentiveTokens() external view returns(address[] memory);

  function depositAA(uint256) external returns(uint256);
  function depositBB(uint256) external returns(uint256);
  function withdrawAA(uint256) external returns(uint256);
  function withdrawBB(uint256) external returns(uint256);
}

interface IIdleCDOStrategy {
  function getApr() external view returns(uint256);
}

// This contract should be deployed with a minimal proxy factory
contract IdlePYT is ILendingProtocol {
  using SafeERC20Upgradeable for IERC20Upgradeable;

  address public idleToken;
  // protocol token (AA_tranche_token) address
  address public override token;
  // underlying token (token eg DAI) address
  address public override underlying;
  IERC20Upgradeable public tokenContract;
  IERC20Upgradeable public underlyingContract;

  // contract used for minting/burning tranche tokens
  IIdleCDO public idleCDO;
  // Used for calculating the nextRate
  uint256 internal constant AA_RATIO_LIM_UP = 99000;
  uint256 internal constant AA_RATIO_LIM_DOWN = 50000;
  uint256 internal constant FULL_ALLOC = 100000;
  uint256 internal constant ONE_TRANCHE = 1e18;
  bool public isSenior;

  // Errors
  error Initialized();
  error Unauthorized();

  /**
   * @param _token : tranche token address
   * @param _idleToken : idleToken address
   * @param _cdo : IdleCDO contract address for minting tranche tokens
   */
  function initialize(
    address _token, 
    address _idleToken, 
    address _cdo
  ) external {
    if (address(token) != address(0)) {
      revert Initialized();
    }

    idleCDO = IIdleCDO(_cdo);
    token = _token;
    isSenior = idleCDO.AATranche() == _token;
    tokenContract = IERC20Upgradeable(_token);
    underlying = idleCDO.token();
    underlyingContract = IERC20Upgradeable(idleCDO.token());
    idleToken = _idleToken;
    underlyingContract.safeApprove(_cdo, type(uint256).max);
  }

  /**
   * Throws if called by any account other than IdleToken contract.
   */
  function _onlyIdle() internal view {
    if (msg.sender != idleToken) revert Unauthorized();
  }

  /**
   * Calculate next supply rate for Compound, given an `_amount` supplied
   *
   * @notice this is used for off-chain calculations
   * @param _amount : new underlying amount supplied (eg DAI)
   * @return newAAApr : yearly net rate
   */
  function nextSupplyRate(uint256 _amount)
    external view virtual
    returns (uint256 newAAApr) {
      IERC20Upgradeable _token = IERC20Upgradeable(token);
      IIdleCDO _idleCDO = idleCDO;
      uint256 _tvl = _idleCDO.getContractValue();
      // we use tranchePrice instead of virtualPrice for more efficiency as interest accrued wont 
      // affect too much TVL
      uint256 _tvlAA = _token.totalSupply() * _idleCDO.tranchePrice(address(_token)) / ONE_TRANCHE;
      uint256 _newTvlRatio = (_tvlAA + _amount) * FULL_ALLOC / (_tvl + _amount);
      uint256 _newAprRatio  = _calcNewAPRSplit(_newTvlRatio);
      // we need to get the underlying strategy apr here to calculate the new apr for the tranche
      IIdleCDOStrategy innerStrategy = IIdleCDOStrategy(_idleCDO.strategy());
      // TODO in new CDO strategies we should support a getApr(_amount) similar to nextSupplyRate
      // so to calculate also the impact on the underlying lending protocol used by the PYT. This 
      // can be calculated off-chain in the meantime for the optimal rebalance amount
      newAAApr = innerStrategy.getApr() * _newAprRatio / _newTvlRatio;
      newAAApr = newAAApr * (FULL_ALLOC - idleCDO.fee()) / FULL_ALLOC;
  }

  /**
   * @return current price of tranche token
   */
  function getPriceInToken()
    external view
    returns (uint256) {
      return idleCDO.virtualPrice(address(token));
  }

  /**
   * @return _apr current apr
   */
  function getAPR()
    external view
    returns (uint256 _apr) {
      _apr = idleCDO.getApr(address(token));
      _apr = _apr * (FULL_ALLOC - idleCDO.fee()) / FULL_ALLOC;
  }

  /**
   * Gets all underlying tokens in this contract and mints cTokenLike Tokens
   * tokens are then transferred to msg.sender
   * NOTE: underlying tokens needs to be sent here before calling this
   *
   * @return minted : tranche tokens minted
   */
  function mint()
    external virtual
    returns (uint256 minted) {
      _onlyIdle();
      uint256 balance = underlyingContract.balanceOf(address(this));
      if (balance != 0) {
        if (isSenior) {
          idleCDO.depositAA(balance);
        } else {
          idleCDO.depositBB(balance);
        }
        IERC20Upgradeable _token = tokenContract;
        minted = _token.balanceOf(address(this));
        _token.safeTransfer(msg.sender, minted);
      }
  }

  /**
   * Gets all cTokenLike in this contract and redeems underlying tokens.
   * underlying tokens are then transferred to `_account`
   * NOTE: cTokenLike needs to be sent here before calling this
   *
   * @return tokens underlying tokens redeemd
   */
  function redeem(address _account)
    external virtual
    returns (uint256 tokens) {
      _onlyIdle();
      uint256 _bal = tokenContract.balanceOf(address(this));
      if (isSenior) {
        idleCDO.withdrawAA(_bal);
      } else {
        idleCDO.withdrawBB(_bal);
      }
      IERC20Upgradeable _underlying = underlyingContract;
      tokens = _underlying.balanceOf(address(this));
      _underlying.safeTransfer(_account, tokens);
  }

  /**
   * Get the underlying balance available on the lending protocol
   *
   * @return underlying tokens available
   */
  function availableLiquidity() external virtual view returns (uint256) {
    return idleCDO.getContractValue();
  }

  /**
   * Get the new apr split ratio in IdleCDO. Taken from here https://github.com/Idle-Labs/idle-tranches/blob/448c707a690e20bf2ef3e5a233fa97a329b34eb0/contracts/IdleCDO.sol#L454
   *
   * @return _new new apr split ratio for IdleCDO
   */
  function _calcNewAPRSplit(uint256 ratio) internal view returns (uint256 _new){
    uint256 minSplit = idleCDO.minAprSplitAYS();
    uint256 aux;
    if (ratio >= AA_RATIO_LIM_UP) {
      aux = AA_RATIO_LIM_UP;
    } else if (ratio > minSplit) {
      aux = ratio;
    } else {
      aux = minSplit;
    }
    _new = aux * ratio / FULL_ALLOC;
  }
}

interface IMMVault {
  function maxWithdraw(address owner) external view returns (uint256);
}

// This contract should be deployed with a minimal proxy factory
contract MetamorphoPYTStrategy is IdlePYT {
  /**
   * Get the underlying balance available on the lending protocol
   *
   * @return underlying tokens available
   */
  function availableLiquidity() external override view returns (uint256) {
    IIdleCDO _idleCDO = idleCDO;
    IERC20Upgradeable _underlyingContract = underlyingContract;

    // add max withdrawal balance for the Metamorpho vault used by IdleCDO
    IMMVault mmVault = IMMVault(_idleCDO.strategyToken());

    return 
      _underlyingContract.balanceOf(address(_idleCDO)) + 
      mmVault.maxWithdraw(address(_idleCDO));
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"Initialized","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"availableLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAPR","outputs":[{"internalType":"uint256","name":"_apr","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPriceInToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"idleCDO","outputs":[{"internalType":"contract IIdleCDO","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"idleToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_idleToken","type":"address"},{"internalType":"address","name":"_cdo","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isSenior","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"nextSupplyRate","outputs":[{"internalType":"uint256","name":"newAAApr","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"tokens","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenContract","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"underlyingContract","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

608060405234801561000f575f80fd5b50611af68061001d5f395ff3fe608060405234801561000f575f80fd5b50600436106100e5575f3560e01c806395a2251f11610088578063c89d5b8b11610063578063c89d5b8b14610215578063ccdd01491461021d578063d4090fb814610230578063fc0c546a14610250575f80fd5b806395a2251f146101b857806399ac9774146101cb578063c0c53b8b14610200575f80fd5b80632dd60c5e116100c35780632dd60c5e1461015157806355a373d6146101705780636f307dc31461019057806374375359146101b0575f80fd5b806302bbce46146100e957806310cfe906146101045780631249c58b14610149575b5f80fd5b6100f1610270565b6040519081526020015b60405180910390f35b6004546101249073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100fb565b6100f161030d565b5f546101249073ffffffffffffffffffffffffffffffffffffffff1681565b6003546101249073ffffffffffffffffffffffffffffffffffffffff1681565b6002546101249073ffffffffffffffffffffffffffffffffffffffff1681565b6100f16105bd565b6100f16101c63660046118b9565b61078b565b6005546101f09074010000000000000000000000000000000000000000900460ff1681565b60405190151581526020016100fb565b61021361020e3660046118db565b610a33565b005b6100f1610da1565b6100f161022b366004611923565b610eee565b6005546101249073ffffffffffffffffffffffffffffffffffffffff1681565b6001546101249073ffffffffffffffffffffffffffffffffffffffff1681565b6005546001546040517f9290d42700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff91821660048201525f929190911690639290d42790602401602060405180830381865afa1580156102e4573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610308919061193a565b905090565b5f61031661129b565b600480546040517f70a0823100000000000000000000000000000000000000000000000000000000815230928101929092525f9173ffffffffffffffffffffffffffffffffffffffff909116906370a0823190602401602060405180830381865afa158015610387573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103ab919061193a565b905080156105b95760055474010000000000000000000000000000000000000000900460ff161561046e576005546040517fb450dfce0000000000000000000000000000000000000000000000000000000081526004810183905273ffffffffffffffffffffffffffffffffffffffff9091169063b450dfce906024016020604051808303815f875af1158015610444573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610468919061193a565b50610502565b6005546040517fe70875ad0000000000000000000000000000000000000000000000000000000081526004810183905273ffffffffffffffffffffffffffffffffffffffff9091169063e70875ad906024016020604051808303815f875af11580156104dc573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610500919061193a565b505b6003546040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff9091169081906370a0823190602401602060405180830381865afa158015610570573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610594919061193a565b92506105b773ffffffffffffffffffffffffffffffffffffffff821633856112ed565b505b5090565b60055460048054604080517f747efea100000000000000000000000000000000000000000000000000000000815290515f9473ffffffffffffffffffffffffffffffffffffffff908116949316928592859263747efea1928281019260209291908290030181865afa158015610635573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106599190611951565b6040517fce96cb7700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301529192509082169063ce96cb7790602401602060405180830381865afa1580156106c7573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106eb919061193a565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301528416906370a0823190602401602060405180830381865afa158015610755573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610779919061193a565b6107839190611999565b935050505090565b5f61079461129b565b6003546040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201525f9173ffffffffffffffffffffffffffffffffffffffff16906370a0823190602401602060405180830381865afa158015610800573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610824919061193a565b60055490915074010000000000000000000000000000000000000000900460ff16156108e2576005546040517f9af648540000000000000000000000000000000000000000000000000000000081526004810183905273ffffffffffffffffffffffffffffffffffffffff90911690639af64854906024016020604051808303815f875af11580156108b8573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108dc919061193a565b50610976565b6005546040517f99abe5e80000000000000000000000000000000000000000000000000000000081526004810183905273ffffffffffffffffffffffffffffffffffffffff909116906399abe5e8906024016020604051808303815f875af1158015610950573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610974919061193a565b505b600480546040517f70a08231000000000000000000000000000000000000000000000000000000008152309281019290925273ffffffffffffffffffffffffffffffffffffffff169081906370a0823190602401602060405180830381865afa1580156109e5573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a09919061193a565b9250610a2c73ffffffffffffffffffffffffffffffffffffffff821685856112ed565b5050919050565b60015473ffffffffffffffffffffffffffffffffffffffff1615610a83576040517f5daa87a000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600580547fffffffffffffffffffffffff000000000000000000000000000000000000000090811673ffffffffffffffffffffffffffffffffffffffff84811691821790935560018054909216928616928317909155604080517f44966ba000000000000000000000000000000000000000000000000000000000815290516344966ba0916004818101926020929091908290030181865afa158015610b2b573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b4f9190611951565b600580547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff811673ffffffffffffffffffffffffffffffffffffffff938416949094147401000000000000000000000000000000000000000002938417909155600380547fffffffffffffffffffffffff000000000000000000000000000000000000000016878416179055604080517ffc0c546a000000000000000000000000000000000000000000000000000000008152905191831693909216929092179163fc0c546a916004808201926020929091908290030181865afa158015610c39573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610c5d9190611951565b600280547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff928316179055600554604080517ffc0c546a0000000000000000000000000000000000000000000000000000000081529051919092169163fc0c546a9160048083019260209291908290030181865afa158015610cf7573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610d1b9190611951565b6004805473ffffffffffffffffffffffffffffffffffffffff9283167fffffffffffffffffffffffff000000000000000000000000000000000000000091821681179092555f80549386169390911692909217909155610d9c90827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6113c1565b505050565b6005546001546040517f29811ee500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff91821660048201525f9291909116906329811ee590602401602060405180830381865afa158015610e15573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e39919061193a565b9050620186a060055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ddca3f436040518163ffffffff1660e01b8152600401602060405180830381865afa158015610ea9573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ecd919061193a565b610eda90620186a06119b2565b610ee490836119c5565b61030891906119dc565b600154600554604080517fdc82697c00000000000000000000000000000000000000000000000000000000815290515f9373ffffffffffffffffffffffffffffffffffffffff9081169316918491839163dc82697c9160048083019260209291908290030181865afa158015610f66573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f8a919061193a565b6040517fa219d21800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301529192505f91670de0b6b3a7640000919085169063a219d21890602401602060405180830381865afa158015611004573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611028919061193a565b8573ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611071573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611095919061193a565b61109f91906119c5565b6110a991906119dc565b90505f6110b68784611999565b620186a06110c48985611999565b6110ce91906119c5565b6110d891906119dc565b90505f6110e482611546565b90505f8573ffffffffffffffffffffffffffffffffffffffff1663a8c62e766040518163ffffffff1660e01b8152600401602060405180830381865afa158015611130573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111549190611951565b905082828273ffffffffffffffffffffffffffffffffffffffff1663845bc8046040518163ffffffff1660e01b8152600401602060405180830381865afa1580156111a1573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111c5919061193a565b6111cf91906119c5565b6111d991906119dc565b9750620186a060055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ddca3f436040518163ffffffff1660e01b8152600401602060405180830381865afa158015611249573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061126d919061193a565b61127a90620186a06119b2565b611284908a6119c5565b61128e91906119dc565b9998505050505050505050565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146112eb576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b565b60405173ffffffffffffffffffffffffffffffffffffffff8316602482015260448101829052610d9c9084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261161f565b80158061145f57506040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff838116602483015284169063dd62ed3e90604401602060405180830381865afa158015611439573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061145d919061193a565b155b6114f0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527f20746f206e6f6e2d7a65726f20616c6c6f77616e63650000000000000000000060648201526084015b60405180910390fd5b60405173ffffffffffffffffffffffffffffffffffffffff8316602482015260448101829052610d9c9084907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161133f565b5f8060055f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16632c2a7ca46040518163ffffffff1660e01b8152600401602060405180830381865afa1580156115b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906115d6919061193a565b90505f620182b884106115ed5750620182b86115ff565b818411156115fc5750826115ff565b50805b620186a061160d85836119c5565b61161791906119dc565b949350505050565b5f611680826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661172a9092919063ffffffff16565b805190915015610d9c578080602001905181019061169e9190611a14565b610d9c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016114e7565b606061161784845f85855f808673ffffffffffffffffffffffffffffffffffffffff16858760405161175c9190611a55565b5f6040518083038185875af1925050503d805f8114611796576040519150601f19603f3d011682016040523d82523d5f602084013e61179b565b606091505b50915091506117ac878383876117b7565b979650505050505050565b6060831561184c5782515f036118455773ffffffffffffffffffffffffffffffffffffffff85163b611845576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016114e7565b5081611617565b61161783838151156118615781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114e79190611a70565b73ffffffffffffffffffffffffffffffffffffffff811681146118b6575f80fd5b50565b5f602082840312156118c9575f80fd5b81356118d481611895565b9392505050565b5f805f606084860312156118ed575f80fd5b83356118f881611895565b9250602084013561190881611895565b9150604084013561191881611895565b809150509250925092565b5f60208284031215611933575f80fd5b5035919050565b5f6020828403121561194a575f80fd5b5051919050565b5f60208284031215611961575f80fd5b81516118d481611895565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b808201808211156119ac576119ac61196c565b92915050565b818103818111156119ac576119ac61196c565b80820281158282048414176119ac576119ac61196c565b5f82611a0f577f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b500490565b5f60208284031215611a24575f80fd5b815180151581146118d4575f80fd5b5f5b83811015611a4d578181015183820152602001611a35565b50505f910152565b5f8251611a66818460208701611a33565b9190910192915050565b602081525f8251806020840152611a8e816040850160208701611a33565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016919091016040019291505056fea26469706673582212209afecbd7cc94f9a38772cf4a5efb437bd5136dd2b81aa0944c42d2186e248a5164736f6c63430008160033

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

26950:614:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24077:127;;;:::i;:::-;;;160:25:1;;;148:2;133:18;24077:127:0;;;;;;;;21161:43;;;;;;;;;;;;396:42:1;384:55;;;366:74;;354:2;339:18;21161:43:0;196:250:1;24705:484:0;;;:::i;20922:24::-;;;;;;;;;21118:38;;;;;;;;;21079:34;;;;;;;;;27126:435;;;:::i;25460:456::-;;;;;;:::i;:::-;;:::i;21543:20::-;;;;;;;;;;;;;;;1258:14:1;;1251:22;1233:41;;1221:2;1206:18;21543:20:0;1093:187:1;21808:521:0;;;;;;:::i;:::-;;:::i;:::-;;24255:181;;;:::i;22775:1237::-;;;;;;:::i;:::-;;:::i;21266:23::-;;;;;;;;;20999:29;;;;;;;;;24077:127;24162:7;;;24191:5;24162:36;;;;;:7;24191:5;;;24162:36;;;366:74:1;24137:7:0;;24162;;;;;:20;;339:18:1;;24162:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24155:43;;24077:127;:::o;24705:484::-;24757:14;24782:11;:9;:11::i;:::-;24820:18;;;:43;;;;;24857:4;24820:43;;;366:74:1;;;;24802:15:0;;24820:18;;;;;:28;;339:18:1;;24820:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24802:61;-1:-1:-1;24876:12:0;;24872:312;;24905:8;;;;;;;24901:122;;;24928:7;;:26;;;;;;;;160:25:1;;;24928:7:0;;;;;:17;;133:18:1;;24928:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24901:122;;;24985:7;;:26;;;;;;;;160:25:1;;;24985:7:0;;;;;:17;;133:18:1;;24985:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24901:122;25060:13;;25093:31;;;;;25118:4;25093:31;;;366:74:1;25060:13:0;;;;;;;25093:16;;339:18:1;;25093:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25084:40;-1:-1:-1;25135:39:0;:19;;;25155:10;25084:40;25135:19;:39::i;:::-;24890:294;24872:312;24773:416;24705:484;:::o;27126:435::-;27224:7;;27278:18;;;27409:24;;;;;;;;27188:7;;27224;;;;;27278:18;;;27188:7;;27224;;27409:22;;:24;;;;;;;;;;;;;27224:7;27409:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27517:38;;;;;:19;384:55:1;;;27517:38:0;;;366:74:1;27381:53:0;;-1:-1:-1;27517:19:0;;;;;;339:18:1;;27517:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27458:48;;;;;:29;384:55:1;;;27458:48:0;;;366:74:1;27458:29:0;;;;;339:18:1;;27458:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:97;;;;:::i;:::-;27443:112;;;;;27126:435;:::o;25460:456::-;25530:14;25555:11;:9;:11::i;:::-;25590:13;;:38;;;;;25622:4;25590:38;;;366:74:1;25575:12:0;;25590:13;;;:23;;339:18:1;;25590:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25641:8;;25575:53;;-1:-1:-1;25641:8:0;;;;;25637:110;;;25662:7;;:24;;;;;;;;160:25:1;;;25662:7:0;;;;;:18;;133::1;;25662:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;25637:110;;;25713:7;;:24;;;;;;;;160:25:1;;;25713:7:0;;;;;:18;;133::1;;25713:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;25637:110;25787:18;;;25823:36;;;;;25853:4;25823:36;;;366:74:1;;;;25787:18:0;;;;;25823:21;;339:18:1;;25823:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25814:45;-1:-1:-1;25868:42:0;:24;;;25893:8;25814:45;25868:24;:42::i;:::-;25546:370;;25460:456;;;:::o;21808:521::-;21928:5;;21920:28;21928:5;21920:28;21916:71;;21966:13;;;;;;;;;;;;;;21916:71;21995:7;:24;;;;;;;;;;;;;;;;-1:-1:-1;22026:14:0;;;;;;;;;;;;;;22058:19;;;;;;;;:17;;-1:-1:-1;22058:19:0;;;;;;;;;;;;;;21995:24;22058:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22047:8;:40;;;;;22058:29;;;;;;;;22047:40;;;;;;;;22094:13;:41;;;;;;;;;;22155:15;;;;;;;;:7;;;;;;;;;;;;:13;;:15;;;;;;;;;;;;;;;:7;:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22142:10;:28;;;;;;;;;;;22216:7;;:15;;;;;;;;:7;;;;;:13;;:15;;;;;;;;;;;;;;:7;:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22177:18;:55;;;;;;;;;;;;;;;:18;22239:22;;;;;;;;;;;;;;;;22268:55;;22299:4;22305:17;22268:30;:55::i;:::-;21808:521;;;:::o;24255:181::-;24336:7;;;24359:5;24336:30;;;;;:7;24359:5;;;24336:30;;;366:74:1;24306:12:0;;24336:7;;;;;:14;;339:18:1;;24336:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24329:37;;21483:6;24403:7;;;;;;;;;;;:11;;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24390:26;;21483:6;24390:26;:::i;:::-;24382:35;;:4;:35;:::i;:::-;:48;;;;:::i;22775:1237::-;22929:5;;22964:7;;22995:27;;;;;;;;22857:16;;22929:5;;;;;22964:7;;22857:16;;22964:7;;22995:25;;:27;;;;;;;;;;;;;;22964:7;22995:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23201:38;;;;;:21;384:55:1;;;23201:38:0;;;366:74:1;22980:42:0;;-1:-1:-1;23161:14:0;;21534:4;;23201:21;;;;;;339:18:1;;23201:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23178:6;:18;;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:61;;;;:::i;:::-;:75;;;;:::i;:::-;23161:92;-1:-1:-1;23262:20:0;23320:14;23327:7;23320:4;:14;:::i;:::-;21483:6;23286:16;23295:7;23286:6;:16;:::i;:::-;23285:31;;;;:::i;:::-;:50;;;;:::i;:::-;23262:73;;23344:20;23368:30;23385:12;23368:16;:30::i;:::-;23344:54;;23506:30;23556:8;:17;;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23506:70;;23922:12;23907;23882:13;:20;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:37;;;;:::i;:::-;:52;;;;:::i;:::-;23871:63;;21483:6;23979:7;;;;;;;;;;;:11;;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23966:26;;21483:6;23966:26;:::i;:::-;23954:39;;:8;:39;:::i;:::-;:52;;;;:::i;:::-;23943:63;22775:1237;-1:-1:-1;;;;;;;;;22775:1237:0:o;22418:98::-;22478:9;;;;22464:10;:23;22460:50;;22496:14;;;;;;;;;;;;;;22460:50;22418:98::o;14916:222::-;15071:58;;3804:42:1;3792:55;;15071:58:0;;;3774:74:1;3864:18;;;3857:34;;;15044:86:0;;15064:5;;15094:23;;3747:18:1;;15071:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15044:19;:86::i;15674:627::-;16049:10;;;16048:62;;-1:-1:-1;16065:39:0;;;;;16089:4;16065:39;;;4137:34:1;16065:15:0;4207::1;;;4187:18;;;4180:43;16065:15:0;;;;;4049:18:1;;16065:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;16048:62;16026:166;;;;;;;4436:2:1;16026:166:0;;;4418:21:1;4475:2;4455:18;;;4448:30;4514:34;4494:18;;;4487:62;4585:24;4565:18;;;4558:52;4627:19;;16026:166:0;;;;;;;;;16230:62;;3804:42:1;3792:55;;16230:62:0;;;3774:74:1;3864:18;;;3857:34;;;16203:90:0;;16223:5;;16253:22;;3747:18:1;;16230:62:0;3600:297:1;26422:356:0;26486:12;26506:16;26525:7;;;;;;;;;;;:22;;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26506:43;;26556:11;21378:5;26578;:24;26574:161;;-1:-1:-1;21378:5:0;26574:161;;;26660:8;26652:5;:16;26648:87;;;-1:-1:-1;26685:5:0;26648:87;;;-1:-1:-1;26719:8:0;26648:87;21483:6;26748:11;26754:5;26748:3;:11;:::i;:::-;:24;;;;:::i;:::-;26741:31;26422:356;-1:-1:-1;;;;26422:356:0:o;18049:727::-;18484:23;18510:69;18538:4;18510:69;;;;;;;;;;;;;;;;;18518:5;18510:27;;;;:69;;;;;:::i;:::-;18594:17;;18484:95;;-1:-1:-1;18594:21:0;18590:179;;18691:10;18680:30;;;;;;;;;;;;:::i;:::-;18672:85;;;;;;;5141:2:1;18672:85:0;;;5123:21:1;5180:2;5160:18;;;5153:30;5219:34;5199:18;;;5192:62;5290:12;5270:18;;;5263:40;5320:19;;18672:85:0;4939:406:1;9843:229:0;9980:12;10012:52;10034:6;10042:4;10048:1;10051:12;9980;11251;11265:23;11292:6;:11;;11311:5;11318:4;11292:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11250:73;;;;11341:69;11368:6;11376:7;11385:10;11397:12;11341:26;:69::i;:::-;11334:76;10963:455;-1:-1:-1;;;;;;;10963:455:0:o;12623:644::-;12808:12;12837:7;12833:427;;;12865:10;:17;12886:1;12865:22;12861:290;;7381:19;;;;13075:60;;;;;;;6506:2:1;13075:60:0;;;6488:21:1;6545:2;6525:18;;;6518:30;6584:31;6564:18;;;6557:59;6633:18;;13075:60:0;6304:353:1;13075:60:0;-1:-1:-1;13172:10:0;13165:17;;12833:427;13215:33;13223:10;13235:12;13970:17;;:21;13966:388;;14202:10;14196:17;14259:15;14246:10;14242:2;14238:19;14231:44;13966:388;14329:12;14322:20;;;;;;;;;;;:::i;682:154:1:-;768:42;761:5;757:54;750:5;747:65;737:93;;826:1;823;816:12;737:93;682:154;:::o;841:247::-;900:6;953:2;941:9;932:7;928:23;924:32;921:52;;;969:1;966;959:12;921:52;1008:9;995:23;1027:31;1052:5;1027:31;:::i;:::-;1077:5;841:247;-1:-1:-1;;;841:247:1:o;1285:529::-;1362:6;1370;1378;1431:2;1419:9;1410:7;1406:23;1402:32;1399:52;;;1447:1;1444;1437:12;1399:52;1486:9;1473:23;1505:31;1530:5;1505:31;:::i;:::-;1555:5;-1:-1:-1;1612:2:1;1597:18;;1584:32;1625:33;1584:32;1625:33;:::i;:::-;1677:7;-1:-1:-1;1736:2:1;1721:18;;1708:32;1749:33;1708:32;1749:33;:::i;:::-;1801:7;1791:17;;;1285:529;;;;;:::o;1819:180::-;1878:6;1931:2;1919:9;1910:7;1906:23;1902:32;1899:52;;;1947:1;1944;1937:12;1899:52;-1:-1:-1;1970:23:1;;1819:180;-1:-1:-1;1819:180:1:o;2251:184::-;2321:6;2374:2;2362:9;2353:7;2349:23;2345:32;2342:52;;;2390:1;2387;2380:12;2342:52;-1:-1:-1;2413:16:1;;2251:184;-1:-1:-1;2251:184:1:o;2440:251::-;2510:6;2563:2;2551:9;2542:7;2538:23;2534:32;2531:52;;;2579:1;2576;2569:12;2531:52;2611:9;2605:16;2630:31;2655:5;2630:31;:::i;2696:184::-;2748:77;2745:1;2738:88;2845:4;2842:1;2835:15;2869:4;2866:1;2859:15;2885:125;2950:9;;;2971:10;;;2968:36;;;2984:18;;:::i;:::-;2885:125;;;;:::o;3015:128::-;3082:9;;;3103:11;;;3100:37;;;3117:18;;:::i;3148:168::-;3221:9;;;3252;;3269:15;;;3263:22;;3249:37;3239:71;;3290:18;;:::i;3321:274::-;3361:1;3387;3377:189;;3422:77;3419:1;3412:88;3523:4;3520:1;3513:15;3551:4;3548:1;3541:15;3377:189;-1:-1:-1;3580:9:1;;3321:274::o;4657:277::-;4724:6;4777:2;4765:9;4756:7;4752:23;4748:32;4745:52;;;4793:1;4790;4783:12;4745:52;4825:9;4819:16;4878:5;4871:13;4864:21;4857:5;4854:32;4844:60;;4900:1;4897;4890:12;5757:250;5842:1;5852:113;5866:6;5863:1;5860:13;5852:113;;;5942:11;;;5936:18;5923:11;;;5916:39;5888:2;5881:10;5852:113;;;-1:-1:-1;;5999:1:1;5981:16;;5974:27;5757:250::o;6012:287::-;6141:3;6179:6;6173:13;6195:66;6254:6;6249:3;6242:4;6234:6;6230:17;6195:66;:::i;:::-;6277:16;;;;;6012:287;-1:-1:-1;;6012:287:1:o;6662:455::-;6811:2;6800:9;6793:21;6774:4;6843:6;6837:13;6886:6;6881:2;6870:9;6866:18;6859:34;6902:79;6974:6;6969:2;6958:9;6954:18;6949:2;6941:6;6937:15;6902:79;:::i;:::-;7033:2;7021:15;7038:66;7017:88;7002:104;;;;7108:2;6998:113;;6662:455;-1:-1:-1;;6662:455:1:o

ipfs://9afecbd7cc94f9a38772cf4a5efb437bd5136dd2b81aa0944c42d2186e248a51