gmUSDC

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "../error/Errors.sol";

library AccountUtils {
    function validateAccount(address account) internal pure {
        if (account == address(0)) {
            revert Errors.EmptyAccount();
        }
    }

    function validateReceiver(address receiver) internal pure {
        if (receiver == address(0)) {
            revert Errors.EmptyReceiver();
        }
    }
}

// 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);
        }
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import { ERC20 } from "solmate/tokens/ERC20.sol";
import { TransferUtils } from "../libraries/TransferUtils.sol";
import { Auth, GlobalACL, SWAP_KEEPER, KEEPER_ROLE, REQUEST_HANDLER } from "../Auth.sol";
import { AssetVault } from "./AssetVault.sol";
import { AggregateVaultStorage } from "../storage/AggregateVaultStorage.sol";
import { PositionManagerRouter, WhitelistedTokenRegistry } from "../position-managers/PositionManagerRouter.sol";
import { Multicall } from "../libraries/Multicall.sol";
import { NettingMath } from "../libraries/NettingMath.sol";
import { HookType } from "../interfaces/IHookExecutor.sol";
import { Emitter } from "../peripheral/Emitter.sol";
import { Delegatecall } from "../libraries/Delegatecall.sol";
import { OracleWrapper } from "../peripheral/OracleWrapper.sol";
import { AggregateVaultHelper } from "../peripheral/AggregateVaultHelper.sol";
import { IAssetVault } from "../interfaces/IAssetVault.sol";
import { IVaultFees } from "../interfaces/IVaultFees.sol";
import { SafeTransferLib } from "solmate/utils/SafeTransferLib.sol";
import { IPositionManager } from "../interfaces/IPositionManager.sol";
import { Solarray } from "../libraries/Solarray.sol";

enum Peripheral {
    HookHandler,
    EventEmitter,
    OracleWrapper,
    GMI,
    AggregateVaultHelper,
    GmxV2Handler,
    FeeHelper,
    RequestHandler,
    UniswapV3SwapManager
}

using Delegatecall for address;
using SafeTransferLib for ERC20;

/// @title AggregateVault
/// @author Umami Devs
/// @notice Contains common logic for all asset vaults and core keeper interactions
contract AggregateVault is Multicall, AggregateVaultStorage, PositionManagerRouter, GlobalACL {
    // ERRORS
    // ------------------------------------------------------------------------------------------

    /// @dev address should not be zero
    error ZeroAddress();
    /// @dev gas is not above the min required for the keeper execution
    error MinGasRequirement();
    /// @dev amount should be greater than 0
    error AmountEqualsZero();
    /// @dev vault rebalance is open
    error RebalanceOpen();
    /// @dev vault rebealance is closed
    error RebalanceNotOpen();
    /// @dev netting check has failed for the parameters passed
    error FailedNettingCheck();
    /// @dev config validation failed on set
    error FailedConfigValidation();
    /// @dev delevate view did not revert
    error DelegateViewRevert();
    /// @dev oracle price length is not equal to config requirement
    error OraclePriceSizeInvalid();
    /// @dev caller is not the asset vault
    error NotAssetVault();
    /// @dev not RequestHandler or AssetVault
    error notRequestHandlerOrAssetVault();

    constructor(Auth _auth, WhitelistedTokenRegistry _whitelistedTokenRegistry)
        PositionManagerRouter(_whitelistedTokenRegistry)
        GlobalACL(_auth)
    { }

    // DEPOSIT & WITHDRAW
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Handles a deposit of a specified amount of an ERC20 asset into the AggregateVault from an account, with a deposit fee deducted.
     * @param assets The amount of the asset to be deposited.
     * @param account The address of the account from which the deposit will be made.
     */
    function handleDeposit(uint256 assets, uint256 minOutAfterFees, address account, address sender, address callback)
        external
        payable
        onlyAssetVault
    {
        if (assets == 0) revert AmountEqualsZero();
        if (account == address(0)) revert ZeroAddress();
        AVStorage storage stg = _getStorage();
        uint256 gas = _gasRequirement(callback != address(0));
        if (msg.value < gas * tx.gasprice) revert MinGasRequirement();

        // store request data
        uint256 key = _saveRequest(sender, account, msg.sender, callback, true, assets, minOutAfterFees);

        // send execution gas cost
        TransferUtils.transferNativeAsset(stg.rebalanceKeeper, msg.value);

        _executeHook(HookType.DEPOSIT_HOOK, msg.data[4:]);

        // emit request event
        Emitter(stg.emitter).emitDepositRequest(key, account, msg.sender);
    }

    /**
     * @notice Handles a withdrawal of a specified amount of an ERC20 asset from the AggregateVault to an account, with a withdrawal fee deducted.
     * @param shares The amount of the shares to be withdrawn.
     * @param account The address of the account to which the withdrawal will be made.
     */
    function handleWithdraw(uint256 shares, uint256 minOutAfterFees, address account, address sender, address callback)
        external
        payable
        onlyAssetVault
    {
        if (shares == 0) revert AmountEqualsZero();
        if (account == address(0)) revert ZeroAddress();
        AVStorage storage stg = _getStorage();
        uint256 gas = _gasRequirement(callback != address(0));
        if (msg.value < gas * tx.gasprice) revert MinGasRequirement();

        // store request data
        uint256 key = _saveRequest(sender, account, msg.sender, callback, false, shares, minOutAfterFees);

        // send execution gas cost
        TransferUtils.transferNativeAsset(stg.rebalanceKeeper, msg.value);

        _executeHook(HookType.WITHDRAW_HOOK, msg.data[4:]);

        // emit request event
        Emitter(stg.emitter).emitWithdrawalRequest(key, account, msg.sender);
    }

    /**
     * @notice clear a request from storage when a request is cancelled or fulfilled by handler
     */
    function clearRequest(uint256 key) external onlyRequestHandlerOrAssetVault returns (OCRequest memory order) {
        AVStorage storage stg = _getStorage();
        order = stg.pendingRequests[key];
        delete stg.pendingRequests[key];
    }

    /**
     * @notice releases funds for withdrawal to the user, can only be called by the request handler
     * @param underlyingToken the underlying vault token for the request
     * @param account the account the request was made for
     * @param assets the amounf of assets
     * @param totalWithdrawalFee size of the withdrawal fee calculated in request handler
     */
    function releaseWithdrawal(address underlyingToken, address account, uint256 assets, uint256 totalWithdrawalFee)
        external
        onlyRequestHandler
    {
        TransferUtils.transferAsset(underlyingToken, account, assets);
        address feeEscrow = _getVaultState().withdrawalFeeEscrow;
        if (totalWithdrawalFee > 0 && feeEscrow != address(0)) {
            TransferUtils.transferAsset(underlyingToken, feeEscrow, totalWithdrawalFee);
        }
    }

    /**
     * @notice Increments the epoch deposit/withdraw delta.
     */
    function incrementEpochDelta(address asset, int256 amount) external onlyRequestHandler {
        AssetVaultStorage storage vaultStg = _getVaultFromAsset(asset);
        vaultStg.epochDelta += amount;
    }

    // REBALANCE
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Executes a multicall in the context of the aggregate vault.
     * @param data the calls to be executed.
     * @return results the return values of each call.
     */
    function multicall(bytes[] calldata data)
        external
        payable
        onlyRole(KEEPER_ROLE)
        returns (bytes[] memory results, uint256[] memory gasEstimates)
    {
        (results, gasEstimates) = _multicall(data);
    }

    /**
     * @notice Opens the rebalance period and validates next rebalance state.
     * @param nextVaultIndexAlloc next vault GMI allocations in $
     * @param nextIndexComposition the composition of the GMI index
     * @param externalPosition the external position the vaults are taking on in $
     * @param priceData token price data.
     * @param _hook hook
     */
    function openRebalancePeriod(
        uint256[2] memory nextVaultIndexAlloc,
        uint256[2] memory nextIndexComposition,
        int256 externalPosition,
        SetPricesParams memory priceData,
        bytes memory _hook
    ) external onlyRole(KEEPER_ROLE) setOraclePricing(priceData) {
        // before rebalance hook
        _executeHook(HookType.OPEN_REBALANCE_HOOK, _hook);
        VaultState storage vaultState = _getVaultState();
        if (vaultState.rebalanceOpen) revert RebalanceOpen();

        // check netting constraint
        checkNettingConstraint(
            Solarray.arraySum(nextVaultIndexAlloc), nextVaultIndexAlloc, nextIndexComposition, externalPosition
        );

        // pause vault deposits
        pauseDeposits();

        // set rebalance storage
        RebalanceState storage rebalanceState = _getRebalanceState();
        rebalanceState.indexAllocation = nextVaultIndexAlloc;
        rebalanceState.indexComposition = nextIndexComposition;
        rebalanceState.externalPosition = externalPosition;
        rebalanceState.epoch = vaultState.epoch;

        // cache the rebalance PPS
        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();
        for (uint256 i = 0; i < 2; i++) {
            vaultState.rebalancePPS[i] = getVaultPPS(assetVaults[i].vault, false, true);
        }
        vaultState.rebalanceOpen = true;

        Emitter(_getEmitter()).emitOpenRebalance(
            block.timestamp, nextVaultIndexAlloc, nextIndexComposition, externalPosition
        );
    }

    /**
     * @notice Closes a rebalance period and validates current state is valid.
     */
    function closeRebalancePeriod(SetPricesParams memory priceData, bytes memory _hook)
        external
        onlyRole(KEEPER_ROLE)
        setOraclePricing(priceData)
    {
        VaultState storage vaultState = _getVaultState();
        if (!vaultState.rebalanceOpen) revert RebalanceNotOpen();
        RebalanceState storage rebalanceState = _getRebalanceState();

        address aggregateVaultHelper = _getStorage().aggregateVaultHelper;
        bytes memory gmiValue = aggregateVaultHelper.delegateCall(
            abi.encodeCall(AggregateVaultHelper.getVaultsGmiValue, (vaultState.epoch, true))
        );
        uint256[2] memory vaultIndexAllocation = abi.decode(gmiValue, (uint256[2]));

        // check netting constraint
        checkNettingConstraint(
            Solarray.arraySum(vaultIndexAllocation),
            rebalanceState.indexAllocation,
            rebalanceState.indexComposition,
            rebalanceState.externalPosition
        );

        // calculate the new netted positions
        (int256[2][2] memory nettedMatrix,) = NettingMath.calculateNettedPositions(
            rebalanceState.externalPosition, rebalanceState.indexComposition, vaultIndexAllocation
        );

        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();

        // collect fees
        if (vaultState.epoch > 0) _collectVaultRebalanceFees(assetVaults);

        // reset epoch delta
        _resetEpochDeltas();

        vaultState.rebalanceOpen = false;
        vaultState.indexAllocation = rebalanceState.indexAllocation;

        // set netted positions
        _setPositions(nettedMatrix, rebalanceState.externalPosition);

        // finalise tvl checkpoint
        _setCheckpointTvls(assetVaults);

        // note set last to not trigger internal pnl
        vaultState.epoch += 1;
        vaultState.lastRebalanceTime = block.timestamp;

        // after rebalance hook
        _executeHook(HookType.CLOSE_REBALANCE_HOOK, _hook);

        // unpause vaults
        unpauseDeposits();

        Emitter(_getEmitter()).emitCloseRebalance(block.timestamp);
    }

    /**
     * @notice Checks if the netting constraint is satisfied for the given input values.
     * @dev Reverts if the netting constraint is not satisfied.
     * @param vaultCumulativeHoldings The total dollars deposited in backing.
     * @param indexComposition composition of the backing index.
     * @param vaultHoldings amount held by each vault.
     * @param externalPosition the external position to hedge.
     */
    function checkNettingConstraint(
        uint256 vaultCumulativeHoldings,
        uint256[2] memory vaultHoldings,
        uint256[2] memory indexComposition,
        int256 externalPosition
    ) internal view {
        if (_getStorage().shouldCheckNetting) {
            if (
                !NettingMath.isNetted(
                    vaultCumulativeHoldings, indexComposition, vaultHoldings, externalPosition, _getNettedThreshold()
                )
            ) {
                revert FailedNettingCheck();
            }
        }
    }

    // VIEWS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice vault rebalance in progress
     */
    function rebalanceOpen() external view returns (bool) {
        return _getVaultState().rebalanceOpen;
    }

    /**
     * @notice preview a vault request
     * @param key The request key to query for
     * @return - The OCRequest corresponding to the key if set
     */
    function getRequest(uint256 key) external view returns (OCRequest memory) {
        return _getStorage().pendingRequests[key];
    }

    /**
     * @notice Gets the current asset vault price per share (PPS)
     * @param _assetVault The address of the asset vault whose PPS is being queried
     * @param useLlo should use the low latency oracle price
     * @return _tvl The current asset vault PPS
     */
    function getVaultPPS(address _assetVault, bool isDeposit, bool useLlo) public returns (uint256) {
        address aggregateVaultHelper = _getStorage().aggregateVaultHelper;
        bytes memory ret = aggregateVaultHelper.delegateCall(
            abi.encodeCall(AggregateVaultHelper.getVaultPPS, (_assetVault, isDeposit, useLlo))
        );
        return abi.decode(ret, (uint256));
    }

    /**
     * @notice Gets the current asset vault total value locked (TVL)
     * @param _assetVault The address of the asset vault whose TVL is being queried
     * @param useLlo should use the low latency oracle price
     * @return _tvl The current asset vault TVL
     */
    function getVaultTVL(address _assetVault, bool useLlo) public returns (uint256 _tvl) {
        address aggregateVaultHelper = _getStorage().aggregateVaultHelper;
        bytes memory ret =
            aggregateVaultHelper.delegateCall(abi.encodeCall(AggregateVaultHelper.getVaultTVL, (_assetVault, useLlo)));
        return abi.decode(ret, (uint256));
    }

    /**
     * @notice preview deposit fee
     * @param size The size of the deposit for which the fee is being calculated
     * @return totalDepositFee The calculated deposit fee
     */
    function previewDepositFee(address token, uint256 size, bool useLlo) external returns (uint256 totalDepositFee) {
        address feeHelper = _getFeeHelper();
        (bytes memory ret) = feeHelper.delegateCall(abi.encodeCall(IVaultFees.getDepositFee, (token, size, useLlo)));
        (totalDepositFee) = abi.decode(ret, (uint256));
    }

    /**
     * @notice preview withdrawal fee
     * @param token The address of the token for which the withdrawal fee is being calculated
     * @param size The size of the withdrawal for which the fee is being calculated
     * @return totalWithdrawalFee The calculated withdrawal fee
     */
    function previewWithdrawalFee(address token, uint256 size, bool useLlo)
        external
        returns (uint256 totalWithdrawalFee)
    {
        address feeHelper = _getFeeHelper();
        (bytes memory ret) = feeHelper.delegateCall(abi.encodeCall(IVaultFees.getWithdrawalFee, (token, size, useLlo)));
        (totalWithdrawalFee) = abi.decode(ret, (uint256));
    }

    /**
     * @notice Preview the asset vault cap
     * @param _asset The address of the asset whose vault cap is being queried
     * @return The current asset vault cap
     */
    function previewVaultCap(address _asset) external view returns (uint256) {
        uint256 vidx = _getTokenToAssetVaultIndex()[_asset];
        VaultState memory state = _getVaultState();
        return state.vaultCaps[vidx];
    }

    /**
     * @notice Preview the timelock address for an asset vault
     * @param _asset The address of the asset whose vault timelock is being queried
     * @return timelock address of the timelock contract
     */
    function getVaultTimelockAddress(address _asset) external view returns (address timelock) {
        AssetVaultStorage storage vaultStg = _getVaultFromAsset(_asset);
        return vaultStg.timelockYieldBoost;
    }

    /**
     * @dev reads storage slots in the contract returned as bytes32[] result
     */
    function readStorageSlots(bytes32[] calldata _slots) external view returns (bytes32[] memory _values) {
        _values = new bytes32[](_slots.length);
        for (uint256 i; i < _slots.length; i++) {
            uint256 value;
            bytes32 slot = _slots[i];
            assembly {
                value := sload(slot)
            }
            _values[i] = bytes32(value);
        }
    }

    /**
     * @notice Set the flag for checking netting constraints
     * @param _newVal The new boolean value for the flag
     */
    function setShouldCheckNetting(bool _newVal) external onlyConfigurator {
        AVStorage storage stg = _getStorage();
        stg.shouldCheckNetting = _newVal;
    }

    /**
     * @notice Set the flag for checking netting constraints
     * @param _newVal The new boolean value for the flag
     */
    function setShouldUseGmxFee(bool _newVal) external onlyConfigurator {
        AVStorage storage stg = _getStorage();
        stg.shouldUseGmxFee = _newVal;
    }

    /**
     * @notice Update asset vault receipt contracts
     * @param assetVaults An array of new asset vault entries
     */
    function setAssetVaults(AssetVaultStorage[2] calldata assetVaults) external onlyConfigurator {
        AssetVaultStorage[2] storage vaults = _getAssetVaultEntries();
        mapping(address => uint256) storage tokenToAssetVaultIndex = _getTokenToAssetVaultIndex();
        mapping(address => uint256) storage vaultToAssetVaultIndex = _getVaultToAssetVaultIndex();

        for (uint256 i = 0; i < 2; i++) {
            vaults[i] = assetVaults[i];
            tokenToAssetVaultIndex[assetVaults[i].token] = i;
            vaultToAssetVaultIndex[assetVaults[i].vault] = i;
        }
    }

    /**
     * @notice Sets the vault fees
     * @param _performanceFee The performance fee value to set
     * @param _managementFee The management fee value to set
     * @param _withdrawalFee The withdrawal fee value to set
     * @param _depositFee The deposit fee value to set
     */
    function setVaultFees(uint256 _performanceFee, uint256 _managementFee, uint256 _withdrawalFee, uint256 _depositFee)
        external
        onlyConfigurator
    {
        _getStorage().vaultFees = VaultFees({
            performanceFee: _performanceFee,
            managementFee: _managementFee,
            withdrawalFee: _withdrawalFee,
            depositFee: _depositFee
        });
    }

    /**
     * @notice Sets the timelock percentage reward
     * @param asset The asset for the vault to set the new percentage for
     * @param newTimelockFeePercent The new percentage reward for the timelock
     */
    function setVaultTimelockPercent(address asset, uint256 newTimelockFeePercent) external onlyConfigurator {
        if (newTimelockFeePercent >= 100 * 1e18) revert FailedConfigValidation();
        AssetVaultStorage storage vaultStg = _getVaultFromAsset(asset);
        vaultStg.timelockBoostPercent = newTimelockFeePercent;
    }

    // CONFIG
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Set the peripheral contract addresses
     * @param peripheral The enum value of the peripheral type
     * @param addr The address of the peripheral contract
     */
    function setPeripheral(Peripheral peripheral, address addr) external onlyConfigurator {
        if (addr == address(0)) revert ZeroAddress();
        AVStorage storage stg = _getStorage();
        if (peripheral == Peripheral.HookHandler) {
            stg.hookHandler = addr;
        } else if (peripheral == Peripheral.EventEmitter) {
            stg.emitter = addr;
        } else if (peripheral == Peripheral.OracleWrapper) {
            stg.oracleWrapper = addr;
        } else if (peripheral == Peripheral.GMI) {
            stg.gmi = payable(addr);
        } else if (peripheral == Peripheral.AggregateVaultHelper) {
            stg.aggregateVaultHelper = addr;
        } else if (peripheral == Peripheral.GmxV2Handler) {
            stg.gmxV2Handler = addr;
        } else if (peripheral == Peripheral.FeeHelper) {
            stg.feeHelper = addr;
        } else if (peripheral == Peripheral.RequestHandler) {
            stg.requestHandler = addr;
        } else if (peripheral == Peripheral.UniswapV3SwapManager) {
            stg.uniswapV3SwapManager = addr;
        } else {
            revert("AggregateVault: invalid peripheral");
        }
    }

    /**
     * @notice Set the netted threshold in bips for netting constraint
     * @param _newNettedThreshold The new netted threshold value
     */
    function setThresholds(uint256 _newNettedThreshold, uint256 _zeroSumPnlThreshold, uint256 _swapSlippage)
        external
        onlyConfigurator
    {
        if (
            _zeroSumPnlThreshold == 0 || _zeroSumPnlThreshold >= 1e18 || _newNettedThreshold == 0
                || _newNettedThreshold >= 10_000
        ) revert FailedConfigValidation();

        AVStorage storage stg = _getStorage();
        stg.zeroSumPnlThreshold = _zeroSumPnlThreshold;
        stg.nettedThreshold = _newNettedThreshold;
        stg.swapSlippage = _swapSlippage;
    }

    /**
     * @notice Set the block tolerance for accepting pricing from LLO
     * @param _newBlockTolerance The new block tolerance for pricing
     */
    function setL1BlockTolerance(uint8 _newBlockTolerance) external onlyConfigurator {
        _setL1BlockTolerance(_newBlockTolerance);
    }

    /**
     * @notice Sets the execution gas amounts required for deposits and withdrawals
     * @param executionGasAmount The gas amount required for regular deposits and withdrawals
     * @param executionGasAmountCallback The gas amount requried for callbvack deposits and withdrawals
     */
    function setExecutionGasAmounts(uint256 executionGasAmount, uint256 executionGasAmountCallback)
        external
        onlyConfigurator
    {
        AVStorage storage stg = _getStorage();
        stg.executionGasAmount = executionGasAmount;
        stg.executionGasAmountCallback = executionGasAmountCallback;
    }

    /**
     * @notice Sets the rebalance keeper for execution of deposits and withdrawals
     * @param newKeeper Address of the new exe ution keeper
     */
    function setRebalanceKeeper(address newKeeper) external onlyConfigurator {
        if (newKeeper == address(0)) revert ZeroAddress();
        _setRebalanceKeeper(newKeeper);
    }

    /**
     * @notice Add a new position manager to the list of position managers
     * @param _manager The address of the new position manager
     */
    function addPositionManager(IPositionManager _manager) external onlyConfigurator {
        IPositionManager[] storage positionManagers = _getPositionManagers();
        positionManagers.push(_manager);
    }

    /**
     * @notice Set vault caps for all asset vaults
     * @param _newCaps An array of new cap values for each asset vault
     */
    function setVaultCaps(uint256[2] memory _newCaps) external onlyConfigurator {
        VaultState storage state = _getVaultState();
        state.vaultCaps = _newCaps;
    }

    /**
     * @notice Set fee recipient and deposit fee escrow addresses
     * @param _recipient The address of the fee recipient
     * @param _depositFeeEscrow The address of the deposit fee escrow
     */
    function setFeeRecipient(address _recipient, address _depositFeeEscrow, address _withdrawalFeeEscrow)
        external
        onlyConfigurator
    {
        if (_recipient == address(0) || _depositFeeEscrow == address(0) || _withdrawalFeeEscrow == address(0)) {
            revert ZeroAddress();
        }

        VaultState storage state = _getVaultState();
        state.feeRecipient = _recipient;
        state.depositFeeEscrow = _depositFeeEscrow;
        state.withdrawalFeeEscrow = _withdrawalFeeEscrow;
    }

    // DELEGATE VIEWS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Executes a delegate view to the specified target with the provided data and decodes the response as bytes.
     */
    function delegateview(address _target, bytes calldata _data) external returns (bool _success, bytes memory _ret) {
        (bool success, bytes memory ret) = address(this).call(abi.encodeCall(this.delegateviewRevert, (_target, _data)));
        if (success) revert DelegateViewRevert();
        (_success, _ret) = abi.decode(ret, (bool, bytes));
    }

    /**
     * @notice Executes a delegate call to the specified target with the provided data and reverts on error.
     */
    function delegateviewRevert(address _target, bytes memory _data) external {
        (bool success, bytes memory ret) = _target.delegatecall(_data);
        bytes memory encoded = abi.encode(success, ret);
        /// @solidity memory-safe-assembly
        assembly {
            revert(add(encoded, 0x20), mload(encoded))
        }
    }

    // INTERNAL
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Collects vault rebalance fees, mints timelock shares and distributes them.
     */
    function _collectVaultRebalanceFees(AssetVaultStorage[2] memory assetVaults) internal {
        uint256 performanceFeeInAsset;
        uint256 managementFeeInAsset;
        uint256 timelockYieldMintAmount;
        uint256 totalVaultFee;
        address feeHelper = _getFeeHelper();
        VaultState storage vaultState = _getVaultState();
        for (uint256 i = 0; i < 2; i++) {
            (bytes memory ret) = feeHelper.delegateCall(
                abi.encodeCall(IVaultFees.getVaultRebalanceFees, (assetVaults[i].token, vaultState.lastRebalanceTime))
            );
            (performanceFeeInAsset, managementFeeInAsset, timelockYieldMintAmount, totalVaultFee) =
                abi.decode(ret, (uint256, uint256, uint256, uint256));

            if (totalVaultFee > 0) {
                TransferUtils.transferAsset(assetVaults[i].token, vaultState.feeRecipient, totalVaultFee);
            }
            if (timelockYieldMintAmount > 0 && assetVaults[i].timelockYieldBoost != address(0)) {
                AssetVault(assetVaults[i].vault).mintTo(timelockYieldMintAmount, assetVaults[i].timelockYieldBoost);
            }

            Emitter(_getEmitter()).emitCollectVaultFees(
                totalVaultFee,
                performanceFeeInAsset,
                managementFeeInAsset,
                timelockYieldMintAmount,
                assetVaults[i].vault
            );
        }
    }

    /**
     * @notice Resets the epoch deposit/withdraw delta for all asset vaults.
     */
    function _resetEpochDeltas() internal {
        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();
        assetVaults[0].epochDelta = int256(0);
        assetVaults[1].epochDelta = int256(0);
    }

    /**
     * @notice Sets the checkpoint TVL for all asset vaults.
     */
    function _setCheckpointTvls(AssetVaultStorage[2] storage assetVaults) internal {
        assetVaults[0].lastCheckpointTvl = getVaultTVL(assetVaults[0].vault, true);
        assetVaults[1].lastCheckpointTvl = getVaultTVL(assetVaults[1].vault, true);
    }

    // UTILS
    // ------------------------------------------------------------------------------------------

    function depositEth() external payable onlyRole(KEEPER_ROLE) { }

    function withdrawEth(uint256 amount) external payable onlyRole(KEEPER_ROLE) {
        TransferUtils.transferNativeAsset(msg.sender, amount);
    }

    /**
     * @notice Pause deposits and withdrawals for the asset vaults
     */
    function pauseDeposits() public onlyRole(KEEPER_ROLE) {
        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();
        for (uint256 i = 0; i < 2; i++) {
            IAssetVault(assetVaults[i].vault).pauseDepositWithdraw();
        }
    }

    /**
     * @notice Unpause deposits and withdrawals for the asset vaults
     */
    function unpauseDeposits() public onlyRole(KEEPER_ROLE) {
        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();
        for (uint256 i = 0; i < 2; i++) {
            IAssetVault(assetVaults[i].vault).unpauseDepositWithdraw();
        }
    }

    /**
     * @notice Sets the oracle ricing
     */
    modifier setOraclePricing(SetPricesParams memory prices) {
        if (prices.realtimeFeedTokens.length != prices.realtimeFeedData.length) revert OraclePriceSizeInvalid();
        for (uint256 i = 0; i < prices.realtimeFeedTokens.length; i++) {
            OracleWrapper(_getOracleWrapper()).setAndGetLloPrice(
                prices.realtimeFeedTokens[i], prices.realtimeFeedData[i]
            );
        }
        _;
    }

    /**
     * @notice Ensures the caller is an asset vault.
     */
    modifier onlyAssetVault() {
        if (!_isAssetVault()) revert NotAssetVault();
        _;
    }

    /**
     * @notice Ensures the caller is the RequestHandler or the AssetVault.
     */
    modifier onlyRequestHandlerOrAssetVault() {
        if (!(_isAssetVault() || AUTH.hasRole(REQUEST_HANDLER, msg.sender))) revert notRequestHandlerOrAssetVault();
        _;
    }

    /**
     * @notice check if the sender is an assetVault
     */
    function _isAssetVault() internal view returns (bool) {
        AssetVaultStorage[2] storage assetVaults = _getAssetVaultEntries();
        for (uint256 i = 0; i < 2; ++i) {
            if (msg.sender == assetVaults[i].vault) {
                return true;
            }
        }
        return false;
    }

    /**
     * @dev returns the gas requirement for call execution.
     */
    function _gasRequirement(bool _callback) internal view returns (uint256) {
        return _callback ? _getStorage().executionGasAmountCallback : _getStorage().executionGasAmount;
    }

    /// @dev To be implemented by inheriting contracts to restrict certain functions to a configurator role.
    function _onlyConfigurator() internal override onlyConfigurator { }

    /// @dev To be implemented by inheriting contracts to validate the caller's authorization for execute calls.
    function _validateExecuteCallAuth() internal override onlyRole(KEEPER_ROLE) { }

    /**
     * @notice Ensures the caller is permissioned to swap.
     */
    function _onlySwapIssuer() internal override onlyRole(SWAP_KEEPER) { }
}

pragma solidity 0.8.17;

import { AggregateVaultStorage } from "../storage/AggregateVaultStorage.sol";
import { BaseHandler } from "../BaseHandler.sol";
import { GMI } from "../index/GMI.sol";
import { Pricing } from "../libraries/Pricing.sol";
import { LibAggregateVaultUtils } from "../libraries/LibAggregateVaultUtils.sol";
import { TOKEN_USDC_NATIVE, TOKEN_WETH } from "../constants.sol";
import { ERC20 } from "solmate/tokens/ERC20.sol";
import { OracleWrapper } from "../peripheral/OracleWrapper.sol";
import { IPositionManager } from "../interfaces/IPositionManager.sol";
import { PriceCast } from "../libraries/PriceCast.sol";
import { SafeCast } from "../libraries/SafeCast.sol";
import { NettedPositionTracker } from "../libraries/NettedPositionTracker.sol";
import { Delegatecall } from "../libraries/Delegatecall.sol";
import { Solarray } from "../libraries/Solarray.sol";
import { GmxStorage } from "../libraries/GmxStorage.sol";
import { SafeTransferLib } from "solmate/utils/SafeTransferLib.sol";
import { ISwapManager } from "../interfaces/ISwapManager.sol";
import { LibCycle } from "../libraries/LibCycle.sol";
import { GlobalACL, Auth } from "../Auth.sol";

using SafeCast for uint256;
using SafeCast for int256;
using PriceCast for uint256;
using Delegatecall for address;
using Solarray for uint256[2];
using SafeTransferLib for ERC20;

/// @title AggregateVaultViews
/// @author Umami Devs
/// @notice A contract providing view functions for AggregateVaultStorage data.
contract AggregateVaultViews is AggregateVaultStorage {
    /// @notice Returns the array of AssetVaultEntry structs.
    function getAssetVaultEntries() public view returns (AssetVaultStorage[2] memory _assetVaultEntry) {
        _assetVaultEntry = _getStorage().vaults;
    }

    /// @notice Returns the index of a token in the asset vault array.
    /// @param _token The address of the token.
    function tokenToAssetVaultIndex(address _token) public view returns (uint256 _idx) {
        _idx = _getTokenToAssetVaultIndex()[_token];
    }

    /// @notice Returns the index of a vault in the asset vault array.
    /// @param _vault The address of the vault.
    function vaultToAssetVaultIndex(address _vault) public view returns (uint256 _idx) {
        _idx = _getVaultToAssetVaultIndex()[_vault];
    }

    /// @notice Returns the current vault state.
    function getVaultState() public view returns (VaultState memory _vaultState) {
        _vaultState = _getVaultState();
    }

    /// @notice Returns the current rebalance state.
    function getRebalanceState() public view returns (RebalanceState memory _rebalanceState) {
        _rebalanceState = _getRebalanceState();
    }

    /// @notice Returns the current GMI attribution for each asset vault.
    function getVaultGmiAttribution() public view returns (uint256[2] memory _gmiAttribution) {
        _gmiAttribution = _getStorage().vaultGmiAttribution;
    }

    /// @notice Returns the last netted price for a given epoch.
    /// @param _epoch The epoch for which to retrieve the netted price.
    function getLastNettedPrice(uint256 _epoch) public view returns (int256[2] memory _nettedPrices) {
        _nettedPrices = _getNettedPrices(_epoch);
    }

    /// @notice Returns the array of position managers.
    function getPositionManagers() public view returns (IPositionManager[] memory _positionManagers) {
        _positionManagers = _getPositionManagers();
    }

    /// @notice Returns the array of netted positions.
    function getNettedPositions() public view returns (int256[2][2] memory _nettedPositions) {
        _nettedPositions = _getStorage().nettedPositions;
    }

    /// @notice Returns the array of active external positions.
    function getActiveExternalPosition() public view returns (int256 _activeExternalPosition) {
        _activeExternalPosition = _getStorage().externalPosition;
    }
}

/// @title AggregateVaultHelper
/// @author Umami Devs
/// @notice A contract that constains extended logic of the AggregateVault. Common storage layout is used with delegate calls.
contract AggregateVaultHelper is AggregateVaultStorage, AggregateVaultViews, BaseHandler, GlobalACL {
    constructor(Auth _auth) GlobalACL(_auth) { }

    /**
     * @notice Gets the current asset vault price per share (PPS)
     * @param _vault The address of the asset vault
     * @param isDeposit if the pricing is for a deposit or withdrawal
     * @param useLlo should use the LLO price
     * @return - The price per share of the asset vault
     */
    function getVaultPPS(address _vault, bool isDeposit, bool useLlo) external onlyDelegateCall returns (uint256) {
        VaultState memory vaultState = _getVaultState();
        uint256 index = vaultToAssetVaultIndex(_vault);
        if (vaultState.rebalanceOpen) return vaultState.rebalancePPS[index];

        AssetVaultStorage storage vault = _getStorage().vaults[index];
        uint256 vaultSupply = ERC20(vault.vault).totalSupply();
        uint256 decimals = _vaultDecimals(index);
        uint256 oneToken = 10 ** decimals;

        if (vaultSupply == 0) return oneToken;

        uint256 nativeTokenBalance = ERC20(vault.token).balanceOf(address(this));
        uint256 gmiUsd = useLlo ? _vaultGmiBalanceUsd(index) : _vaultGmiBalanceUsdChainlink(index); // 18 decimal

        uint256 vaultTokenPrice = useLlo ? _vaultTokenPrice(index) : _vaultTokenPriceChainlink(index);
        uint256 gmiToVaultToken = gmiUsd * 1e12 / vaultTokenPrice;

        uint256 positionMargin =
            _getAssetVaultHedgesInNativeToken(index, vaultTokenPrice.toInternalPrice(decimals), decimals);

        uint256 totalBalance = nativeTokenBalance + gmiToVaultToken + positionMargin;
        return isDeposit
            ? (totalBalance * oneToken + vaultSupply - 1) / vaultSupply
            : totalBalance * oneToken / vaultSupply;
    }

    /**
     * @notice Gets the current asset vault Total Value Locked (TVL)
     * @dev TVL of the vaults may not equal PPS * totalSupply due to precision loss
     * @param _vault The address of the asset vault
     * @param useLlo should use the LLO price
     * @return - The total value locked in the asset vault
     */
    function getVaultTVL(address _vault, bool useLlo) external onlyDelegateCall returns (uint256) {
        uint256 index = vaultToAssetVaultIndex(_vault);
        uint256 decimals = _vaultDecimals(index);
        if (_getStorage().vaultState.rebalanceOpen) {
            uint256 totalSupply = ERC20(_vault).totalSupply();
            return _getStorage().vaultState.rebalancePPS[index] * totalSupply / 10 ** decimals;
        }

        AssetVaultStorage storage vault = _getStorage().vaults[index];
        uint256 gmiUsd = useLlo ? _vaultGmiBalanceUsd(index) : _vaultGmiBalanceUsdChainlink(index); // 18 decimals

        uint256 vaultTokenPrice = useLlo ? _vaultTokenPrice(index) : _vaultTokenPriceChainlink(index);

        uint256 positionMargin =
            _getAssetVaultHedgesInNativeToken(index, vaultTokenPrice.toInternalPrice(decimals), decimals);

        uint256 gmiToVaultToken = gmiUsd * 1e12 / vaultTokenPrice;
        uint256 nativeTokenBalance = ERC20(vault.token).balanceOf(address(this));
        return nativeTokenBalance + gmiToVaultToken + positionMargin;
    }

    /**
     * @notice Gets the current asset vault price per share (PPS). This function can be used to
     * get the PPS according to an off chain price set.
     * @param _vault The address of the asset vault
     * @param isDeposit if the pricing is for a deposit or withdrawal
     * @param prices The prices of the markets in GMI. This array is ordered in the same sequence
     * as the GMI index assets. To get the ordering of prices call GMI.indexAssets()
     * @param max Should the max or min price be used.
     * @return - The price per share of the asset vault
     */
    function getVaultPPSWithPrices(address _vault, bool isDeposit, GmxStorage.MarketPrices[] memory prices, bool max)
        external
        onlyDelegateCall
        returns (uint256)
    {
        uint256 index = vaultToAssetVaultIndex(_vault);
        AssetVaultStorage storage vault = _getStorage().vaults[index];
        uint256 vaultSupply = ERC20(vault.vault).totalSupply();
        uint256 decimals = _vaultDecimals(index);
        uint256 oneToken = 10 ** decimals;
        if (vaultSupply == 0) return oneToken;
        uint256 gmiUsd;
        uint256 vaultTokenPrice;
        {
            uint256 ethPrice = max ? prices[0].longTokenPrice.max : prices[0].longTokenPrice.min;
            uint256 usdcPrice = max ? prices[0].shortTokenPrice.max : prices[0].shortTokenPrice.min;
            uint256 gmiPPS = GMI(_getStorage().gmi).pps(prices);
            uint256 gmiBalance = LibAggregateVaultUtils.getVaultGmiWithPrices(
                index,
                _getVaultState().epoch,
                gmiPPS,
                Solarray.int256s(usdcPrice.toInternalPrice(6).toInt256(), ethPrice.toInternalPrice(18).toInt256())
            );
            gmiUsd = gmiPPS * gmiBalance / 1e18;
            vaultTokenPrice = vault.token == TOKEN_USDC_NATIVE ? usdcPrice : ethPrice;
        }
        uint256 gmiToVaultToken = gmiUsd * 1e12 / vaultTokenPrice;
        uint256 positionMargin =
            _getAssetVaultHedgesInNativeToken(index, vaultTokenPrice.toInternalPrice(decimals), decimals);
        uint256 totalBalance = ERC20(vault.token).balanceOf(address(this)) + gmiToVaultToken + positionMargin;
        return isDeposit
            ? (totalBalance * oneToken + vaultSupply - 1) / vaultSupply
            : totalBalance * oneToken / vaultSupply;
    }

    /**
     * @notice Gets the current asset vault Total Value Locked (TVL). This function can be used to
     * get the TVL according to an off chain price set.
     * @dev TVL of the vaults may not equal PPS * totalSupply due to precision loss.
     * @param _vault The address of the asset vault
     * @param prices The prices of the markets in GMI. This array is ordered in the same sequence
     * as the GMI index assets. To get the ordering of prices call GMI.indexAssets()
     * @param max Should the max or min price be used.
     * @return - The total value locked in the asset vault
     */
    function getVaultTVLWithPrices(address _vault, GmxStorage.MarketPrices[] memory prices, bool max)
        external
        onlyDelegateCall
        returns (uint256)
    {
        uint256 index = vaultToAssetVaultIndex(_vault);
        uint256 decimals = _vaultDecimals(index);
        AssetVaultStorage storage vault = _getStorage().vaults[index];
        uint256 ethPrice = max ? prices[0].longTokenPrice.max : prices[0].longTokenPrice.min;
        uint256 usdcPrice = max ? prices[0].shortTokenPrice.max : prices[0].shortTokenPrice.min;
        uint256 gmiPPS = GMI(_getStorage().gmi).pps(prices);
        uint256 gmiBalance = LibAggregateVaultUtils.getVaultGmiWithPrices(
            index,
            _getVaultState().epoch,
            gmiPPS,
            Solarray.int256s(usdcPrice.toInternalPrice(6).toInt256(), ethPrice.toInternalPrice(18).toInt256())
        );
        uint256 gmiUsd = gmiPPS * gmiBalance / 1e18;
        uint256 vaultTokenPrice = vault.token == TOKEN_USDC_NATIVE ? usdcPrice : ethPrice;
        uint256 positionMargin =
            _getAssetVaultHedgesInNativeToken(index, vaultTokenPrice.toInternalPrice(decimals), decimals);

        uint256 gmiToVaultToken = gmiUsd * 1e12 / vaultTokenPrice;
        uint256 nativeTokenBalance = ERC20(vault.token).balanceOf(address(this));
        return nativeTokenBalance + gmiToVaultToken + positionMargin;
    }

    /**
     * @notice Gets the current GMI for all vaults
     * @return gmiAmounts An array containing the GMI for each vault
     */
    function getVaultGmi(uint256 currentEpoch, bool useLlo) public view returns (uint256[2] memory gmiAmounts) {
        return _getVaultsGmi(currentEpoch, useLlo);
    }

    /**
     * @notice Gets the current GMI in $ with 1e18 decimals for all vaults
     * @return - An array containing the GMI dollars for each vault
     */
    function getVaultsGmiValue(uint256 currentEpoch, bool useLlo)
        external
        view
        onlyDelegateCall
        returns (uint256[2] memory)
    {
        return _getVaultsGmiInUsd(currentEpoch, useLlo);
    }

    /**
     * @notice Gets the current GMI in $ with 1e18 decimals for all vaults using an off chain price
     * @param prices The prices of the markets in GMI. This array is ordered in the same sequence
     * as the GMI index assets. To get the ordering of prices call GMI.indexAssets()
     * @param max Should the max or min price be used.
     * @return gmiUsdAmounts An array containing the GMI dollars for each vault
     */
    function getVaultsGmiValueWithPrices(GmxStorage.MarketPrices[] memory prices, bool max)
        external
        view
        onlyDelegateCall
        returns (uint256[2] memory gmiUsdAmounts)
    {
        uint256 currentEpoch = _getVaultState().epoch;
        uint256 ethPrice = max ? prices[0].longTokenPrice.max : prices[0].longTokenPrice.min;
        uint256 usdcPrice = max ? prices[0].shortTokenPrice.max : prices[0].shortTokenPrice.min;
        uint256 gmiPPS = GMI(_getStorage().gmi).pps(prices);
        gmiUsdAmounts = [
            LibAggregateVaultUtils.getVaultGmiWithPrices(
                0,
                currentEpoch,
                gmiPPS,
                Solarray.int256s(usdcPrice.toInternalPrice(6).toInt256(), ethPrice.toInternalPrice(18).toInt256())
            ),
            LibAggregateVaultUtils.getVaultGmiWithPrices(
                1,
                currentEpoch,
                gmiPPS,
                Solarray.int256s(usdcPrice.toInternalPrice(6).toInt256(), ethPrice.toInternalPrice(18).toInt256())
            )
        ];
        gmiUsdAmounts[0] = gmiUsdAmounts[0] * gmiPPS / 1e18;
        gmiUsdAmounts[1] = gmiUsdAmounts[1] * gmiPPS / 1e18;
    }

    // CYCLE
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Cycles the vaults, this settles internal position pnl,
     * and rebalances GMI held by each vault to the target amounts set in `openRebalancePeriod(...)`
     * @param shouldRebalanceGmi Whether the GMI amounts should be rebalanced this cycle. Flag set in keeper
     */
    function cycle(bool shouldRebalanceGmi)
        external
        onlyDelegateCall
        returns (LibCycle.GMIMintRequest[2] memory, LibCycle.GMIBurnRequest[2] memory)
    {
        require(getVaultState().rebalanceOpen, "!rebalanceOpen");
        return LibCycle.cycle(shouldRebalanceGmi);
    }

    /**
     * @notice Fulfills the requests made in `cycle(...)`. This is called after the GMX keeper has executed requests
     */
    function fulfilRequests() external onlyDelegateCall {
        require(getVaultState().rebalanceOpen, "!rebalanceOpen");
        LibCycle.fulfilRequests();
    }

    /// @dev for recovering from a failed cycle
    function rebalanceGmi(uint256[2] memory _previous, uint256[2] memory _new)
        external
        onlyDelegateCall
        returns (LibCycle.GMIMintRequest[2] memory _mintRequests, LibCycle.GMIBurnRequest[2] memory _burnRequests)
    {
        uint256 gmiPrice = Pricing.getIndexPps(_getStorage().oracleWrapper, GMI(_getStorage().gmi));
        (_mintRequests, _burnRequests) = LibCycle.rebalanceGmi(_previous, _new, gmiPrice);
    }

    /// @notice for setting the netted positions via config to recover
    function setNettedPositions(int256[2][2] memory nettedPositions, int256 externalPosition)
        public
        onlyDelegateCall
        onlyConfigurator
    {
        _setPositions(nettedPositions, externalPosition);
    }

    /// @notice for setting the Gmi Attribution via config to recover
    function setVaultGmiAttribution(uint256[2] memory _gmiAttribution) external onlyDelegateCall onlyConfigurator {
        _getStorage().vaultGmiAttribution = _gmiAttribution;
    }

    /// @notice for setting the last netted prices via config to recover
    function setLastNettedPrices(uint256 epoch, int256[2] memory _nettedPrices)
        external
        onlyDelegateCall
        onlyConfigurator
    {
        _getStorage().lastNettedPrices[epoch] = _nettedPrices;
    }

    /// @notice for setting the epoch via config to recover
    function setEpoch(uint256 epoch) external onlyDelegateCall onlyConfigurator {
        _getStorage().vaultState.epoch = epoch;
    }

    /// @notice to clear stale requests
    function clearMintBurnRequests(uint256 start, uint256 end) external onlyDelegateCall onlyConfigurator {
        for (uint256 i = start; i <= end; i++) {
            LibCycle.clearMintBurnRequestForEpoch(i);
        }
    }

    /// @notice set slippage tolerance for swaps
    function setSwapSlippageTolerance(uint256 _slippage) external onlyDelegateCall onlyConfigurator {
        _getStorage().swapSlippage = _slippage;
    }

    // INTERNAL GETTERS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Gets the breakdown of the asset vault TVL
     * @param _assetVault The address of the asset vault
     * @param _useLlo Should use chainlink llo.
     * @return _total The total TVL in the asset vault
     * @return _buffer The buffer portion of the TVL
     * @return _gmi The GMI portion of the TVL
     * @return _hedges The hedge portion of the TVL
     */
    function getVaultTVLBreakdown(address _assetVault, bool _useLlo)
        public
        onlyDelegateCall
        returns (uint256 _total, uint256 _buffer, uint256 _gmi, uint256 _hedges)
    {
        (_total, _buffer, _gmi, _hedges) =
            _getAssetVaultTvl(_getAssetVaultEntry(vaultToAssetVaultIndex(_assetVault)), _useLlo);
    }

    // INTERNAL GETTERS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Get the total value locked (TVL) for a specific AssetVaultEntry.
     * @param _assetVault The AssetVaultEntry to get the TVL for.
     * @param _useLlo Should use chainlink llo.
     * @return _totalTvl The total TVL for the AssetVaultEntry.
     * @return _bufferTvl The TVL held in the buffer for the AssetVaultEntry.
     * @return _gmiTvl The TVL held in the glp for the AssetVaultEntry.
     * @return _hedgesTvl The TVL held in hedges for the AssetVaultEntry.
     */
    function _getAssetVaultTvl(AssetVaultStorage storage _assetVault, bool _useLlo)
        internal
        returns (uint256 _totalTvl, uint256 _bufferTvl, uint256 _gmiTvl, uint256 _hedgesTvl)
    {
        uint256 index = vaultToAssetVaultIndex(_assetVault.vault);
        _bufferTvl = ERC20(_assetVault.token).balanceOf(address(this));
        uint256 vaultTokenPrice = _useLlo ? _vaultTokenPrice(index) : _vaultTokenPriceChainlink(index);
        uint256 decimals = _vaultDecimals(index);
        _gmiTvl = _useLlo ? _vaultGmiBalanceUsd(index) : _vaultGmiBalanceUsdChainlink(index); // 18 decimals
        _gmiTvl = _gmiTvl * 1e12 / vaultTokenPrice;

        _hedgesTvl = _getAssetVaultHedgesInNativeToken(index, vaultTokenPrice.toInternalPrice(decimals), decimals);
        _totalTvl = _bufferTvl + _gmiTvl + _hedgesTvl;
    }

    /**
     * @notice Get the hedges value in native token for a specific vault index.
     * @param _vaultIdx The index of the vault to get the hedges value for.
     * @return _hedgesToken The hedges value in native token for the specified vault index.
     */
    function _getAssetVaultHedgesInNativeToken(uint256 _vaultIdx, uint256 tokenPrice, uint256 tokenDecimals)
        internal
        returns (uint256 _hedgesToken)
    {
        uint256 hedgesUsd = _getAssetVaultHedgeInUsd(_vaultIdx);
        _hedgesToken = (hedgesUsd * (10 ** tokenDecimals)) / tokenPrice;
    }

    /**
     * @notice Get the hedges value in USD for a specific vault index.
     * @param _vaultIdx The index of the vault to get the hedges value for.
     * @return _hedgesUsd The hedges value in USD for the specified vault index.
     */
    function _getAssetVaultHedgeInUsd(uint256 _vaultIdx) internal returns (uint256 _hedgesUsd) {
        AVStorage storage stg = _getStorage();
        uint256 positionMargin;

        /// @dev here we assume all margin belongs to one vault
        if (stg.externalPosition > 0 && _vaultIdx == 0) {
            (positionMargin,) = _getTotalMargin(TOKEN_WETH);
            return positionMargin * 1e18 / 1e30;
        } else if (stg.externalPosition < 0 && _vaultIdx == 1) {
            (positionMargin,) = _getTotalMargin(TOKEN_WETH);
            return positionMargin * 1e18 / 1e30;
        } else {
            return 0;
        }
    }

    /**
     * @notice Get the total margin value for a specific token.
     * @param _token The address of the token to get the total margin value for.
     * @return _totalMargin The total margin value for the specified token.
     */
    function _getTotalMargin(address _token) internal returns (uint256 _totalMargin, bool _isLong) {
        IPositionManager[] storage positionManagers = _getPositionManagers();
        uint256 length = positionManagers.length;

        bool unset = true;
        _isLong = false;

        for (uint256 i = 0; i < length; ++i) {
            bytes memory ret =
                address(positionManagers[i]).delegateCall(abi.encodeWithSignature("positionMargin(address)", _token));
            (uint256 margin, bool isLong_) = abi.decode(ret, (uint256, bool));
            if (margin > 0) {
                if (unset) {
                    _isLong = isLong_;
                    unset = false;
                } else {
                    require(_isLong == isLong_, "AggregateVaultHelper: mixed long/short");
                }
            }
            _totalMargin += margin;
        }
    }

    /**
     * @notice Get the total notional value for a specific token.
     * @param _token The address of the token to get the total notional value for.
     * @return _totalNotional The total notional value for the specified token.
     */
    function getTotalNotional(address _token) public returns (uint256 _totalNotional, bool _isLong) {
        IPositionManager[] storage positionManagers = _getPositionManagers();
        uint256 length = positionManagers.length;

        bool unset = true;
        _isLong = false;

        for (uint256 i = 0; i < length; ++i) {
            bytes memory ret =
                address(positionManagers[i]).delegateCall(abi.encodeWithSignature("positionNotional(address)", _token));
            (uint256 notional, bool isLong_) = abi.decode(ret, (uint256, bool));
            if (notional > 0) {
                if (unset) {
                    _isLong = isLong_;
                    unset = false;
                } else {
                    require(_isLong == isLong_, "AggregateVaultHelper: mixed long/short");
                }
            }

            _totalNotional += notional;
        }
    }

    /// @dev calls the library logic to get the gmi in dollars held by vaults, uses the LLO
    function _vaultGmiBalanceUsd(uint256 _idx) internal view returns (uint256) {
        uint256 pps = Pricing.getIndexPps(_getStorage().oracleWrapper, GMI(_getStorage().gmi));
        uint256 gmiBalance = LibAggregateVaultUtils.getVaultGmi(_idx, _getVaultState().epoch, true);
        return pps * gmiBalance / 1e18;
    }

    /// @dev calls the library logic to get the gmi in dollars held by vaults, uses the onchain prices
    function _vaultGmiBalanceUsdChainlink(uint256 _idx) internal view returns (uint256) {
        uint256 pps = Pricing.getIndexPpsChainlink(_getStorage().oracleWrapper, GMI(_getStorage().gmi));
        uint256 gmiBalance = LibAggregateVaultUtils.getVaultGmi(_idx, _getVaultState().epoch, false);
        return pps * gmiBalance / 1e18;
    }

    /**
     * @notice Calculates the GMI amount owned by a vault in USD at a given epoch.
     * @param currentEpoch The epoch number.
     * @param useLlo Should use chainlink llo.
     * @return gmiUsdAmounts The amount of GMI in usd owned by the vault.
     */
    function _getVaultsGmiInUsd(uint256 currentEpoch, bool useLlo)
        internal
        view
        returns (uint256[2] memory gmiUsdAmounts)
    {
        gmiUsdAmounts = [
            LibAggregateVaultUtils.getVaultGmi(0, currentEpoch, useLlo),
            LibAggregateVaultUtils.getVaultGmi(1, currentEpoch, useLlo)
        ];
        uint256 pps = useLlo
            ? Pricing.getIndexPps(_getStorage().oracleWrapper, GMI(_getStorage().gmi))
            : Pricing.getIndexPpsChainlink(_getStorage().oracleWrapper, GMI(_getStorage().gmi));
        gmiUsdAmounts[0] = gmiUsdAmounts[0] * pps / 1e18;
        gmiUsdAmounts[1] = gmiUsdAmounts[1] * pps / 1e18;
    }

    /**
     * @notice Calculates the GMI amount owned by a vault at a given epoch.
     * @param currentEpoch The epoch number.
     * @param useLlo Should use chainlink llo.
     * @return gmiAmounts The amount of GLP owned by the vault.
     */
    function _getVaultsGmi(uint256 currentEpoch, bool useLlo) internal view returns (uint256[2] memory gmiAmounts) {
        return LibAggregateVaultUtils.getVaultsGmi(currentEpoch, useLlo);
    }

    /// @notice gets the vault token price from the vault index
    function _vaultTokenPrice(uint256 _idx) internal view returns (uint256) {
        address token = _getStorage().vaults[_idx].token;
        address oracle = _getStorage().oracleWrapper;

        if (token == TOKEN_USDC_NATIVE) {
            return OracleWrapper(oracle).getChainlinkPrice(token);
        } else {
            return OracleWrapper(oracle).getLloPriceWithinL1Blocks(token);
        }
    }

    /// @notice gets the vault token price from the vault index, using the onchain price
    function _vaultTokenPriceChainlink(uint256 _idx) internal view returns (uint256) {
        address token = _getStorage().vaults[_idx].token;
        address oracle = _getStorage().oracleWrapper;
        return OracleWrapper(oracle).getChainlinkPrice(token);
    }

    /// @notice gets the vault token decimals
    function _vaultDecimals(uint256 _idx) internal view returns (uint256) {
        address token = _getStorage().vaults[_idx].token;
        return token == TOKEN_USDC_NATIVE ? 6 : 18;
    }

    /// @dev for callbacks
    function callbackSigs() external pure returns (bytes4[] memory) {
        bytes4[] memory sigs = new bytes4[](0);
        return sigs;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import { Delegatecall } from "../libraries/Delegatecall.sol";
import { IHookExecutor, HookType } from "../interfaces/IHookExecutor.sol";
import { IPositionManager } from "../interfaces/IPositionManager.sol";
import { IArbSys } from "../interfaces/IArbSys.sol";
import { ARBSYS } from "../constants.sol";

bytes32 constant STORAGE_SLOT = keccak256("AggregateVault.storage");

/// @title LibAggregateVaultStorage
/// @author Umami Devs
/// @notice Library for some storage logic
library LibAggregateVaultStorage {
    function getStorage() internal pure returns (AggregateVaultStorage.AVStorage storage _storage) {
        bytes32 slot = STORAGE_SLOT;

        assembly {
            _storage.slot := slot
        }
    }

    function getTokenToAssetVaultIndex()
        internal
        view
        returns (mapping(address => uint256) storage _tokenToAssetVaultIndex)
    {
        _tokenToAssetVaultIndex = getStorage().tokenToAssetVaultIndex;
    }

    /**
     * @dev Retrieves the vault state from storage.
     * @return _vaultState The current vault state.
     */
    function getVaultState() internal view returns (AggregateVaultStorage.VaultState storage _vaultState) {
        _vaultState = getStorage().vaultState;
    }

    /**
     * @dev Retrieves the current rebalance state from storage.
     * @return _rebalanceState The current rebalance state.
     */
    function getRebalanceState() internal view returns (AggregateVaultStorage.RebalanceState storage _rebalanceState) {
        _rebalanceState = getStorage().rebalanceState;
    }

    function getEmitter() internal view returns (address _emitter) {
        _emitter = getStorage().emitter;
    }
}

/// @title AggregateVaultStorage
/// @author Umami Devs
/// @notice Storage inheritance for AggregateVault
abstract contract AggregateVaultStorage {
    error InvalidAsset();

    enum CallType {
        Call,
        DelegateCall
    }

    struct AssetVaultStorage {
        // size 8
        address vault; // 0
        address token; // 1
        address timelockYieldBoost; // 2
        uint256 feeWatermarkPPS; // 3
        uint256 feeWatermarkDate; // 4
        int256 epochDelta; // 5
        uint256 lastCheckpointTvl; // 6
        uint256 timelockBoostPercent; // 7
    }

    struct SetPricesParams {
        address[] realtimeFeedTokens;
        bytes[] realtimeFeedData;
    }

    struct RebalanceState {
        // size 6
        uint256[2] indexAllocation; // 0
        uint256[2] indexComposition; // 2
        int256 externalPosition; // 4
        uint256 epoch; // 5
    }

    struct VaultState {
        // size 12
        uint256 epoch; // 0
        bool rebalanceOpen; // 1
        uint256 lastRebalanceTime; // 2
        address feeRecipient; // 3
        address depositFeeEscrow; // 4
        address withdrawalFeeEscrow; // 5
        uint256[2] indexAllocation; // 6
        uint256[2] vaultCaps; // 8
        uint256[2] rebalancePPS; // 10
    }

    struct VaultFees {
        // size 4
        uint256 performanceFee; // 0
        uint256 managementFee; // 1
        uint256 withdrawalFee; // 2
        uint256 depositFee; // 3
    }

    /// @dev open close request
    struct OCRequest {
        address sender;
        address account;
        address vault;
        address callback;
        bool isDeposit;
        uint256 amount;
        uint256 minOut;
        uint256 requestBlock;
    }

    struct AVStorage {
        /// @dev vault state
        VaultState vaultState; // 0-11
        /// @notice The array of asset vault entries.
        AssetVaultStorage[2] vaults; // 12-19, 19-26
        /// @dev vault fee storage
        VaultFees vaultFees; // 27-30
        /// @notice The mapping of token addresses to asset vault indices.
        mapping(address => uint256) tokenToAssetVaultIndex; // 31
        /// @notice The mapping of vault indices to asset vault indices.
        mapping(address => uint256) vaultToAssetVaultIndex; // 32
        /// @notice The current rebalance state.
        RebalanceState rebalanceState; // 33-39
        /// @dev |.....||depositHook|withdrawHook|openHook|closeHook|
        bytes32 hooksConfig; // 40
        address hookHandler; // 41
        /// @dev event emitter
        address emitter;
        uint256 requestNonce;
        /// @notice The array of position manager contracts.
        IPositionManager[] positionManagers; // 44
        /// @dev active external position size
        int256 externalPosition; // 45
        /// @dev the vault netted positions
        int256[2][2] nettedPositions; // 46-49
        /// @dev open/close request storage: nonce => request
        mapping(uint256 => OCRequest) pendingRequests; // 50
        /// @dev execution keeper address for gas rebates
        address rebalanceKeeper; // 51
        /// @dev fee logic
        address feeHelper; // 52
        /// @dev execution amount for regular request
        uint256 executionGasAmount; // 53
        /// @dev execution amount for callback request
        uint256 executionGasAmountCallback; // 54
        /// @notice Maps epoch IDs to the last netted prices.
        mapping(uint256 => int256[2]) lastNettedPrices; // 55
        /// @notice The zero sum PnL threshold value.
        uint256 zeroSumPnlThreshold;
        /// @dev block tolerance for acceptable LLO price
        uint8 L1BlockTolerance;
        /// @notice Flag to indicate whether netting should be checked.
        bool shouldCheckNetting; // 57
        /// @notice The netted threshold value.
        uint256 nettedThreshold;
        /// @notice oracle contract.
        address oracleWrapper;
        uint256[2] vaultGmiAttribution; // USDC, ETH
        /// @notice GMI index
        address payable gmi;
        /// @notice Active helper contract
        address aggregateVaultHelper;
        /// @notice active GMX V2 handler contract
        address gmxV2Handler;
        /// @notice Active request handler
        address requestHandler;
        /// @notice If the GMX fee logic should be used on deposit/withdrawal
        bool shouldUseGmxFee;
        /// @notice UNIV3 swap manager
        address uniswapV3SwapManager;
        /// @notice Slippage param for uniswap
        uint256 swapSlippage;
    }

    /**
     * @dev Retrieves the storage struct of the contract.
     * @return _storage The storage struct containing all contract state variables.
     */
    function _getStorage() internal pure returns (AVStorage storage _storage) {
        _storage = LibAggregateVaultStorage.getStorage();
    }

    /**
     * @dev Retrieves the vault state from storage.
     * @return _vaultState The current vault state.
     */
    function _getVaultState() internal view returns (VaultState storage _vaultState) {
        _vaultState = _getStorage().vaultState;
    }

    function _getEmitter() internal view returns (address _emitter) {
        _emitter = _getStorage().emitter;
    }

    function _getRequestHandler() internal view returns (address _rhandler) {
        _rhandler = _getStorage().requestHandler;
    }

    function _getOracleWrapper() internal view returns (address) {
        return _getStorage().oracleWrapper;
    }

    function _getGmxV2Handler() internal view returns (address) {
        return _getStorage().gmxV2Handler;
    }

    function _getShouldUseGmxFee() internal view returns (bool) {
        return _getStorage().shouldUseGmxFee;
    }

    function _getL1BlockTolerance() internal view returns (uint8) {
        return _getStorage().L1BlockTolerance;
    }

    /**
     * @dev Retrieves the vault entries array from storage.
     * @return vaults The array of asset vault entries.
     */
    function _getAssetVaultEntries() internal view returns (AssetVaultStorage[2] storage) {
        return _getStorage().vaults;
    }

    /**
     * @dev Sets the rebalance keeper in storage.
     */
    function _setL1BlockTolerance(uint8 newTolerance) internal {
        _getStorage().L1BlockTolerance = newTolerance;
    }

    /**
     * @dev Sets the rebalance keeper in storage.
     */
    function _setRebalanceKeeper(address newKeeper) internal {
        _getStorage().rebalanceKeeper = newKeeper;
    }

    /**
     * @dev Retrieves the current rebalance state from storage.
     * @return _rebalanceState The current rebalance state.
     */
    function _getRebalanceState() internal view returns (RebalanceState storage _rebalanceState) {
        _rebalanceState = _getStorage().rebalanceState;
    }

    /**
     * @dev Retrieves the netted threshold from storage.
     * @return _nettedThreshold The current netted threshold value.
     */
    function _getNettedThreshold() internal view returns (uint256 _nettedThreshold) {
        _nettedThreshold = _getStorage().nettedThreshold;
    }

    /**
     * @dev Retrieves the array of position managers from storage.
     * @return _positionManagers The array of position managers.
     */
    function _getPositionManagers() internal view returns (IPositionManager[] storage _positionManagers) {
        _positionManagers = _getStorage().positionManagers;
    }

    /**
     * @dev Retrieves the vault to asset vault index mapping from storage.
     * @return _vaultToAssetVaultIndex The mapping of vault addresses to asset vault indexes.
     */
    function _getVaultToAssetVaultIndex()
        internal
        view
        returns (mapping(address => uint256) storage _vaultToAssetVaultIndex)
    {
        _vaultToAssetVaultIndex = _getStorage().vaultToAssetVaultIndex;
    }

    /**
     * @dev Retrieves the token to asset vault index mapping from storage.
     * @return _tokenToAssetVaultIndex The mapping of token addresses to asset vault indexes.
     */
    function _getTokenToAssetVaultIndex()
        internal
        view
        returns (mapping(address => uint256) storage _tokenToAssetVaultIndex)
    {
        _tokenToAssetVaultIndex = _getStorage().tokenToAssetVaultIndex;
    }

    /**
     * @dev Retrieves the netted positions matrix from storage.
     * @return _nettedPositions The matrix of netted positions.
     */
    function _getNettedPositions() internal view returns (int256[2][2] storage _nettedPositions) {
        _nettedPositions = _getStorage().nettedPositions;
    }

    /**
     * @dev Retrieves the netted prices at epoch.
     * @return _nettedPrices The array of netted prices.
     */
    function _getNettedPrices(uint256 epoch) internal view returns (int256[2] storage _nettedPrices) {
        _nettedPrices = _getStorage().lastNettedPrices[epoch];
    }

    /**
     * @dev Retrieves the zero sum PnL threshold from storage.
     * @return _zeroSumPnlThreshold The current zero sum PnL threshold value.
     */
    function _getZeroSumPnlThreshold() internal view returns (uint256 _zeroSumPnlThreshold) {
        _zeroSumPnlThreshold = _getStorage().zeroSumPnlThreshold;
    }

    /**
     * @dev Retrieves the external position from storage.
     * @return _extenralPosition The positions.
     */
    function _getExternalPosition() internal view returns (int256 _extenralPosition) {
        _extenralPosition = _getStorage().externalPosition;
    }

    /**
     * @dev Retrieves the fee helper from storage.
     * @return _feeHelper The current fee helper.
     */
    function _getFeeHelper() internal view returns (address _feeHelper) {
        _feeHelper = _getStorage().feeHelper;
    }

    /**
     * @dev Retrieves the vault fees struct from storage.
     * @return _vaultFees The current vault fees.
     */
    function _getVaultFees() internal view returns (VaultFees storage _vaultFees) {
        _vaultFees = _getStorage().vaultFees;
    }

    /**
     * @dev Retrieves the asset vault entry for the given asset address.
     * @param asset The asset address for which to retrieve the vault entry.
     * @return vault The asset vault entry for the given asset address.
     */
    function _getVaultFromAsset(address asset) internal view returns (AssetVaultStorage storage vault) {
        AssetVaultStorage[2] storage vaults = _getAssetVaultEntries();
        if (vaults[0].token == asset) {
            return vaults[0];
        } else if (vaults[1].token == asset) {
            return vaults[1];
        } else {
            revert InvalidAsset();
        }
    }

    /**
     * @dev Sets the netted positions matrix in storage.
     * @param _nettedPositions The updated netted positions matrix.
     */
    function _setPositions(int256[2][2] memory _nettedPositions, int256 _externalPosition) internal {
        int256[2][2] storage nettedPositions = _getNettedPositions();
        _getStorage().externalPosition = _externalPosition;
        nettedPositions[0][0] = _nettedPositions[0][0];
        nettedPositions[0][1] = _nettedPositions[0][1];
        nettedPositions[1][0] = _nettedPositions[1][0];
        nettedPositions[1][1] = _nettedPositions[1][1];
    }

    /**
     * @dev Sets the vault GMI attribution array in storage.
     * @param vaultGmiAttribution The updated vault GMI attribution array.
     */
    function _setVaultGmiAttribution(uint256[2] memory vaultGmiAttribution) internal {
        uint256[2] storage gmiAttribution = _getStorage().vaultGmiAttribution;
        gmiAttribution[0] = vaultGmiAttribution[0];
        gmiAttribution[1] = vaultGmiAttribution[1];
    }

    /**
     * @notice Get the AssetVaultEntry at the given index.
     * @param _idx The index of the AssetVaultEntry.
     * @return _assetVault The AssetVaultEntry at the given index.
     */
    function _getAssetVaultEntry(uint256 _idx) internal view returns (AssetVaultStorage storage _assetVault) {
        _assetVault = _getAssetVaultEntries()[_idx];
    }

    // HOOKS
    // ------------------------------------------------------------------------

    function _isHookEnabledMask(HookType _type) internal pure returns (uint256) {
        uint256 hookNum = uint256(_type);
        return 1 << ((hookNum * 2) + 1);
    }

    function _hookCallTypeMask(HookType _type) internal pure returns (uint256) {
        uint256 hookNum = uint256(_type);
        return 1 << (hookNum * 2);
    }

    function _getHook(HookType _type) internal view returns (bool _isEnabled, bool _isDelegateHook) {
        bytes32 config = _getStorage().hooksConfig;
        uint256 isEnabledMask = _isHookEnabledMask(_type);
        uint256 callTypeMask = _hookCallTypeMask(_type);
        _isEnabled = (uint256(config) & isEnabledMask) != 0;
        _isDelegateHook = (uint256(config) & callTypeMask) != 0;
    }

    function _enableHook(HookType _type, CallType _callType) internal {
        bytes32 config = _getStorage().hooksConfig;
        uint256 isEnabledMask = _isHookEnabledMask(_type);
        uint256 callTypeMask = _hookCallTypeMask(_type);
        // cleared
        config = bytes32(uint256(config) & ~(isEnabledMask | callTypeMask));
        // set
        config = bytes32(uint256(config) | isEnabledMask | (_callType == CallType.DelegateCall ? callTypeMask : 0));
        _getStorage().hooksConfig = config;
    }

    function _disableHook(HookType _type) internal {
        bytes32 config = _getStorage().hooksConfig;
        uint256 isEnabledMask = _isHookEnabledMask(_type);
        uint256 callTypeMask = _hookCallTypeMask(_type);
        config = bytes32(uint256(config) & ~(isEnabledMask | callTypeMask));
        _getStorage().hooksConfig = config;
    }

    function _executeHook(HookType _hookType, bytes memory _cd) internal returns (bytes memory) {
        (bool isEnabled, bool isDelegateHook) = _getHook(_hookType);
        if (isEnabled) {
            address hookHandler = _getStorage().hookHandler;
            bytes memory hcd = abi.encodeCall(IHookExecutor.executeHook, (_hookType, _cd));

            if (isDelegateHook) {
                return Delegatecall.delegateCall(hookHandler, hcd);
            } else {
                (bool success, bytes memory ret) = hookHandler.call(hcd);
                if (!success) {
                    assembly {
                        let length := mload(ret)
                        let start := add(ret, 0x20)
                        revert(start, length)
                    }
                }
                return ret;
            }
        }
        return hex"";
    }

    function _getBlockNumber() internal view returns (uint256 _blockNumber) {
        _blockNumber = IArbSys(ARBSYS).arbBlockNumber();
    }

    // REQUESTS
    // ------------------------------------------------------------------------

    function _saveRequest(
        address sender,
        address account,
        address vault,
        address callback,
        bool isDeposit,
        uint256 amount,
        uint256 minOut
    ) internal returns (uint256 requestNonce) {
        AVStorage storage stg = _getStorage();
        stg.pendingRequests[++stg.requestNonce] = OCRequest({
            sender: sender,
            account: account,
            vault: vault,
            callback: callback,
            isDeposit: isDeposit,
            amount: amount,
            minOut: minOut,
            requestBlock: _getBlockNumber()
        });
        return stg.requestNonce;
    }

    function _getRequest(uint256 key) internal view returns (OCRequest memory order) {
        AVStorage storage stg = _getStorage();
        order = stg.pendingRequests[key];
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

// @title ArbSys
// @dev Globally available variables for Arbitrum may have both an L1 and an L2
// value, the ArbSys interface is used to retrieve the L2 value
interface ArbSys {
    function arbBlockNumber() external view returns (uint256);
    function arbBlockHash(uint256 blockNumber) external view returns (bytes32);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../error/Errors.sol";

/**
 * @title Array
 * @dev Library for array functions
 */
library Array {
    using SafeCast for int256;

    /**
     * @dev Gets the value of the element at the specified index in the given array. If the index is out of bounds, returns 0.
     *
     * @param arr the array to get the value from
     * @param index the index of the element in the array
     * @return the value of the element at the specified index in the array
     */
    function get(bytes32[] memory arr, uint256 index) internal pure returns (bytes32) {
        if (index < arr.length) {
            return arr[index];
        }

        return bytes32(0);
    }

    /**
     * @dev Determines whether all of the elements in the given array are equal to the specified value.
     *
     * @param arr the array to check the elements of
     * @param value the value to compare the elements of the array to
     * @return true if all of the elements in the array are equal to the specified value, false otherwise
     */
    function areEqualTo(uint256[] memory arr, uint256 value) internal pure returns (bool) {
        for (uint256 i; i < arr.length; i++) {
            if (arr[i] != value) {
                return false;
            }
        }

        return true;
    }

    /**
     * @dev Determines whether all of the elements in the given array are greater than the specified value.
     *
     * @param arr the array to check the elements of
     * @param value the value to compare the elements of the array to
     * @return true if all of the elements in the array are greater than the specified value, false otherwise
     */
    function areGreaterThan(uint256[] memory arr, uint256 value) internal pure returns (bool) {
        for (uint256 i; i < arr.length; i++) {
            if (arr[i] <= value) {
                return false;
            }
        }

        return true;
    }

    /**
     * @dev Determines whether all of the elements in the given array are greater than or equal to the specified value.
     *
     * @param arr the array to check the elements of
     * @param value the value to compare the elements of the array to
     * @return true if all of the elements in the array are greater than or equal to the specified value, false otherwise
     */
    function areGreaterThanOrEqualTo(uint256[] memory arr, uint256 value) internal pure returns (bool) {
        for (uint256 i; i < arr.length; i++) {
            if (arr[i] < value) {
                return false;
            }
        }

        return true;
    }

    /**
     * @dev Determines whether all of the elements in the given array are less than the specified value.
     *
     * @param arr the array to check the elements of
     * @param value the value to compare the elements of the array to
     * @return true if all of the elements in the array are less than the specified value, false otherwise
     */
    function areLessThan(uint256[] memory arr, uint256 value) internal pure returns (bool) {
        for (uint256 i; i < arr.length; i++) {
            if (arr[i] >= value) {
                return false;
            }
        }

        return true;
    }

    /**
     * @dev Determines whether all of the elements in the given array are less than or equal to the specified value.
     *
     * @param arr the array to check the elements of
     * @param value the value to compare the elements of the array to
     * @return true if all of the elements in the array are less than or equal to the specified value, false otherwise
     */
    function areLessThanOrEqualTo(uint256[] memory arr, uint256 value) internal pure returns (bool) {
        for (uint256 i; i < arr.length; i++) {
            if (arr[i] > value) {
                return false;
            }
        }

        return true;
    }

    /**
     * @dev Gets the median value of the elements in the given array. For arrays with an odd number of elements, returns the element at the middle index. For arrays with an even number of elements, returns the average of the two middle elements.
     *
     * @param arr the array to get the median value from
     * @return the median value of the elements in the given array
     */
    function getMedian(uint256[] memory arr) internal pure returns (uint256) {
        if (arr.length % 2 == 1) {
            return arr[arr.length / 2];
        }

        return (arr[arr.length / 2] + arr[arr.length / 2 - 1]) / 2;
    }

    /**
     * @dev Gets the uncompacted value at the specified index in the given array of compacted values.
     *
     * @param compactedValues the array of compacted values to get the uncompacted value from
     * @param index the index of the uncompacted value in the array
     * @param compactedValueBitLength the length of each compacted value, in bits
     * @param bitmask the bitmask to use to extract the uncompacted value from the compacted value
     * @return the uncompacted value at the specified index in the array of compacted values
     */
    function getUncompactedValue(
        uint256[] memory compactedValues,
        uint256 index,
        uint256 compactedValueBitLength,
        uint256 bitmask,
        string memory label
    ) internal pure returns (uint256) {
        uint256 compactedValuesPerSlot = 256 / compactedValueBitLength;

        uint256 slotIndex = index / compactedValuesPerSlot;
        if (slotIndex >= compactedValues.length) {
            revert Errors.CompactedArrayOutOfBounds(compactedValues, index, slotIndex, label);
        }

        uint256 slotBits = compactedValues[slotIndex];
        uint256 offset = (index - slotIndex * compactedValuesPerSlot) * compactedValueBitLength;

        uint256 value = (slotBits >> offset) & bitmask;

        return value;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import { BaseVault } from "./BaseVault.sol";
import { ERC20 } from "solmate/tokens/ERC20.sol";
import { SafeTransferLib } from "solmate/utils/SafeTransferLib.sol";
import { ReentrancyGuard } from "solmate/utils/ReentrancyGuard.sol";
import { ShareMath } from "../libraries/ShareMath.sol";

import { GlobalACL, REQUEST_HANDLER, AGGREGATE_VAULT_ROLE } from "../Auth.sol";
import { PausableVault } from "../PausableVault.sol";
import { AggregateVault } from "./AggregateVault.sol";
import { AggregateVaultStorage } from "../storage/AggregateVaultStorage.sol";

/// @title AssetVault
/// @author Umami DAO
/// @notice ERC4626-like implementation for vault receipt tokens
contract AssetVault is BaseVault, PausableVault, GlobalACL, ReentrancyGuard {
    using SafeTransferLib for ERC20;

    /// @dev the aggregate vault for the strategy
    AggregateVault public aggregateVault;

    constructor(ERC20 _asset, string memory _name, string memory _symbol, address _aggregateVault)
        BaseVault(_asset, _name, _symbol)
        GlobalACL(AggregateVault(payable(_aggregateVault)).AUTH())
    {
        aggregateVault = AggregateVault(payable(_aggregateVault));
    }

    // DEPOSIT & WITHDRAW
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Deposit a specified amount of assets and mint corresponding shares to the receiver
     * @param assets The amount of assets to deposit
     * @param minOutAfterFees Minimum amount out after fees
     * @param receiver The address to receive the minted shares
     * @return shares The estimate amount of shares minted for the deposited assets
     */
    function deposit(uint256 assets, uint256 minOutAfterFees, address receiver)
        public
        payable
        override
        whenDepositNotPaused
        nonReentrant
        returns (uint256 shares)
    {
        // Check for rounding error since we round down in previewDeposit.
        require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");
        require(
            totalAssets() + assets <= previewVaultCap() + asset.balanceOf(address(this)), "AssetVault: over vault cap"
        );
        // Transfer assets to aggregate vault, transfer before minting or ERC777s could reenter.
        asset.safeTransferFrom(msg.sender, address(this), assets);
        aggregateVault.handleDeposit{ value: msg.value }(assets, minOutAfterFees, receiver, msg.sender, address(0));

        emit Deposit(msg.sender, receiver, assets, shares);
    }

    /**
     * @notice Redeem a specified amount of shares by burning them and transferring the corresponding amount of assets to the receiver
     * @param shares The amount of shares to redeem
     * @param minOutAfterFees Minimum amount out after fees
     * @param receiver The address to receive the corresponding assets
     * @param owner The address of the share owner
     * @return assets The estimate amount of assets transferred for the redeemed shares
     */
    function redeem(uint256 shares, uint256 minOutAfterFees, address receiver, address owner)
        public
        payable
        override
        whenWithdrawalNotPaused
        nonReentrant
        returns (uint256 assets)
    {
        require(shares > 0, "AssetVault: !shares > 0");
        assets = totalSupply == 0 ? shares : ShareMath.sharesToAsset(shares, pps(), decimals);
        if (msg.sender != owner) _checkAllowance(owner, shares);
        require(assets <= asset.balanceOf(address(aggregateVault)), "AssetVault: assets not available");

        // Check for rounding error since we round down in previewRedeem.
        require(previewRedeem(shares) != 0, "ZERO_ASSETS");

        // transfer shares in
        ERC20(address(this)).safeTransferFrom(owner, address(this), shares);

        // handle withdraw
        aggregateVault.handleWithdraw{ value: msg.value }(shares, minOutAfterFees, receiver, msg.sender, address(0));

        emit Withdraw(owner, receiver, owner, assets, shares);
    }

    // WITH CALLBACKS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Deposit a specified amount of assets and mint corresponding shares to the receiver
     * @param assets The amount of assets to deposit
     * @param minOutAfterFees Minimum amount out after fees
     * @param receiver The address to receive the minted shares
     * @param callback The address to callback to after execution
     * @return shares The estimate amount of shares minted for the deposited assets
     */
    function depositWithCallback(uint256 assets, uint256 minOutAfterFees, address receiver, address callback)
        public
        payable
        whenDepositNotPaused
        nonReentrant
        returns (uint256 shares)
    {
        // Check for rounding error since we round down in previewDeposit.
        require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");
        require(
            totalAssets() + assets <= previewVaultCap() + asset.balanceOf(address(this)), "AssetVault: over vault cap"
        );
        // Transfer assets to aggregate vault, transfer before minting or ERC777s could reenter.
        asset.safeTransferFrom(msg.sender, address(this), assets);
        aggregateVault.handleDeposit{ value: msg.value }(assets, minOutAfterFees, receiver, msg.sender, callback);
        emit Deposit(msg.sender, receiver, assets, shares);
    }

    /**
     * @notice Redeem a specified amount of shares by burning them and transferring the corresponding amount of assets to the receiver
     * @param shares The amount of shares to redeem
     * @param minOutAfterFees Minimum amount out after fees
     * @param receiver The address to receive the corresponding assets
     * @param owner The address of the share owner
     * @param callback The address to callback to after execution
     * @return assets The estimate amount of assets transferred for the redeemed shares
     */
    function redeemWithCallback(
        uint256 shares,
        uint256 minOutAfterFees,
        address receiver,
        address owner,
        address callback
    ) public payable whenWithdrawalNotPaused nonReentrant returns (uint256 assets) {
        require(shares > 0, "AssetVault: !shares > 0");
        assets = totalSupply == 0 ? shares : ShareMath.sharesToAsset(shares, pps(), decimals);

        if (msg.sender != owner) _checkAllowance(owner, shares);

        // Check for rounding error since we round down in previewRedeem.
        require(previewRedeem(shares) != 0, "ZERO_ASSETS");

        // transfer shares in
        ERC20(address(this)).safeTransferFrom(owner, address(this), shares);

        // handle withdrawal
        aggregateVault.handleWithdraw{ value: msg.value }(shares, minOutAfterFees, receiver, msg.sender, callback);

        emit Withdraw(owner, receiver, owner, assets, shares);
    }

    /**
     * @notice Cancels a vault request for this vault
     * @param key The request key to cancel
     */
    function cancelRequest(uint256 key) external {
        AggregateVaultStorage.OCRequest memory request = aggregateVault.getRequest(key);
        require(request.vault == address(this), "AssetVault: invalid vault");
        require(request.sender == msg.sender, "AssetVault: invalid account");

        if (request.isDeposit) {
            asset.safeTransfer(msg.sender, request.amount);
        } else {
            ERC20(address(this)).safeTransfer(msg.sender, request.amount);
        }

        aggregateVault.clearRequest(key);
    }

    // MATH
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Get the total value locked (TVL) of the vault
     * @return totalValueLocked The current total value locked
     */
    function totalAssets() public view override returns (uint256 totalValueLocked) {
        (bool success, bytes memory ret) =
            address(aggregateVault).staticcall(abi.encodeCall(AggregateVault.getVaultTVL, (address(this), false)));

        // bubble up error message
        if (!success) {
            assembly {
                let length := mload(ret)
                revert(add(32, ret), length)
            }
        }
        totalValueLocked = abi.decode(ret, (uint256));
    }

    /**
     * @notice Get the price per share (PPS) of the vault
     * @return pricePerShare The current price per share
     */
    function pps() public view returns (uint256 pricePerShare) {
        (bool success, bytes memory ret) =
            address(aggregateVault).staticcall(abi.encodeCall(AggregateVault.getVaultPPS, (address(this), true, false)));

        // bubble up error message
        if (!success) {
            assembly {
                let length := mload(ret)
                revert(add(32, ret), length)
            }
        }

        pricePerShare = abi.decode(ret, (uint256));
    }

    /**
     * @notice Convert a specified amount of assets to shares
     * @param assets The amount of assets to convert
     * @return - The amount of shares corresponding to the given assets
     */
    function convertToShares(uint256 assets) public view override returns (uint256) {
        return totalSupply == 0 ? assets : ShareMath.assetToShares(assets, pps(), decimals);
    }

    /**
     * @notice Convert a specified amount of shares to assets
     * @param shares The amount of shares to convert
     * @return - The amount of assets corresponding to the given shares
     */
    function convertToAssets(uint256 shares) public view override returns (uint256) {
        return totalSupply == 0 ? shares : ShareMath.sharesToAsset(shares, pps(), decimals);
    }

    /**
     * @notice Preview the amount of shares for a given deposit amount
     * @param assets The amount of assets to deposit
     * @return - The amount of shares for the given deposit amount
     */
    function previewDeposit(uint256 assets) public view override returns (uint256) {
        uint256 assetFee = previewDepositFee(assets);
        if (assetFee >= assets) return 0;
        return convertToShares(assets - assetFee);
    }

    /**
     * @notice Preview the amount of assets for a given redeem amount
     * @param shares The amount of shares to redeem
     * @return The amount of assets for the given redeem amount
     */
    function previewRedeem(uint256 shares) public view override returns (uint256) {
        uint256 assets = ShareMath.sharesToAsset(shares, pps(), decimals);
        uint256 assetFee = previewWithdrawalFee(assets);
        if (assetFee >= assets) return 0;
        return assets - assetFee;
    }

    // DEPOSIT & WITHDRAW LIMIT
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Get the maximum deposit amount for an address
     * @dev _address The address to check the maximum deposit amount for
     * @dev returns the maximum deposit amount for the given address
     */
    function maxDeposit(address) public view override returns (uint256) {
        uint256 cap = previewVaultCap();
        uint256 tvl_ = totalAssets();
        return cap > tvl_ ? cap - tvl_ : 0;
    }

    /**
     * @notice Get the maximum mint amount for an address
     */
    function maxMint(address) public view override returns (uint256) {
        uint256 cap = previewVaultCap();
        uint256 tvl_ = totalAssets();
        return cap > tvl_ ? convertToShares(cap - tvl_) : 0;
    }

    /**
     * @notice Get the maximum withdrawal amount for an address
     * @param owner The address to check the maximum withdrawal amount for
     * @return The maximum withdrawal amount for the given address
     */
    function maxWithdraw(address owner) public view override returns (uint256) {
        uint256 aggBalance = asset.balanceOf(address(aggregateVault));
        uint256 userMaxAssets = convertToAssets(balanceOf[owner]);
        return aggBalance > userMaxAssets ? userMaxAssets : aggBalance;
    }

    /**
     * @notice Get the maximum redeem amount for an address
     * @param owner The address to check the maximum redeem amount for
     * @return - The maximum redeem amount for the given address
     */
    function maxRedeem(address owner) public view override returns (uint256) {
        uint256 aggBalance = convertToShares(asset.balanceOf(address(aggregateVault)));
        return aggBalance > balanceOf[owner] ? balanceOf[owner] : aggBalance;
    }

    // UTILS
    // ------------------------------------------------------------------------------------------

    /**
     * @notice Pause deposit and withdrawal operations
     */
    function pauseDepositWithdraw() external onlyAggregateVault {
        _pause();
    }

    /**
     * @notice Unpause deposit and withdrawal operations
     */
    function unpauseDepositWithdraw() external onlyAggregateVault {
        _unpause();
    }

    /**
     * @notice Pause deposits operations
     */
    function pauseDeposits() external onlyConfigurator {
        _pauseDeposit();
    }

    /**
     * @notice Unpause deposit operations
     */
    function unpauseDeposits() external onlyConfigurator {
        _unpauseDeposit();
    }

    /**
     * @notice Pause withdrawal operations
     */
    function pauseWithdrawals() external onlyConfigurator {
        _pauseWithdrawal();
    }

    /**
     * @notice Unpause withdrawal operations
     */
    function unpauseWithdrawals() external onlyConfigurator {
        _unpauseWithdrawal();
    }

    /**
     * @notice Update the aggregate vault to a new instance
     * @param _newAggregateVault The new aggregate vault instance to update to
     */
    function updateAggregateVault(AggregateVault _newAggregateVault) external onlyConfigurator {
        aggregateVault = _newAggregateVault;
    }

    /**
     * @notice Mint a specified amount of shares to an address
     * @param _mintAmount The amount of shares to mint
     * @param _toAddress The address to mint
     */
    function mintTo(uint256 _mintAmount, address _toAddress) external validateMintCallAuth(_toAddress) {
        _mint(_toAddress, _mintAmount);
    }

    /**
     * @notice Burn tokens during order execution
     * @param _burnAmount The amount of shares to burn
     */
    function burnShares(uint256 _burnAmount) external onlyRequestHandler {
        _burn(address(this), _burnAmount);
    }

    /**
     * @notice Lodge the underlying assets for a deposit execution
     * @param _assetAmount The amount of assets to lodge
     */
    function lodgeAssets(uint256 _assetAmount, address feeReciever, uint256 _depositFees) external onlyRequestHandler {
        asset.safeTransfer(address(aggregateVault), _assetAmount);
        if (_depositFees > 0 && feeReciever != address(0)) asset.safeTransfer(feeReciever, _depositFees);
    }

    /**
     * @notice Return deposited assets
     */
    function returnAssets(address _to, uint256 _amt) external onlyRequestHandler {
        asset.safeTransfer(_to, _amt);
    }

    /**
     * @notice Return withdraw request shares
     */
    function returnShares(address _to, uint256 _amt) external onlyRequestHandler {
        ERC20(address(this)).safeTransfer(_to, _amt);
    }

    /**
     * @notice Preview the deposit fee for a specified amount of assets
     * @param size The amount of assets to preview the deposit fee for
     * @return totalDepositFee The total deposit fee for the specified amount of assets
     */
    function previewDepositFee(uint256 size) public view returns (uint256 totalDepositFee) {
        (bool success, bytes memory ret) = address(aggregateVault).staticcall(
            abi.encodeCall(AggregateVault.previewDepositFee, (address(asset), size, false))
        );
        if (!success) {
            assembly {
                let length := mload(ret)
                revert(add(32, ret), length)
            }
        }
        totalDepositFee = abi.decode(ret, (uint256));
    }

    /**
     * @notice Preview the withdrawal fee for a specified amount of assets
     * @param size The amount of assets to preview the withdrawal fee for
     * @return totalWithdrawalFee The total withdrawal fee for the specified amount of assets
     */
    function previewWithdrawalFee(uint256 size) public view returns (uint256 totalWithdrawalFee) {
        (bool success, bytes memory ret) = address(aggregateVault).staticcall(
            abi.encodeCall(AggregateVault.previewWithdrawalFee, (address(asset), size, false))
        );
        if (!success) {
            assembly {
                let length := mload(ret)
                revert(add(32, ret), length)
            }
        }
        totalWithdrawalFee = abi.decode(ret, (uint256));
    }

    /**
     * @notice Preview the deposit cap for the vault
     * @return - The current deposit cap for the vault
     */
    function previewVaultCap() public view returns (uint256) {
        return aggregateVault.previewVaultCap(address(asset));
    }

    /**
     * @dev Check the owners spend allowance
     */
    function _checkAllowance(address owner, uint256 shares) internal {
        uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals.
        if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares;
    }

    /// @dev validate the mint call
    modifier validateMintCallAuth(address _mintTo) {
        require(
            (_mintTo == aggregateVault.getVaultTimelockAddress(address(asset)) && address(aggregateVault) == msg.sender)
                || AUTH.hasRole(REQUEST_HANDLER, msg.sender),
            "AssetVault: !validateMintCallAuth"
        );
        _;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

bytes32 constant CONFIGURATOR_ROLE = keccak256("CONFIGURATOR");
bytes32 constant AGGREGATE_VAULT_ROLE = keccak256("AGGREGATE_VAULT");
bytes32 constant REQUEST_HANDLER = keccak256("REQUEST_HANDLER");
bytes32 constant KEEPER_ROLE = keccak256("KEEPER_ROLE");
bytes32 constant EXECUTION_KEEPER = keccak256("EXECUTION_KEEPER");
bytes32 constant SWAP_KEEPER = keccak256("SWAP_KEEPER");

/// @title Auth
/// @author Umami Devs
/// @notice Simple centralized ACL
contract Auth {
    /// @dev user not authorized with given role
    error NotAuthorized(bytes32 _role, address _user);

    event RoleUpdated(bytes32 indexed role, address indexed user, bool authorized);

    bytes32 public constant AUTH_MANAGER_ROLE = keccak256("AUTH_MANAGER");
    mapping(bytes32 => mapping(address => bool)) public hasRole;

    constructor() {
        _updateRole(msg.sender, AUTH_MANAGER_ROLE, true);
    }

    function updateRole(address _user, bytes32 _role, bool _authorized) external {
        onlyRole(AUTH_MANAGER_ROLE, msg.sender);
        _updateRole(_user, _role, _authorized);
    }

    function onlyRole(bytes32 _role, address _user) public view {
        if (!hasRole[_role][_user]) {
            revert NotAuthorized(_role, _user);
        }
    }

    function _updateRole(address _user, bytes32 _role, bool _authorized) internal {
        hasRole[_role][_user] = _authorized;
        emit RoleUpdated(_role, _user, _authorized);
    }
}

/// @title GlobalACL
/// @author Umami Devs
abstract contract GlobalACL {
    Auth public immutable AUTH;

    constructor(Auth _auth) {
        require(address(_auth) != address(0), "GlobalACL: zero address");
        AUTH = _auth;
    }

    modifier onlyConfigurator() {
        AUTH.onlyRole(CONFIGURATOR_ROLE, msg.sender);
        _;
    }

    modifier onlyAggregateVault() {
        AUTH.onlyRole(AGGREGATE_VAULT_ROLE, msg.sender);
        _;
    }

    modifier onlyRequestHandler() {
        AUTH.onlyRole(REQUEST_HANDLER, msg.sender);
        _;
    }

    modifier onlyExecutionKeeper() {
        AUTH.onlyRole(EXECUTION_KEEPER, msg.sender);
        _;
    }

    modifier onlyRole(bytes32 _role) {
        AUTH.onlyRole(_role, msg.sender);
        _;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "../token/TokenUtils.sol";
import "../role/RoleModule.sol";

// @title Bank
// @dev Contract to handle storing and transferring of tokens
contract Bank is RoleModule {
    using SafeERC20 for IERC20;

    DataStore public immutable dataStore;

    constructor(RoleStore _roleStore, DataStore _dataStore) RoleModule(_roleStore) {
        dataStore = _dataStore;
    }

    receive() external payable {
        address wnt = TokenUtils.wnt(dataStore);
        if (msg.sender != wnt) {
            revert Errors.InvalidNativeTokenSender(msg.sender);
        }
    }

    // @dev transfer tokens from this contract to a receiver
    //
    // @param token the token to transfer
    // @param amount the amount to transfer
    // @param receiver the address to transfer to
    function transferOut(
        address token,
        address receiver,
        uint256 amount
    ) external onlyController {
        _transferOut(token, receiver, amount);
    }

    // @dev transfer tokens from this contract to a receiver
    // handles native token transfers as well
    //
    // @param token the token to transfer
    // @param amount the amount to transfer
    // @param receiver the address to transfer to
    // @param shouldUnwrapNativeToken whether to unwrap the wrapped native token
    // before transferring
    function transferOut(
        address token,
        address receiver,
        uint256 amount,
        bool shouldUnwrapNativeToken
    ) external onlyController {
        address wnt = TokenUtils.wnt(dataStore);

        if (token == wnt && shouldUnwrapNativeToken) {
            _transferOutNativeToken(token, receiver, amount);
        } else {
            _transferOut(token, receiver, amount);
        }
    }

    // @dev transfer native tokens from this contract to a receiver
    //
    // @param token the token to transfer
    // @param amount the amount to transfer
    // @param receiver the address to transfer to
    // @param shouldUnwrapNativeToken whether to unwrap the wrapped native token
    // before transferring
    function transferOutNativeToken(
        address receiver,
        uint256 amount
    ) external onlyController {
        address wnt = TokenUtils.wnt(dataStore);
        _transferOutNativeToken(wnt, receiver, amount);
    }

    // @dev transfer tokens from this contract to a receiver
    //
    // @param token the token to transfer
    // @param amount the amount to transfer
    // @param receiver the address to transfer to
    function _transferOut(
        address token,
        address receiver,
        uint256 amount
    ) internal {
        if (receiver == address(this)) {
            revert Errors.SelfTransferNotSupported(receiver);
        }

        TokenUtils.transfer(dataStore, token, receiver, amount);

        _afterTransferOut(token);
    }

    // @dev unwrap wrapped native tokens and transfer the native tokens from
    // this contract to a receiver
    //
    // @param token the token to transfer
    // @param amount the amount to transfer
    // @param receiver the address to transfer to
    function _transferOutNativeToken(
        address token,
        address receiver,
        uint256 amount
    ) internal {
        if (receiver == address(this)) {
            revert Errors.SelfTransferNotSupported(receiver);
        }

        TokenUtils.withdrawAndSendNativeToken(
            dataStore,
            token,
            receiver,
            amount
        );

        _afterTransferOut(token);
    }

    function _afterTransferOut(address /* token */) internal virtual {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import { IHandlerContract } from "./interfaces/IHandlerContract.sol";
import { ISwapManager } from "./interfaces/ISwapManager.sol";
import { PositionManagerRouter } from "./position-managers/PositionManagerRouter.sol";

/**
 * @title BaseHandler
 * @author Umami DAO
 * @notice Abstract base contract for implementing handler contracts with a delegate call restriction.
 * @dev Any contract inheriting from this contract must implement the IHandlerContract interface.
 */
abstract contract BaseHandler is IHandlerContract {
    address immutable SELF;

    error OnlyDelegateCall();

    constructor() {
        SELF = address(this);
    }

    /**
     * @notice Executes a token swap using the provided SwapManager instance.
     * @param _swapManager The SwapManager instance to use for the swap.
     * @param _tokenIn The address of the input token.
     * @param _tokenOut The address of the output token.
     * @param _amountIn The input amount to swap.
     * @param _minOut The minimum output amount required for the swap.
     * @param _data Additional data for the swap.
     * @return _amountOut The output amount received from the swap.
     */
    function _executeSwap(
        ISwapManager _swapManager,
        address _tokenIn,
        address _tokenOut,
        uint256 _amountIn,
        uint256 _minOut,
        bytes memory _data
    ) internal returns (uint256 _amountOut) {
        _amountOut = PositionManagerRouter(payable(address(this))).executeSwap(
            _swapManager, _tokenIn, _tokenOut, _amountIn, _minOut, _data
        );
    }

    /**
     * @notice Modifier to restrict functions to be called only via delegate call.
     * @dev Reverts if the function is called directly (not via delegate call).
     */
    modifier onlyDelegateCall() {
        if (address(this) == SELF) {
            revert OnlyDelegateCall();
        }
        _;
    }
}

pragma solidity 0.8.17;

import { BaseHandler } from "../BaseHandler.sol";
import { ISwapManager } from "../interfaces/ISwapManager.sol";
import { IHandlerContract } from "../interfaces/IHandlerContract.sol";
import { ERC20 } from "solmate/tokens/ERC20.sol";

/**
 * @title BaseSwapManager
 * @author Umami Devs
 * @notice Abstract base contract for implementing swap managers.
 * @dev This contract provides common functionality for swap manager implementations and enforces
 * swap checks using the `swapChecks` modifier.
 */
abstract contract BaseSwapManager is BaseHandler, ISwapManager {
    error InsufficientOutput();
    error InsufficientInput();
    error InvalidInput();
    error TooMuchInput();

    /**
     * @notice Returns an empty array for callback signatures.
     * @return _ret An empty bytes4[] array.
     */
    function callbackSigs() external pure returns (bytes4[] memory _ret) {
        _ret = new bytes4[](0);
    }

    /**
     * @notice Modifier to enforce swap checks, ensuring sufficient input and output token amounts.
     * @param _tokenIn The address of the input token.
     * @param _tokenOut The address of the output token.
     * @param _amountIn The amount of input tokens to swap.
     * @param _minOut The minimum amount of output tokens to receive.
     */
    modifier swapChecks(address _tokenIn, address _tokenOut, uint256 _amountIn, uint256 _minOut) {
        uint256 tokenInBalance = ERC20(_tokenIn).balanceOf(address(this));
        if (tokenInBalance < _amountIn) revert InsufficientInput();
        uint256 tokenOutBalanceBefore = ERC20(_tokenOut).balanceOf(address(this));
        _;
        uint256 tokenOutBalanceAfter = ERC20(_tokenOut).balanceOf(address(this));
        uint256 actualOut = tokenOutBalanceAfter - tokenOutBalanceBefore;
        if (actualOut < _minOut) revert InsufficientOutput();
    }

    /**
     * @notice Modifier to enforce swap checks, ensuring sufficient input and output token amounts.
     * @param _tokenIn The address of the input token.
     * @param _tokenOut The address of the output token.
     * @param _amountOut The amount of output tokens to expect.
     * @param _maxIn The max amount of input tokens to send.
     */
    modifier swapChecksExactOutput(address _tokenIn, address _tokenOut, uint256 _amountOut, uint256 _maxIn) {
        uint256 tokenInBalance = ERC20(_tokenIn).balanceOf(address(this));
        uint256 tokenOutBalanceBefore = ERC20(_tokenOut).balanceOf(address(this));
        _;
        uint256 tokenOutBalanceAfter = ERC20(_tokenOut).balanceOf(address(this));
        uint256 actualOut = tokenOutBalanceAfter - tokenOutBalanceBefore;
        if (actualOut != _amountOut) revert InsufficientOutput();
        uint256 actualIn = tokenInBalance - ERC20(_tokenIn).balanceOf(address(this));
        if (actualIn > _maxIn) revert TooMuchInput();
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import { ERC20 } from "solmate/tokens/ERC20.sol";
import { SafeTransferLib } from "solmate/utils/SafeTransferLib.sol";
import { FixedPointMathLib } from "solmate/utils/FixedPointMathLib.sol";

abstract contract BaseVault is ERC20 {
    using SafeTransferLib for ERC20;
    using FixedPointMathLib for uint256;

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);

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

    /*//////////////////////////////////////////////////////////////
                               IMMUTABLES
    //////////////////////////////////////////////////////////////*/

    ERC20 public immutable asset;

    constructor(ERC20 _asset, string memory _name, string memory _symbol) ERC20(_name, _symbol, _asset.decimals()) {
        asset = _asset;
    }

    /*//////////////////////////////////////////////////////////////
                        DEPOSIT/WITHDRAWAL LOGIC
    //////////////////////////////////////////////////////////////*/

    function deposit(uint256 assets, uint256, /*minOutAfterFees*/ address receiver)
        public
        payable
        virtual
        returns (uint256 shares)
    {
        // Check for rounding error since we round down in previewDeposit.
        require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");

        // Need to transfer before minting or ERC777s could reenter.
        asset.safeTransferFrom(msg.sender, address(this), assets);

        _mint(receiver, shares);

        emit Deposit(msg.sender, receiver, assets, shares);

        afterDeposit(assets, shares);
    }

    function redeem(uint256 shares, uint256, /*minOutAfterFees*/ address receiver, address owner)
        public
        payable
        virtual
        returns (uint256 assets)
    {
        if (msg.sender != owner) {
            uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals.

            if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares;
        }

        // Check for rounding error since we round down in previewRedeem.
        require((assets = previewRedeem(shares)) != 0, "ZERO_ASSETS");

        beforeWithdraw(assets, shares);

        _burn(owner, shares);

        emit Withdraw(msg.sender, receiver, owner, assets, shares);

        asset.safeTransfer(receiver, assets);
    }

    /*//////////////////////////////////////////////////////////////
                            ACCOUNTING LOGIC
    //////////////////////////////////////////////////////////////*/

    function totalAssets() public view virtual returns (uint256);

    function convertToShares(uint256 assets) public view virtual returns (uint256) {
        uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero.

        return supply == 0 ? assets : assets.mulDivDown(supply, totalAssets());
    }

    function convertToAssets(uint256 shares) public view virtual returns (uint256) {
        uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero.

        return supply == 0 ? shares : shares.mulDivDown(totalAssets(), supply);
    }

    function previewDeposit(uint256 assets) public view virtual returns (uint256) {
        return convertToShares(assets);
    }

    function previewMint(uint256 shares) public view virtual returns (uint256) {
        uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero.

        return supply == 0 ? shares : shares.mulDivUp(totalAssets(), supply);
    }

    function previewWithdraw(uint256 assets) public view virtual returns (uint256) {
        uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero.

        return supply == 0 ? assets : assets.mulDivUp(supply, totalAssets());
    }

    function previewRedeem(uint256 shares) public view virtual returns (uint256) {
        return convertToAssets(shares);
    }

    /*//////////////////////////////////////////////////////////////
                     DEPOSIT/WITHDRAWAL LIMIT LOGIC
    //////////////////////////////////////////////////////////////*/

    function maxDeposit(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxMint(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return convertToAssets(balanceOf[owner]);
    }

    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf[owner];
    }

    /*//////////////////////////////////////////////////////////////
                          INTERNAL HOOKS LOGIC
    //////////////////////////////////////////////////////////////*/

    function beforeWithdraw(uint256 assets, uint256 shares) internal virtual { }

    function afterDeposit(uint256 assets, uint256 shares) internal virtual { }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

/**
 * @title Bits
 * @dev Library for bit values
 */
library Bits {
    // @dev uint256(~0) is 256 bits of 1s
    // @dev shift the 1s by (256 - 8) to get (256 - 8) 0s followed by 8 1s
    uint256 constant public BITMASK_8 = ~uint256(0) >> (256 - 8);
    // @dev shift the 1s by (256 - 16) to get (256 - 16) 0s followed by 16 1s
    uint256 constant public BITMASK_16 = ~uint256(0) >> (256 - 16);
    // @dev shift the 1s by (256 - 32) to get (256 - 32) 0s followed by 32 1s
    uint256 constant public BITMASK_32 = ~uint256(0) >> (256 - 32);
    // @dev shift the 1s by (256 - 64) to get (256 - 64) 0s followed by 64 1s
    uint256 constant public BITMASK_64 = ~uint256(0) >> (256 - 64);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SignedMath.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";

/**
 * @title Calc
 * @dev Library for math functions
 */
library Calc {
    using SignedMath for int256;
    using SafeCast for uint256;

    // this method assumes that min is less than max
    function boundMagnitude(int256 value, uint256 min, uint256 max) internal pure returns (int256) {
        uint256 magnitude = value.abs();

        if (magnitude < min) {
            magnitude = min;
        }

        if (magnitude > max) {
            magnitude = max;
        }

        int256 sign = value == 0 ? int256(1) : value / value.abs().toInt256();

        return magnitude.toInt256() * sign;
    }

    /**
     * @dev Calculates the result of dividing the first number by the second number,
     * rounded up to the nearest integer.
     *
     * @param a the dividend
     * @param b the divisor
     * @return the result of dividing the first number by the second number, rounded up to the nearest integer
     */
    function roundUpDivision(uint256 a, uint256 b) internal pure returns (uint256) {
        return (a + b - 1) / b;
    }

    /**
     * Calculates the result of dividing the first number by the second number,
     * rounded up to the nearest integer.
     * The rounding is purely on the magnitude of a, if a is negative the result
     * is a larger magnitude negative
     *
     * @param a the dividend
     * @param b the divisor
     * @return the result of dividing the first number by the second number, rounded up to the nearest integer
     */
    function roundUpMagnitudeDivision(int256 a, uint256 b) internal pure returns (int256) {
        if (a < 0) {
            return (a - b.toInt256() + 1) / b.toInt256();
        }

        return (a + b.toInt256() - 1) / b.toInt256();
    }

    /**
     * Adds two numbers together and return a uint256 value, treating the second number as a signed integer.
     *
     * @param a the first number
     * @param b the second number
     * @return the result of adding the two numbers together
     */
    function sumReturnUint256(uint256 a, int256 b) internal pure returns (uint256) {
        if (b > 0) {
            return a + b.abs();
        }

        return a - b.abs();
    }

    /**
     * Adds two numbers together and return an int256 value, treating the second number as a signed integer.
     *
     * @param a the first number
     * @param b the second number
     * @return the result of adding the two numbers together
     */
    function sumReturnInt256(uint256 a, int256 b) internal pure returns (int256) {
        return a.toInt256() + b;
    }

    /**
     * @dev Calculates the absolute difference between two numbers.
     *
     * @param a the first number
     * @param b the second number
     * @return the absolute difference between the two numbers
     */
    function diff(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a - b : b - a;
    }

    /**
     * Adds two numbers together, the result is bounded to prevent overflows.
     *
     * @param a the first number
     * @param b the second number
     * @return the result of adding the two numbers together
     */
    function boundedAdd(int256 a, int256 b) internal pure returns (int256) {
        // if either a or b is zero or if the signs are different there should not be any overflows
        if (a == 0 || b == 0 || (a < 0 && b > 0) || (a > 0 && b < 0)) {
            return a + b;
        }

        // if adding `b` to `a` would result in a value less than the min int256 value
        // then return the min int256 value
        if (a < 0 && b <= type(int256).min - a) {
            return type(int256).min;
        }

        // if adding `b` to `a` would result in a value more than the max int256 value
        // then return the max int256 value
        if (a > 0 && b >= type(int256).max - a) {
            return type(int256).max;
        }

        return a + b;
    }

    /**
     * Returns a - b, the result is bounded to prevent overflows.
     * Note that this will revert if b is type(int256).min because of the usage of "-b".
     *
     * @param a the first number
     * @param b the second number
     * @return the bounded result of a - b
     */
    function boundedSub(int256 a, int256 b) internal pure returns (int256) {
        // if either a or b is zero or the signs are the same there should not be any overflow
        if (a == 0 || b == 0 || (a > 0 && b > 0) || (a < 0 && b < 0)) {
            return a - b;
        }

        // if adding `-b` to `a` would result in a value greater than the max int256 value
        // then return the max int256 value
        if (a > 0 && -b >= type(int256).max - a) {
            return type(int256).max;
        }

        // if subtracting `b` from `a` would result in a value less than the min int256 value
        // then return the min int256 value
        if (a < 0 && -b <= type(int256).min - a) {
            return type(int256).min;
        }

        return a - b;
    }


    /**
     * Converts the given unsigned integer to a signed integer, using the given
     * flag to determine whether the result should be positive or negative.
     *
     * @param a the unsigned integer to convert
     * @param isPositive whether the result should be positive (if true) or negative (if false)
     * @return the signed integer representation of the given unsigned integer
     */
    function toSigned(uint256 a, bool isPositive) internal pure returns (int256) {
        if (isPositive) {
            return a.toInt256();
        } else {
            return -a.toInt256();
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

/**
 * @title Cast
 * @dev Library for casting functions
 */
library Cast {
    function toBytes32(address value) internal pure returns (bytes32) {
        return bytes32(uint256(uint160(value)));
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "./ArbSys.sol";

// @title Chain
// @dev Wrap the calls to retrieve chain variables to handle differences
// between chain implementations
library Chain {
    // if the ARBITRUM_CHAIN_ID changes, a new version of this library
    // and contracts depending on it would need to be deployed
    uint256 constant public ARBITRUM_CHAIN_ID = 42161;
    uint256 constant public ARBITRUM_GOERLI_CHAIN_ID = 421613;

    ArbSys constant public arbSys = ArbSys(address(100));

    // @dev return the current block's timestamp
    // @return the current block's timestamp
    function currentTimestamp() internal view returns (uint256) {
        return block.timestamp;
    }

    // @dev return the current block's number
    // @return the current block's number
    function currentBlockNumber() internal view returns (uint256) {
        if (shouldUseArbSysValues()) {
            return arbSys.arbBlockNumber();
        }

        return block.number;
    }

    // @dev return the current block's hash
    // @return the current block's hash
    function getBlockHash(uint256 blockNumber) internal view returns (bytes32) {
        if (shouldUseArbSysValues()) {
            return arbSys.arbBlockHash(blockNumber);
        }

        return blockhash(blockNumber);
    }

    function shouldUseArbSysValues() internal view returns (bool) {
        return block.chainid == ARBITRUM_CHAIN_ID || block.chainid == ARBITRUM_GOERLI_CHAIN_ID;

    }
}

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

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "../role/RoleModule.sol";
import "../utils/Calc.sol";
import "../utils/Printer.sol";

// @title DataStore
// @dev DataStore for all general state values
contract DataStore is RoleModule {
    using SafeCast for int256;

    using EnumerableSet for EnumerableSet.Bytes32Set;
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableValues for EnumerableSet.Bytes32Set;
    using EnumerableValues for EnumerableSet.AddressSet;
    using EnumerableValues for EnumerableSet.UintSet;

    // store for uint values
    mapping(bytes32 => uint256) public uintValues;
    // store for int values
    mapping(bytes32 => int256) public intValues;
    // store for address values
    mapping(bytes32 => address) public addressValues;
    // store for bool values
    mapping(bytes32 => bool) public boolValues;
    // store for string values
    mapping(bytes32 => string) public stringValues;
    // store for bytes32 values
    mapping(bytes32 => bytes32) public bytes32Values;

    // store for uint[] values
    mapping(bytes32 => uint256[]) public uintArrayValues;
    // store for int[] values
    mapping(bytes32 => int256[]) public intArrayValues;
    // store for address[] values
    mapping(bytes32 => address[]) public addressArrayValues;
    // store for bool[] values
    mapping(bytes32 => bool[]) public boolArrayValues;
    // store for string[] values
    mapping(bytes32 => string[]) public stringArrayValues;
    // store for bytes32[] values
    mapping(bytes32 => bytes32[]) public bytes32ArrayValues;

    // store for bytes32 sets
    mapping(bytes32 => EnumerableSet.Bytes32Set) internal bytes32Sets;
    // store for address sets
    mapping(bytes32 => EnumerableSet.AddressSet) internal addressSets;
    // store for uint256 sets
    mapping(bytes32 => EnumerableSet.UintSet) internal uintSets;

    constructor(RoleStore _roleStore) RoleModule(_roleStore) {}

    // @dev get the uint value for the given key
    // @param key the key of the value
    // @return the uint value for the key
    function getUint(bytes32 key) external view returns (uint256) {
        return uintValues[key];
    }

    // @dev set the uint value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the uint value for the key
    function setUint(bytes32 key, uint256 value) external onlyController returns (uint256) {
        uintValues[key] = value;
        return value;
    }

    // @dev delete the uint value for the given key
    // @param key the key of the value
    function removeUint(bytes32 key) external onlyController {
        delete uintValues[key];
    }

    // @dev add the input int value to the existing uint value
    // @param key the key of the value
    // @param value the input int value
    // @return the new uint value
    function applyDeltaToUint(bytes32 key, int256 value, string memory errorMessage) external onlyController returns (uint256) {
        uint256 currValue = uintValues[key];
        if (value < 0 && (-value).toUint256() > currValue) {
            revert(errorMessage);
        }
        uint256 nextUint = Calc.sumReturnUint256(currValue, value);
        uintValues[key] = nextUint;
        return nextUint;
    }

    // @dev add the input uint value to the existing uint value
    // @param key the key of the value
    // @param value the input int value
    // @return the new uint value
    function applyDeltaToUint(bytes32 key, uint256 value) external onlyController returns (uint256) {
        uint256 currValue = uintValues[key];
        uint256 nextUint = currValue + value;
        uintValues[key] = nextUint;
        return nextUint;
    }

    // @dev add the input int value to the existing uint value, prevent the uint
    // value from becoming negative
    // @param key the key of the value
    // @param value the input int value
    // @return the new uint value
    function applyBoundedDeltaToUint(bytes32 key, int256 value) external onlyController returns (uint256) {
        uint256 uintValue = uintValues[key];
        if (value < 0 && (-value).toUint256() > uintValue) {
            uintValues[key] = 0;
            return 0;
        }

        uint256 nextUint = Calc.sumReturnUint256(uintValue, value);
        uintValues[key] = nextUint;
        return nextUint;
    }

    // @dev add the input uint value to the existing uint value
    // @param key the key of the value
    // @param value the input uint value
    // @return the new uint value
    function incrementUint(bytes32 key, uint256 value) external onlyController returns (uint256) {
        uint256 nextUint = uintValues[key] + value;
        uintValues[key] = nextUint;
        return nextUint;
    }

    // @dev subtract the input uint value from the existing uint value
    // @param key the key of the value
    // @param value the input uint value
    // @return the new uint value
    function decrementUint(bytes32 key, uint256 value) external onlyController returns (uint256) {
        uint256 nextUint = uintValues[key] - value;
        uintValues[key] = nextUint;
        return nextUint;
    }

    // @dev get the int value for the given key
    // @param key the key of the value
    // @return the int value for the key
    function getInt(bytes32 key) external view returns (int256) {
        return intValues[key];
    }

    // @dev set the int value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the int value for the key
    function setInt(bytes32 key, int256 value) external onlyController returns (int256) {
        intValues[key] = value;
        return value;
    }

    function removeInt(bytes32 key) external onlyController {
        delete intValues[key];
    }

    // @dev add the input int value to the existing int value
    // @param key the key of the value
    // @param value the input int value
    // @return the new int value
    function applyDeltaToInt(bytes32 key, int256 value) external onlyController returns (int256) {
        int256 nextInt = intValues[key] + value;
        intValues[key] = nextInt;
        return nextInt;
    }

    // @dev add the input int value to the existing int value
    // @param key the key of the value
    // @param value the input int value
    // @return the new int value
    function incrementInt(bytes32 key, int256 value) external onlyController returns (int256) {
        int256 nextInt = intValues[key] + value;
        intValues[key] = nextInt;
        return nextInt;
    }

    // @dev subtract the input int value from the existing int value
    // @param key the key of the value
    // @param value the input int value
    // @return the new int value
    function decrementInt(bytes32 key, int256 value) external onlyController returns (int256) {
        int256 nextInt = intValues[key] - value;
        intValues[key] = nextInt;
        return nextInt;
    }

    // @dev get the address value for the given key
    // @param key the key of the value
    // @return the address value for the key
    function getAddress(bytes32 key) external view returns (address) {
        return addressValues[key];
    }

    // @dev set the address value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the address value for the key
    function setAddress(bytes32 key, address value) external onlyController returns (address) {
        addressValues[key] = value;
        return value;
    }

    // @dev delete the address value for the given key
    // @param key the key of the value
    function removeAddress(bytes32 key) external onlyController {
        delete addressValues[key];
    }

    // @dev get the bool value for the given key
    // @param key the key of the value
    // @return the bool value for the key
    function getBool(bytes32 key) external view returns (bool) {
        return boolValues[key];
    }

    // @dev set the bool value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the bool value for the key
    function setBool(bytes32 key, bool value) external onlyController returns (bool) {
        boolValues[key] = value;
        return value;
    }

    // @dev delete the bool value for the given key
    // @param key the key of the value
    function removeBool(bytes32 key) external onlyController {
        delete boolValues[key];
    }

    // @dev get the string value for the given key
    // @param key the key of the value
    // @return the string value for the key
    function getString(bytes32 key) external view returns (string memory) {
        return stringValues[key];
    }

    // @dev set the string value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the string value for the key
    function setString(bytes32 key, string memory value) external onlyController returns (string memory) {
        stringValues[key] = value;
        return value;
    }

    // @dev delete the string value for the given key
    // @param key the key of the value
    function removeString(bytes32 key) external onlyController {
        delete stringValues[key];
    }

    // @dev get the bytes32 value for the given key
    // @param key the key of the value
    // @return the bytes32 value for the key
    function getBytes32(bytes32 key) external view returns (bytes32) {
        return bytes32Values[key];
    }

    // @dev set the bytes32 value for the given key
    // @param key the key of the value
    // @param value the value to set
    // @return the bytes32 value for the key
    function setBytes32(bytes32 key, bytes32 value) external onlyController returns (bytes32) {
        bytes32Values[key] = value;
        return value;
    }

    // @dev delete the bytes32 value for the given key
    // @param key the key of the value
    function removeBytes32(bytes32 key) external onlyController {
        delete bytes32Values[key];
    }

    // @dev get the uint array for the given key
    // @param key the key of the uint array
    // @return the uint array for the key
    function getUintArray(bytes32 key) external view returns (uint256[] memory) {
        return uintArrayValues[key];
    }

    // @dev set the uint array for the given key
    // @param key the key of the uint array
    // @param value the value of the uint array
    function setUintArray(bytes32 key, uint256[] memory value) external onlyController {
        uintArrayValues[key] = value;
    }

    // @dev delete the uint array for the given key
    // @param key the key of the uint array
    // @param value the value of the uint array
    function removeUintArray(bytes32 key) external onlyController {
        delete uintArrayValues[key];
    }

    // @dev get the int array for the given key
    // @param key the key of the int array
    // @return the int array for the key
    function getIntArray(bytes32 key) external view returns (int256[] memory) {
        return intArrayValues[key];
    }

    // @dev set the int array for the given key
    // @param key the key of the int array
    // @param value the value of the int array
    function setIntArray(bytes32 key, int256[] memory value) external onlyController {
        intArrayValues[key] = value;
    }

    // @dev delete the int array for the given key
    // @param key the key of the int array
    // @param value the value of the int array
    function removeIntArray(bytes32 key) external onlyController {
        delete intArrayValues[key];
    }

    // @dev get the address array for the given key
    // @param key the key of the address array
    // @return the address array for the key
    function getAddressArray(bytes32 key) external view returns (address[] memory) {
        return addressArrayValues[key];
    }

    // @dev set the address array for the given key
    // @param key the key of the address array
    // @param value the value of the address array
    function setAddressArray(bytes32 key, address[] memory value) external onlyController {
        addressArrayValues[key] = value;
    }

    // @dev delete the address array for the given key
    // @param key the key of the address array
    // @param value the value of the address array
    function removeAddressArray(bytes32 key) external onlyController {
        delete addressArrayValues[key];
    }

    // @dev get the bool array for the given key
    // @param key the key of the bool array
    // @return the bool array for the key
    function getBoolArray(bytes32 key) external view returns (bool[] memory) {
        return boolArrayValues[key];
    }

    // @dev set the bool array for the given key
    // @param key the key of the bool array
    // @param value the value of the bool array
    function setBoolArray(bytes32 key, bool[] memory value) external onlyController {
        boolArrayValues[key] = value;
    }

    // @dev delete the bool array for the given key
    // @param key the key of the bool array
    // @param value the value of the bool array
    function removeBoolArray(bytes32 key) external onlyController {
        delete boolArrayValues[key];
    }

    // @dev get the string array for the given key
    // @param key the key of the string array
    // @return the string array for the key
    function getStringArray(bytes32 key) external view returns (string[] memory) {
        return stringArrayValues[key];
    }

    // @dev set the string array for the given key
    // @param key the key of the string array
    // @param value the value of the string array
    function setStringArray(bytes32 key, string[] memory value) external onlyController {
        stringArrayValues[key] = value;
    }

    // @dev delete the string array for the given key
    // @param key the key of the string array
    // @param value the value of the string array
    function removeStringArray(bytes32 key) external onlyController {
        delete stringArrayValues[key];
    }

    // @dev get the bytes32 array for the given key
    // @param key the key of the bytes32 array
    // @return the bytes32 array for the key
    function getBytes32Array(bytes32 key) external view returns (bytes32[] memory) {
        return bytes32ArrayValues[key];
    }

    // @dev set the bytes32 array for the given key
    // @param key the key of the bytes32 array
    // @param value the value of the bytes32 array
    function setBytes32Array(bytes32 key, bytes32[] memory value) external onlyController {
        bytes32ArrayValues[key] = value;
    }

    // @dev delete the bytes32 array for the given key
    // @param key the key of the bytes32 array
    // @param value the value of the bytes32 array
    function removeBytes32Array(bytes32 key) external onlyController {
        delete bytes32ArrayValues[key];
    }

    // @dev check whether the given value exists in the set
    // @param setKey the key of the set
    // @param value the value to check
    function containsBytes32(bytes32 setKey, bytes32 value) external view returns (bool) {
        return bytes32Sets[setKey].contains(value);
    }

    // @dev get the length of the set
    // @param setKey the key of the set
    function getBytes32Count(bytes32 setKey) external view returns (uint256) {
        return bytes32Sets[setKey].length();
    }

    // @dev get the values of the set in the given range
    // @param setKey the key of the set
    // @param the start of the range, values at the start index will be returned
    // in the result
    // @param the end of the range, values at the end index will not be returned
    // in the result
    function getBytes32ValuesAt(bytes32 setKey, uint256 start, uint256 end) external view returns (bytes32[] memory) {
        return bytes32Sets[setKey].valuesAt(start, end);
    }

    // @dev add the given value to the set
    // @param setKey the key of the set
    // @param value the value to add
    function addBytes32(bytes32 setKey, bytes32 value) external onlyController {
        bytes32Sets[setKey].add(value);
    }

    // @dev remove the given value from the set
    // @param setKey the key of the set
    // @param value the value to remove
    function removeBytes32(bytes32 setKey, bytes32 value) external onlyController {
        bytes32Sets[setKey].remove(value);
    }

    // @dev check whether the given value exists in the set
    // @param setKey the key of the set
    // @param value the value to check
    function containsAddress(bytes32 setKey, address value) external view returns (bool) {
        return addressSets[setKey].contains(value);
    }

    // @dev get the length of the set
    // @param setKey the key of the set
    function getAddressCount(bytes32 setKey) external view returns (uint256) {
        return addressSets[setKey].length();
    }

    // @dev get the values of the set in the given range
    // @param setKey the key of the set
    // @param the start of the range, values at the start index will be returned
    // in the result
    // @param the end of the range, values at the end index will not be returned
    // in the result
    function getAddressValuesAt(bytes32 setKey, uint256 start, uint256 end) external view returns (address[] memory) {
        return addressSets[setKey].valuesAt(start, end);
    }

    // @dev add the given value to the set
    // @param setKey the key of the set
    // @param value the value to add
    function addAddress(bytes32 setKey, address value) external onlyController {
        addressSets[setKey].add(value);
    }

    // @dev remove the given value from the set
    // @param setKey the key of the set
    // @param value the value to remove
    function removeAddress(bytes32 setKey, address value) external onlyController {
        addressSets[setKey].remove(value);
    }

    // @dev check whether the given value exists in the set
    // @param setKey the key of the set
    // @param value the value to check
    function containsUint(bytes32 setKey, uint256 value) external view returns (bool) {
        return uintSets[setKey].contains(value);
    }

    // @dev get the length of the set
    // @param setKey the key of the set
    function getUintCount(bytes32 setKey) external view returns (uint256) {
        return uintSets[setKey].length();
    }

    // @dev get the values of the set in the given range
    // @param setKey the key of the set
    // @param the start of the range, values at the start index will be returned
    // in the result
    // @param the end of the range, values at the end index will not be returned
    // in the result
    function getUintValuesAt(bytes32 setKey, uint256 start, uint256 end) external view returns (uint256[] memory) {
        return uintSets[setKey].valuesAt(start, end);
    }

    // @dev add the given value to the set
    // @param setKey the key of the set
    // @param value the value to add
    function addUint(bytes32 setKey, uint256 value) external onlyController {
        uintSets[setKey].add(value);
    }

    // @dev remove the given value from the set
    // @param setKey the key of the set
    // @param value the value to remove
    function removeUint(bytes32 setKey, uint256 value) external onlyController {
        uintSets[setKey].remove(value);
    }
}