Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.18;

import { IVault } from "./interfaces/IVault.sol";
import { FixedPointMathLib } from "@solmate/utils/FixedPointMathLib.sol";
import { Auth, Authority } from "@solmate/auth/Auth.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

contract DelayedWithdraw is Auth, ReentrancyGuard {
  using SafeERC20 for IERC20Metadata;
  using SafeERC20 for ERC20;
  using FixedPointMathLib for uint256;

  // ========================================= STRUCTS =========================================

  /**
   * @param allowWithdraws Whether or not withdrawals are allowed for this asset.
   * @param withdrawDelay The delay in seconds before a requested withdrawal can be completed.
   * @param outstandingShares The total number of shares that are currently outstanding for an asset.
   * @param withdrawFee The fee that is charged when a withdrawal is completed.
   * @param maxLoss The maximum loss that can be incurred when completing a withdrawal, evaluating the
   *                exchange rate at time of withdraw, compared to time of completion.
   * @param maxWithdrawPerUser maximum withdraw per user
   */
  struct WithdrawAsset {
    bool allowWithdraws;
    uint32 withdrawDelay;
    uint128 outstandingShares;
    uint16 withdrawFee;
    uint16 maxLoss;
    uint256 maxWithdrawPerUser;
  }

  /**
   * @param allowThirdPartyToComplete Whether or not a 3rd party can complete a withdraw on behalf of a user.
   * @param maturity The time at which the withdrawal can be completed.
   * @param shares The number of shares that are requested to be withdrawn.
   * @param assetsAtTimeOfRequest The exchange rate at the time of the request.
   */
  struct WithdrawRequest {
    bool allowThirdPartyToComplete;
    uint40 maturity;
    uint96 shares;
    uint256 assetsAtTimeOfRequest;
  }

  struct WithdrawUserRequests {
    mapping(uint256 => WithdrawRequest) requests;
    uint256[] keys;
    uint256 lastIdx;
  }

  // ========================================= CONSTANTS =========================================

  /**
   * @notice The largest withdraw fee that can be set.
   */
  uint16 internal constant MAX_WITHDRAW_FEE = 0.2e4;

  /**
   * @notice The largest max loss that can be set.
   */
  uint16 internal constant MAX_LOSS = 10_000;

  // ========================================= STATE =========================================

  /**
   * @notice The address that receives the fee when a withdrawal is completed.
   */
  address public feeAddress;

  /**
   * @notice The mapping of assets to their respective withdrawal settings.
   */
  mapping(ERC20 => WithdrawAsset) public withdrawAssets;

  /**
   * @notice The mapping of users to withdraw asset to their withdrawal requests.
   */
  mapping(address => mapping(ERC20 => WithdrawUserRequests)) internal withdrawRequests;

  /**
   * @notice Used to pause calls to `requestWithdraw`, and `completeWithdraw`.
   */
  bool public isPaused;

  //============================== ERRORS ===============================

  error DelayedWithdraw__WithdrawFeeTooHigh();
  error DelayedWithdraw__MaxLossTooLarge();
  error DelayedWithdraw__AlreadySetup();
  error DelayedWithdraw__WithdrawsNotAllowed();
  error DelayedWithdraw__WithdrawNotMatured();
  error DelayedWithdraw__NoSharesToWithdraw();
  error DelayedWithdraw__MaxLossExceeded();
  error DelayedWithdraw__transferNotAllowed();
  error DelayedWithdraw__WrongVaultStrategy();
  error DelayedWithdraw__BadAddress();
  error DelayedWithdraw__ThirdPartyCompletionNotAllowed();
  error DelayedWithdraw__WrongAsset();
  error DelayedWithdraw__Paused();
  error DelayedWithdraw__SharesIs0();
  error DelayedWithdraw__ExceedsMaxWithdrawPerUser();

  //============================== EVENTS ===============================

  event WithdrawRequested(
    address indexed account,
    ERC20 indexed asset,
    uint96 shares,
    uint40 maturity,
    bool allowThirdPartyToComplete,
    uint256 indexed withdrawalIdx
  );
  event WithdrawCancelled(address indexed account, ERC20 indexed asset, uint96 shares, uint256 indexed withdrawalIdx);
  event WithdrawCompleted(
    address indexed account,
    ERC20 indexed asset,
    uint256 shares,
    uint256 assets,
    uint256 indexed withdrawalIdx
  );
  event FeeAddressSet(address newFeeAddress);
  event SetupWithdrawalsInAsset(
    address indexed asset,
    uint64 withdrawDelay,
    uint16 withdrawFee,
    uint16 maxLoss,
    uint256 maxWithdrawPerUser
  );
  event WithdrawDelayUpdated(address indexed asset, uint256 newWithdrawDelay);
  event WithdrawFeeUpdated(address indexed asset, uint16 newWithdrawFee);
  event MaxLossUpdated(address indexed asset, uint16 newMaxLoss);
  event WithdrawalsStopped(address indexed asset);
  event ThirdPartyCompletionChanged(
    address indexed account,
    ERC20 indexed asset,
    bool allowed,
    uint256 indexed withdrawalIdx
  );
  event WithrawalCompleted(address indexed account, uint256 indexed withdrawalIdx);
  event Paused();
  event Unpaused();
  event MaxWithdrawPerUserUpdated(address indexed asset, uint256 newMaxWithdrawPerUser);

  //============================== IMMUTABLES ===============================

  /**
   * @notice The VaultV3 contract that users are withdrawing from.
   */
  IVault internal immutable lrtVault;

  constructor(address _owner, address _lrtVault, address _feeAddress) Auth(_owner, Authority(address(0))) {
    lrtVault = IVault(payable(_lrtVault));
    if (_feeAddress == address(0)) revert DelayedWithdraw__BadAddress();
    feeAddress = _feeAddress;
    emit FeeAddressSet(_feeAddress);
  }

  // ========================================= ADMIN FUNCTIONS =========================================

  /**
   * @notice Pause this contract.
   * @dev Callable by MULTISIG_ROLE.
   */
  function pause() external requiresAuth {
    isPaused = true;
    emit Paused();
  }

  /**
   * @notice Unpause this contract.
   * @dev Callable by MULTISIG_ROLE.
   */
  function unpause() external requiresAuth {
    isPaused = false;
    emit Unpaused();
  }

  /**
   * @notice Stops withdrawals for a specific asset.
   * @dev Callable by MULTISIG_ROLE.
   */
  function stopWithdrawalsInAsset(ERC20 asset) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();

    withdrawAsset.allowWithdraws = false;

    emit WithdrawalsStopped(address(asset));
  }

  /**
   * @notice Sets up the withdrawal settings for a specific asset.
   * @dev Callable by OWNER_ROLE.
   */
  function setupWithdrawAsset(
    ERC20 asset,
    uint32 withdrawDelay,
    uint16 withdrawFee,
    uint16 maxLoss,
    uint256 maxWithdrawPerUser
  ) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];

    if (withdrawFee > MAX_WITHDRAW_FEE) revert DelayedWithdraw__WithdrawFeeTooHigh();
    if (maxLoss > MAX_LOSS) revert DelayedWithdraw__MaxLossTooLarge();

    if (withdrawAsset.allowWithdraws) revert DelayedWithdraw__AlreadySetup();
    if (address(asset) != lrtVault.asset()) revert DelayedWithdraw__WrongAsset();
    withdrawAsset.allowWithdraws = true;
    withdrawAsset.withdrawDelay = withdrawDelay;
    withdrawAsset.withdrawFee = withdrawFee;
    withdrawAsset.maxLoss = maxLoss;
    withdrawAsset.maxWithdrawPerUser = maxWithdrawPerUser;

    emit SetupWithdrawalsInAsset(address(asset), withdrawDelay, withdrawFee, maxLoss, maxWithdrawPerUser);
  }

  /**
   * @notice Changes the withdraw delay for a specific asset.
   * @dev Callable by MULTISIG_ROLE.
   */
  function changeWithdrawDelay(ERC20 asset, uint32 withdrawDelay) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();

    withdrawAsset.withdrawDelay = withdrawDelay;

    emit WithdrawDelayUpdated(address(asset), withdrawDelay);
  }

  /**
   * @notice Changes the withdraw fee for a specific asset.
   * @dev Callable by OWNER_ROLE.
   */
  function changeWithdrawFee(ERC20 asset, uint16 withdrawFee) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();

    if (withdrawFee > MAX_WITHDRAW_FEE) revert DelayedWithdraw__WithdrawFeeTooHigh();

    withdrawAsset.withdrawFee = withdrawFee;

    emit WithdrawFeeUpdated(address(asset), withdrawFee);
  }

  /**
   * @notice Changes the max loss for a specific asset.
   * @dev Callable by OWNER_ROLE.
   * @dev Since maxLoss is a global value based off some withdraw asset, it is possible that a user
   *      creates a request, then the maxLoss is updated to some value the user is not comfortable with.
   *      In this case the user should cancel their request. However this is not always possible, so a
   *      better course of action would be if the maxLoss needs to be updated, the asset can be fully removed.
   *      Then all exisitng requests for that asset can be cancelled, and finally the maxLoss can be updated.
   */
  function changeMaxLoss(ERC20 asset, uint16 maxLoss) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();

    if (maxLoss > MAX_LOSS) revert DelayedWithdraw__MaxLossTooLarge();

    withdrawAsset.maxLoss = maxLoss;

    emit MaxLossUpdated(address(asset), maxLoss);
  }

  /**
   * @notice Changes the fee address.
   * @dev Callable by STRATEGIST_MULTISIG_ROLE.
   */
  function setFeeAddress(address _feeAddress) external requiresAuth {
    if (_feeAddress == address(0)) revert DelayedWithdraw__BadAddress();
    feeAddress = _feeAddress;

    emit FeeAddressSet(_feeAddress);
  }

  /**
   * @notice Sets the maximum withdrawal amount per user for a specific asset.
   * @dev Callable by OWNER_ROLE.
   * @param asset The ERC20 token address
   * @param maxWithdraw The maximum amount a user can withdraw
   */
  function setMaxWithdrawPerUser(ERC20 asset, uint256 maxWithdraw) external requiresAuth {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];

    withdrawAsset.maxWithdrawPerUser = maxWithdraw;

    emit MaxWithdrawPerUserUpdated(address(asset), maxWithdraw);
  }

  /**
   * @notice Cancels a user's withdrawal request.
   * @dev Callable by MULTISIG_ROLE, and STRATEGIST_MULTISIG_ROLE.
   */
  function cancelUserWithdraw(ERC20 asset, address user, uint256 withdrawalIdx) external requiresAuth {
    _cancelWithdraw(asset, user, withdrawalIdx);
  }

  /**
   * @notice Completes a user's withdrawal request.
   * @dev Admins can complete requests even if they are outside the completion window.
   * @dev Callable by MULTISIG_ROLE, and STRATEGIST_MULTISIG_ROLE.
   */
  function completeUserWithdraw(
    ERC20 asset,
    address user,
    uint256 withdrawalIdx
  ) external requiresAuth returns (uint256 assetsOut) {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    WithdrawUserRequests storage userRequests = withdrawRequests[user][asset];

    WithdrawRequest storage req = userRequests.requests[withdrawalIdx];
    assetsOut = _completeWithdraw(asset, user, withdrawAsset, req, withdrawalIdx);

    _deleteWithdrawRequest(userRequests, withdrawalIdx);
  }

  // ========================================= PUBLIC FUNCTIONS =========================================

  /**
   * @notice Allows a user to set whether or not a 3rd party can complete withdraws on behalf of them.
   */
  function setAllowThirdPartyToComplete(ERC20 asset, bool allow, uint256 withdrawalIdx) external requiresAuth {
    withdrawRequests[msg.sender][asset].requests[withdrawalIdx].allowThirdPartyToComplete = allow;

    emit ThirdPartyCompletionChanged(msg.sender, asset, allow, withdrawalIdx);
  }

  /**
   * @notice Requests a withdrawal of shares for a specific asset.
   * @dev Publicly callable.
   */
  function requestWithdraw(
    ERC20 asset,
    uint96 shares,
    bool allowThirdPartyToComplete
  ) external requiresAuth nonReentrant {
    if (isPaused) revert DelayedWithdraw__Paused();
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();
    if (shares == 0) revert DelayedWithdraw__SharesIs0();

    WithdrawUserRequests storage userRequests = withdrawRequests[msg.sender][asset];
    if (userRequests.keys.length >= withdrawAsset.maxWithdrawPerUser) {
      revert DelayedWithdraw__ExceedsMaxWithdrawPerUser();
    }
    IERC20Metadata(lrtVault).safeTransferFrom(msg.sender, address(this), shares);

    withdrawAsset.outstandingShares += shares;

    uint256 lastIdx = userRequests.lastIdx + 1;
    userRequests.lastIdx = lastIdx;
    userRequests.keys.push(lastIdx);

    uint40 maturity = uint40(block.timestamp + withdrawAsset.withdrawDelay);

    userRequests.requests[lastIdx] = WithdrawRequest({
      allowThirdPartyToComplete: allowThirdPartyToComplete,
      maturity: maturity,
      assetsAtTimeOfRequest: lrtVault.previewRedeem(shares),
      shares: shares
    });

    emit WithdrawRequested(msg.sender, asset, shares, maturity, allowThirdPartyToComplete, lastIdx);
  }

  /**
   * @notice Cancels msg.sender's withdrawal request.
   * @dev not callable in a regular mode.
   */
  function cancelWithdraw(ERC20 asset, uint256 withdrawalIdx) external requiresAuth nonReentrant {
    _cancelWithdraw(asset, msg.sender, withdrawalIdx);
  }

  /**
   * @notice Completes a user's withdrawal request.
   * @dev Publicly callable.
   */
  function completeWithdraw(
    ERC20 asset,
    address account,
    uint256 withdrawalIdx
  ) external requiresAuth nonReentrant returns (uint256 assetsOut) {
    if (isPaused) revert DelayedWithdraw__Paused();
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    WithdrawUserRequests storage userRequests = withdrawRequests[account][asset];

    WithdrawRequest storage req = userRequests.requests[withdrawalIdx];

    if (msg.sender != account && !req.allowThirdPartyToComplete) {
      revert DelayedWithdraw__ThirdPartyCompletionNotAllowed();
    }
    assetsOut = _completeWithdraw(asset, account, withdrawAsset, req, withdrawalIdx);
    _deleteWithdrawRequest(userRequests, withdrawalIdx);

    emit WithrawalCompleted(account, withdrawalIdx);
  }

  /**
   * @notice Transfers any leftover balance (dust) of the specified ERC20 asset to the strategy vault.
   * @dev This function ensures that any remaining tokens in the contract are moved to the strategy.
   *      Reverts if the asset is the same as the lrtVault.
   *      Callable by MULTISIG_ROLE
   * @param asset The ERC20 asset from which dust is to be transferred.
   */
  function transferDustToStrategy(ERC20 asset) external requiresAuth {
    if (address(asset) == address(lrtVault)) revert DelayedWithdraw__transferNotAllowed();
    address[] memory default_queue = lrtVault.get_default_queue();
    if (default_queue.length != 1) revert DelayedWithdraw__WrongVaultStrategy();
    uint256 balance = asset.balanceOf(address(this));
    if (balance > 0) {
      asset.safeTransfer(default_queue[0], balance);
    }
  }

  /**
   * @notice Transfers the specified number of locked shares to the given account.
   * @dev Uses the safeTransfer function of the IERC20Metadata interface to ensure the transfer is safe.
   *      Callable by OWNER
   */
  function safeLockedShares(address account, uint256 shares, ERC20 asset) external requiresAuth {
    if (address(asset) != address(lrtVault)) revert DelayedWithdraw__transferNotAllowed();

    WithdrawAsset memory withdrawAsset = withdrawAssets[ERC20(lrtVault.asset())];
    if (withdrawAsset.outstandingShares + shares > asset.balanceOf(address(this)))
      revert DelayedWithdraw__transferNotAllowed();
    IERC20Metadata(asset).safeTransfer(account, shares);
  }

  // ========================================= VIEW FUNCTIONS =========================================

  /**
   * @notice Helper function to view the outstanding withdraw debt for a specific asset.
   */
  function viewOutstandingDebt(ERC20 asset) public view returns (uint256 debt) {
    debt = lrtVault.previewRedeem(withdrawAssets[asset].outstandingShares);
  }

  /**
   * @notice Helper function to view the outstanding withdraw debt for multiple assets.
   */
  function viewOutstandingDebts(ERC20[] calldata assets) external view returns (uint256[] memory debts) {
    debts = new uint256[](assets.length);
    for (uint256 i = 0; i < assets.length; i++) {
      debts[i] = viewOutstandingDebt(assets[i]);
    }
  }
  /// @notice Retrieves all withdraw requests for a given user and asset
  /// @param user The address of the user
  /// @param asset The ERC20 token address
  /// @return requests An array of WithdrawRequest structures
  /// @return keys An array of keys corresponding to each WithdrawRequest
  /// @return lastIdx The last index used for withdraw requests
  function getAllWithdrawRequests(
    address user,
    ERC20 asset
  ) public view returns (WithdrawRequest[] memory requests, uint256[] memory keys, uint256 lastIdx) {
    WithdrawUserRequests storage userRequests = withdrawRequests[user][asset];
    keys = userRequests.keys;
    uint256 keyCount = keys.length;

    requests = new WithdrawRequest[](keyCount);

    for (uint256 i = 0; i < keyCount; i++) {
      requests[i] = userRequests.requests[keys[i]];
    }

    lastIdx = userRequests.lastIdx;

    return (requests, keys, lastIdx);
  }

  /// @notice Retrieves a single withdraw request for a given user, asset, and withdrawal index
  /// @param user The address of the user
  /// @param asset The ERC20 token address
  /// @param withdrawalIdx The index of the withdrawal request
  /// @return A WithdrawRequest structure
  function getWithdrawRequest(
    address user,
    ERC20 asset,
    uint256 withdrawalIdx
  ) external view returns (WithdrawRequest memory) {
    return withdrawRequests[user][asset].requests[withdrawalIdx];
  }

  /// @notice Retrieves the array of keys for withdraw requests of a given user and asset
  /// @param user The address of the user
  /// @param asset The ERC20 token address
  /// @return An array of uint256 keys
  function getWithdrawRequestKeys(address user, ERC20 asset) external view returns (uint256[] memory) {
    return withdrawRequests[user][asset].keys;
  }

  /// @notice Retrieves the last index used for withdraw requests of a given user and asset
  /// @param user The address of the user
  /// @param asset The ERC20 token address
  /// @return The last index (uint256) used
  function getWithdrawRequestLastIdx(address user, ERC20 asset) external view returns (uint256) {
    return withdrawRequests[user][asset].lastIdx;
  }

  // ========================================= INTERNAL FUNCTIONS =========================================

  /**
   * @notice Internal helper function that implements shared logic for cancelling a user's withdrawal request.
   */
  function _cancelWithdraw(ERC20 asset, address account, uint256 withdrawalIdx) internal {
    WithdrawAsset storage withdrawAsset = withdrawAssets[asset];
    // We do not check if `asset` is allowed, to handle edge cases where the asset is no longer allowed.
    WithdrawUserRequests storage userRequests = withdrawRequests[account][asset];

    WithdrawRequest storage req = userRequests.requests[withdrawalIdx];

    uint96 shares = req.shares;
    if (shares == 0) revert DelayedWithdraw__NoSharesToWithdraw();
    withdrawAsset.outstandingShares -= shares;
    req.shares = 0;
    IERC20Metadata(lrtVault).safeTransfer(account, shares);
    _deleteWithdrawRequest(userRequests, withdrawalIdx);

    emit WithdrawCancelled(account, asset, shares, withdrawalIdx);
  }

  /**
   * @notice Internal helper function that implements shared logic for completing a user's withdrawal request.
   */
  function _completeWithdraw(
    ERC20 asset,
    address account,
    WithdrawAsset storage withdrawAsset,
    WithdrawRequest storage req,
    uint256 withdrawalIdx
  ) internal returns (uint256 minAssetToWithdraw) {
    if (!withdrawAsset.allowWithdraws) revert DelayedWithdraw__WithdrawsNotAllowed();

    if (block.timestamp < req.maturity) revert DelayedWithdraw__WithdrawNotMatured();
    uint256 shares = req.shares;
    if (shares == 0) revert DelayedWithdraw__NoSharesToWithdraw();

    uint256 currentAssetToWithdraw = lrtVault.previewRedeem(shares);
    minAssetToWithdraw = req.assetsAtTimeOfRequest < currentAssetToWithdraw
      ? req.assetsAtTimeOfRequest
      : currentAssetToWithdraw;
    // Safe to cast shares to a uint128 since req.shares is constrained to be less than 2^96.
    withdrawAsset.outstandingShares -= uint128(shares);

    if (withdrawAsset.withdrawFee > 0 && msg.sender != feeAddress) {
      // Handle withdraw fee.
      uint256 fee = uint256(shares).mulDivDown(withdrawAsset.withdrawFee, 1e4);
      shares -= fee;
      minAssetToWithdraw -= minAssetToWithdraw.mulDivDown(withdrawAsset.withdrawFee, 1e4);

      // Transfer fee to feeAddress.
      IERC20Metadata(lrtVault).safeTransfer(feeAddress, fee);
    }

    req.shares = 0;

    uint256 balanceBefore = asset.balanceOf(address(this));

    lrtVault.redeem(shares, address(this), address(this), withdrawAsset.maxLoss);

    uint256 balanceAfter = asset.balanceOf(address(this));

    minAssetToWithdraw = Math.min(balanceAfter - balanceBefore, minAssetToWithdraw);

    asset.safeTransfer(account, minAssetToWithdraw);

    emit WithdrawCompleted(account, asset, shares, minAssetToWithdraw, withdrawalIdx);
  }

  function _deleteWithdrawRequest(WithdrawUserRequests storage userRequests, uint256 withdrawalIdx) internal {
    // Delete the request from the mapping
    delete userRequests.requests[withdrawalIdx];

    // Remove the withdrawalIdx from the keys array
    uint256 lastIndex = userRequests.keys.length - 1;
    for (uint256 i = 0; i <= lastIndex; i++) {
      if (userRequests.keys[i] == withdrawalIdx) {
        if (i != lastIndex) {
          userRequests.keys[i] = userRequests.keys[lastIndex];
        }
        userRequests.keys.pop();
        break;
      }
    }
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.18;

import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";

interface IVault is IERC4626 {
    // STRATEGY EVENTS
    event StrategyChanged(address indexed strategy, uint256 change_type);
    event StrategyReported(
        address indexed strategy,
        uint256 gain,
        uint256 loss,
        uint256 current_debt,
        uint256 protocol_fees,
        uint256 total_fees,
        uint256 total_refunds
    );
    // DEBT MANAGEMENT EVENTS
    event DebtUpdated(address indexed strategy, uint256 current_debt, uint256 new_debt);
    // ROLE UPDATES
    event RoleSet(address indexed account, uint256 role);
    event UpdateRoleManager(address indexed role_manager);

    event UpdateAccountant(address indexed accountant);
    event UpdateDefaultQueue(address[] new_default_queue);
    event UpdateUseDefaultQueue(bool use_default_queue);
    event UpdatedMaxDebtForStrategy(address indexed sender, address indexed strategy, uint256 new_debt);
    event UpdateDepositLimit(uint256 deposit_limit);
    event UpdateMinimumTotalIdle(uint256 minimum_total_idle);
    event UpdateProfitMaxUnlockTime(uint256 profit_max_unlock_time);
    event DebtPurchased(address indexed strategy, uint256 amount);
    event Shutdown();

    struct StrategyParams {
        uint256 activation;
        uint256 last_report;
        uint256 current_debt;
        uint256 max_debt;
    }

    function FACTORY() external view returns (uint256);

    function strategies(address) external view returns (StrategyParams memory);

    function default_queue(uint256) external view returns (address);

    function use_default_queue() external view returns (bool);

    function minimum_total_idle() external view returns (uint256);

    function deposit_limit() external view returns (uint256);

    function deposit_limit_module() external view returns (address);

    function withdraw_limit_module() external view returns (address);

    function accountant() external view returns (address);

    function roles(address) external view returns (uint256);

    function role_manager() external view returns (address);

    function future_role_manager() external view returns (address);

    function isShutdown() external view returns (bool);

    function nonces(address) external view returns (uint256);

    function initialize(address, string memory, string memory, address, uint256) external;

    function set_accountant(address new_accountant) external;

    function set_default_queue(address[] memory new_default_queue) external;

    function set_use_default_queue(bool) external;

    function set_deposit_limit(uint256 deposit_limit) external;

    function set_deposit_limit(uint256 deposit_limit, bool should_override) external;

    function set_deposit_limit_module(address new_deposit_limit_module) external;

    function set_deposit_limit_module(address new_deposit_limit_module, bool should_override) external;

    function set_withdraw_limit_module(address new_withdraw_limit_module) external;

    function set_minimum_total_idle(uint256 minimum_total_idle) external;

    function setProfitMaxUnlockTime(uint256 new_profit_max_unlock_time) external;

    function set_role(address account, uint256 role) external;

    function add_role(address account, uint256 role) external;

    function remove_role(address account, uint256 role) external;

    function transfer_role_manager(address role_manager) external;

    function accept_role_manager() external;

    function unlockedShares() external view returns (uint256);

    function pricePerShare() external view returns (uint256);

    function get_default_queue() external view returns (address[] memory);

    function process_report(address strategy) external returns (uint256, uint256);

    function buy_debt(address strategy, uint256 amount) external;

    function add_strategy(address new_strategy) external;

    function revoke_strategy(address strategy) external;

    function force_revoke_strategy(address strategy) external;

    function update_max_debt_for_strategy(address strategy, uint256 new_max_debt) external;

    function update_debt(address strategy, uint256 target_debt) external returns (uint256);

    function update_debt(address strategy, uint256 target_debt, uint256 max_loss) external returns (uint256);

    function shutdown_vault() external;

    function totalIdle() external view returns (uint256);

    function totalDebt() external view returns (uint256);

    function apiVersion() external view returns (string memory);

    function assess_share_of_unrealised_losses(
        address strategy,
        uint256 assets_needed
    )
        external
        view
        returns (uint256);

    function profitMaxUnlockTime() external view returns (uint256);

    function fullProfitUnlockDate() external view returns (uint256);

    function profitUnlockingRate() external view returns (uint256);

    function lastProfitUpdate() external view returns (uint256);

    //// NON-STANDARD ERC-4626 FUNCTIONS \\\\

    function withdraw(uint256 assets, address receiver, address owner, uint256 max_loss) external returns (uint256);

    function withdraw(
        uint256 assets,
        address receiver,
        address owner,
        uint256 max_loss,
        address[] memory strategies
    )
        external
        returns (uint256);

    function redeem(uint256 shares, address receiver, address owner, uint256 max_loss) external returns (uint256);

    function redeem(
        uint256 shares,
        address receiver,
        address owner,
        uint256 max_loss,
        address[] memory strategies
    )
        external
        returns (uint256);

    function maxWithdraw(address owner, uint256 max_loss) external view returns (uint256);

    function maxWithdraw(
        address owner,
        uint256 max_loss,
        address[] memory strategies
    )
        external
        view
        returns (uint256);

    function maxRedeem(address owner, uint256 max_loss) external view returns (uint256);

    function maxRedeem(address owner, uint256 max_loss, address[] memory strategies) external view returns (uint256);

    //// NON-STANDARD ERC-20 FUNCTIONS \\\\

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
        returns (bool);

    function convertToAssets(uint256 shares) external view returns (uint256);

    function balanceOf(address) external view returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant MAX_UINT256 = 2**256 - 1;

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // Divide x * y by the denominator.
            z := div(mul(x, y), denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // If x * y modulo the denominator is strictly greater than 0,
            // 1 is added to round up the division of x * y by the denominator.
            z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            let y := x // We start y at x, which will help us make our initial estimate.

            z := 181 // The "correct" value is 1, but this saves a multiplication later.

            // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
            // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.

            // We check y >= 2^(k + 8) but shift right by k bits
            // each branch to ensure that if x >= 256, then y >= 256.
            if iszero(lt(y, 0x10000000000000000000000000000000000)) {
                y := shr(128, y)
                z := shl(64, z)
            }
            if iszero(lt(y, 0x1000000000000000000)) {
                y := shr(64, y)
                z := shl(32, z)
            }
            if iszero(lt(y, 0x10000000000)) {
                y := shr(32, y)
                z := shl(16, z)
            }
            if iszero(lt(y, 0x1000000)) {
                y := shr(16, y)
                z := shl(8, z)
            }

            // Goal was to get z*z*y within a small factor of x. More iterations could
            // get y in a tighter range. Currently, we will have y in [256, 256*2^16).
            // We ensured y >= 256 so that the relative difference between y and y+1 is small.
            // That's not possible if x < 256 but we can just verify those cases exhaustively.

            // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
            // Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
            // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.

            // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
            // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.

            // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
            // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.

            // There is no overflow risk here since y < 2^136 after the first branch above.
            z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.

            // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // If x+1 is a perfect square, the Babylonian method cycles between
            // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
            // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
            // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
            // If you don't care whether the floor or ceil square root is returned, you can remove this statement.
            z := sub(z, lt(div(x, z), z))
        }
    }

    function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Mod x by y. Note this will return
            // 0 instead of reverting if y is zero.
            z := mod(x, y)
        }
    }

    function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Divide x by y. Note this will return
            // 0 instead of reverting if y is zero.
            r := div(x, y)
        }
    }

    function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Add 1 to x * y if x % y > 0. Note this will
            // return 0 instead of reverting if y is zero.
            z := add(gt(mod(x, y), 0), div(x, y))
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Provides a flexible and updatable auth pattern which is completely separate from application logic.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
abstract contract Auth {
    event OwnershipTransferred(address indexed user, address indexed newOwner);

    event AuthorityUpdated(address indexed user, Authority indexed newAuthority);

    address public owner;

    Authority public authority;

    constructor(address _owner, Authority _authority) {
        owner = _owner;
        authority = _authority;

        emit OwnershipTransferred(msg.sender, _owner);
        emit AuthorityUpdated(msg.sender, _authority);
    }

    modifier requiresAuth() virtual {
        require(isAuthorized(msg.sender, msg.sig), "UNAUTHORIZED");

        _;
    }

    function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) {
        Authority auth = authority; // Memoizing authority saves us a warm SLOAD, around 100 gas.

        // Checking if the caller is the owner only after calling the authority saves gas in most cases, but be
        // aware that this makes protected functions uncallable even to the owner if the authority is out of order.
        return (address(auth) != address(0) && auth.canCall(user, address(this), functionSig)) || user == owner;
    }

    function setAuthority(Authority newAuthority) public virtual {
        // We check if the caller is the owner first because we want to ensure they can
        // always swap out the authority even if it's reverting or using up a lot of gas.
        require(msg.sender == owner || authority.canCall(msg.sender, address(this), msg.sig));

        authority = newAuthority;

        emit AuthorityUpdated(msg.sender, newAuthority);
    }

    function transferOwnership(address newOwner) public virtual requiresAuth {
        owner = newOwner;

        emit OwnershipTransferred(msg.sender, newOwner);
    }
}

/// @notice A generic interface for a contract which provides authorization data to an Auth instance.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
interface Authority {
    function canCall(
        address user,
        address target,
        bytes4 functionSig
    ) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

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

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

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

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4626.sol)

pragma solidity ^0.8.0;

import "../token/ERC20/IERC20.sol";
import "../token/ERC20/extensions/IERC20Metadata.sol";

/**
 * @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
 * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
 *
 * _Available since v4.7._
 */
interface IERC4626 is IERC20, IERC20Metadata {
    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

    event Withdraw(
        address indexed sender,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function asset() external view returns (address assetTokenAddress);

    /**
     * @dev Returns the total amount of the underlying asset that is “managed” by Vault.
     *
     * - SHOULD include any compounding that occurs from yield.
     * - MUST be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT revert.
     */
    function totalAssets() external view returns (uint256 totalManagedAssets);

    /**
     * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToShares(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToAssets(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
     * through a deposit call.
     *
     * - MUST return a limited value if receiver is subject to some deposit limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
     * - MUST NOT revert.
     */
    function maxDeposit(address receiver) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
     *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
     *   in the same transaction.
     * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
     *   deposit would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewDeposit(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   deposit execution, and are accounted for during deposit.
     * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
     * - MUST return a limited value if receiver is subject to some mint limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
     * - MUST NOT revert.
     */
    function maxMint(address receiver) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
     *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
     *   same transaction.
     * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
     *   would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by minting.
     */
    function previewMint(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
     *   execution, and are accounted for during mint.
     * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function mint(uint256 shares, address receiver) external returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
     * Vault, through a withdraw call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxWithdraw(address owner) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
     *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
     *   called
     *   in the same transaction.
     * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
     *   the withdrawal would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewWithdraw(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   withdraw execution, and are accounted for during withdraw.
     * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
     * through a redeem call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxRedeem(address owner) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
     *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
     *   same transaction.
     * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
     *   redemption would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by redeeming.
     */
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   redeem execution, and are accounted for during redeem.
     * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "@openzeppelin-upgradeable/contracts/=node_modules/@openzeppelin/contracts-upgradeable/",
    "forge-std/=node_modules/forge-std/src/",
    "@solmate/=lib/solmate/src/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "hardhat/=node_modules/hardhat/",
    "solmate/=lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_lrtVault","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DelayedWithdraw__AlreadySetup","type":"error"},{"inputs":[],"name":"DelayedWithdraw__BadAddress","type":"error"},{"inputs":[],"name":"DelayedWithdraw__ExceedsMaxWithdrawPerUser","type":"error"},{"inputs":[],"name":"DelayedWithdraw__MaxLossExceeded","type":"error"},{"inputs":[],"name":"DelayedWithdraw__MaxLossTooLarge","type":"error"},{"inputs":[],"name":"DelayedWithdraw__NoSharesToWithdraw","type":"error"},{"inputs":[],"name":"DelayedWithdraw__Paused","type":"error"},{"inputs":[],"name":"DelayedWithdraw__SharesIs0","type":"error"},{"inputs":[],"name":"DelayedWithdraw__ThirdPartyCompletionNotAllowed","type":"error"},{"inputs":[],"name":"DelayedWithdraw__WithdrawFeeTooHigh","type":"error"},{"inputs":[],"name":"DelayedWithdraw__WithdrawNotMatured","type":"error"},{"inputs":[],"name":"DelayedWithdraw__WithdrawsNotAllowed","type":"error"},{"inputs":[],"name":"DelayedWithdraw__WrongAsset","type":"error"},{"inputs":[],"name":"DelayedWithdraw__WrongVaultStrategy","type":"error"},{"inputs":[],"name":"DelayedWithdraw__transferNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"contract Authority","name":"newAuthority","type":"address"}],"name":"AuthorityUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newFeeAddress","type":"address"}],"name":"FeeAddressSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint16","name":"newMaxLoss","type":"uint16"}],"name":"MaxLossUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"newMaxWithdrawPerUser","type":"uint256"}],"name":"MaxWithdrawPerUserUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint64","name":"withdrawDelay","type":"uint64"},{"indexed":false,"internalType":"uint16","name":"withdrawFee","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"maxLoss","type":"uint16"},{"indexed":false,"internalType":"uint256","name":"maxWithdrawPerUser","type":"uint256"}],"name":"SetupWithdrawalsInAsset","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"contract ERC20","name":"asset","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"},{"indexed":true,"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"ThirdPartyCompletionChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"contract ERC20","name":"asset","type":"address"},{"indexed":false,"internalType":"uint96","name":"shares","type":"uint96"},{"indexed":true,"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"WithdrawCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"contract ERC20","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"WithdrawCompleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"newWithdrawDelay","type":"uint256"}],"name":"WithdrawDelayUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint16","name":"newWithdrawFee","type":"uint16"}],"name":"WithdrawFeeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"contract ERC20","name":"asset","type":"address"},{"indexed":false,"internalType":"uint96","name":"shares","type":"uint96"},{"indexed":false,"internalType":"uint40","name":"maturity","type":"uint40"},{"indexed":false,"internalType":"bool","name":"allowThirdPartyToComplete","type":"bool"},{"indexed":true,"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"WithdrawRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"WithdrawalsStopped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"WithrawalCompleted","type":"event"},{"inputs":[],"name":"authority","outputs":[{"internalType":"contract Authority","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"cancelUserWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"cancelWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint16","name":"maxLoss","type":"uint16"}],"name":"changeMaxLoss","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint32","name":"withdrawDelay","type":"uint32"}],"name":"changeWithdrawDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint16","name":"withdrawFee","type":"uint16"}],"name":"changeWithdrawFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"completeUserWithdraw","outputs":[{"internalType":"uint256","name":"assetsOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"completeWithdraw","outputs":[{"internalType":"uint256","name":"assetsOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"getAllWithdrawRequests","outputs":[{"components":[{"internalType":"bool","name":"allowThirdPartyToComplete","type":"bool"},{"internalType":"uint40","name":"maturity","type":"uint40"},{"internalType":"uint96","name":"shares","type":"uint96"},{"internalType":"uint256","name":"assetsAtTimeOfRequest","type":"uint256"}],"internalType":"struct DelayedWithdraw.WithdrawRequest[]","name":"requests","type":"tuple[]"},{"internalType":"uint256[]","name":"keys","type":"uint256[]"},{"internalType":"uint256","name":"lastIdx","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"getWithdrawRequest","outputs":[{"components":[{"internalType":"bool","name":"allowThirdPartyToComplete","type":"bool"},{"internalType":"uint40","name":"maturity","type":"uint40"},{"internalType":"uint96","name":"shares","type":"uint96"},{"internalType":"uint256","name":"assetsAtTimeOfRequest","type":"uint256"}],"internalType":"struct DelayedWithdraw.WithdrawRequest","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"getWithdrawRequestKeys","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"getWithdrawRequestLastIdx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint96","name":"shares","type":"uint96"},{"internalType":"bool","name":"allowThirdPartyToComplete","type":"bool"}],"name":"requestWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"safeLockedShares","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"bool","name":"allow","type":"bool"},{"internalType":"uint256","name":"withdrawalIdx","type":"uint256"}],"name":"setAllowThirdPartyToComplete","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract Authority","name":"newAuthority","type":"address"}],"name":"setAuthority","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint256","name":"maxWithdraw","type":"uint256"}],"name":"setMaxWithdrawPerUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"},{"internalType":"uint32","name":"withdrawDelay","type":"uint32"},{"internalType":"uint16","name":"withdrawFee","type":"uint16"},{"internalType":"uint16","name":"maxLoss","type":"uint16"},{"internalType":"uint256","name":"maxWithdrawPerUser","type":"uint256"}],"name":"setupWithdrawAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"stopWithdrawalsInAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"transferDustToStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"viewOutstandingDebt","outputs":[{"internalType":"uint256","name":"debt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20[]","name":"assets","type":"address[]"}],"name":"viewOutstandingDebts","outputs":[{"internalType":"uint256[]","name":"debts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"name":"withdrawAssets","outputs":[{"internalType":"bool","name":"allowWithdraws","type":"bool"},{"internalType":"uint32","name":"withdrawDelay","type":"uint32"},{"internalType":"uint128","name":"outstandingShares","type":"uint128"},{"internalType":"uint16","name":"withdrawFee","type":"uint16"},{"internalType":"uint16","name":"maxLoss","type":"uint16"},{"internalType":"uint256","name":"maxWithdrawPerUser","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000af994551f4f940224825f54f810ed5439651e5f9000000000000000000000000358d94b5b2f147d741088803d932acb566acb7b600000000000000000000000020fdf47509c5efc0e1101e3ce443691781c17f90

-----Decoded View---------------
Arg [0] : _owner (address): 0xaf994551f4f940224825F54F810ed5439651E5f9
Arg [1] : _lrtVault (address): 0x358d94b5b2F147D741088803d932Acb566acB7B6
Arg [2] : _feeAddress (address): 0x20fDF47509C5eFC0e1101e3CE443691781C17F90

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000af994551f4f940224825f54f810ed5439651e5f9
Arg [1] : 000000000000000000000000358d94b5b2f147d741088803d932acb566acb7b6
Arg [2] : 00000000000000000000000020fdf47509c5efc0e1101e3ce443691781c17f90