S Price: $0.494346 (+9.60%)
    /

    Contract Diff Checker

    Contract Name:
    AutoLeverager

    Contract Source Code:

    // SPDX-License-Identifier: BUSL-1.1
    pragma solidity ^0.8.10;
    
    import {AggregatorInterface} from "AggregatorInterface.sol";
    import {IERC20} from "IERC20.sol";
    import {SafeERC20} from "SafeERC20.sol";
    import {IPyth, Price} from "IPyth.sol";
    import {Ownable} from "Ownable.sol";
    import {IPeggedOracle} from "IPeggedOracle.sol";
    import {IICHIVault} from "IICHIVault.sol";
    import {IPool} from "IPool.sol";
    import {IBeefyVault} from "IBeefyVault.sol";
    
    /**
     * @title Autoleverager
     * @author Your Name
     * @notice This contract automates leveraged positions in AAVE markets using ICHI vaults and Beefy vaults
     * @dev Uses flash loans to achieve leverage and handles the complete flow of leverage deposit
     */
    contract AutoLeverager is Ownable {
        event Log(uint256);
        event LogWLabel(string, uint256);
        using SafeERC20 for IERC20;
    
        /// @notice Router used for token swaps
        address public odosRouter;
    
        /// @notice Address that receives fees
        address public feeReceiver;
    
        /// @notice Fee percentage (10000 = 100%)
        uint256 public fee;
    
        /// @notice Main pool for supply and borrow operations
        IPool public pool;
    
        /// @notice Pool used for flash loans
        IPool public borrowPool;
    
        /// @notice Emitted when a leveraged deposit is completed
        event LeverageDeposited(
            address indexed user,
            address depositAsset,
            address borrowAsset,
            uint256 initialAmount,
            address ichiVault,
            address vicunaVault
        );
    
        /// @notice Emitted when the fee percentage is updated
        event FeeUpdated(uint256 oldFee, uint256 newFee);
    
        /// @notice Emitted when a contract parameter is updated
        event ParameterUpdated(string paramName, address oldValue, address newValue);
    
        /// @notice Emitted when tokens are rescued in an emergency
        event TokensRescued(address indexed token, address indexed recipient, uint256 amount);
    
        /**
         * @notice Constructor to initialize the Autoleverager contract
         * @param _odosRouter Address of the ODOS router for swaps
         * @param _pool Address of the main pool for supply/borrow
         * @param _borrowPool Address of the pool for flash loans
         * @param _feeReceiver Address that will receive fees
         */
        constructor(address _odosRouter, address _pool, address _borrowPool, address _feeReceiver) {
            odosRouter = _odosRouter;
            pool = IPool(_pool);
            borrowPool = IPool(_borrowPool);
            feeReceiver = _feeReceiver;
        }
    
        /**
         * @notice Sets the fee percentage
         * @param _fee New fee percentage (10000 = 100%)
         */
        function setFee(uint256 _fee) external onlyOwner {
            require(_fee <= 10000, "Fee too high");
            uint256 oldFee = fee;
            fee = _fee;
            emit FeeUpdated(oldFee, _fee);
        }
    
        /**
         * @notice Sets the ODOS router address
         * @param _odosRouter New router address
         */
        function setOdosRouter(address _odosRouter) external onlyOwner {
            require(_odosRouter != address(0), "Invalid address");
            address oldRouter = odosRouter;
            odosRouter = _odosRouter;
            emit ParameterUpdated("odosRouter", oldRouter, _odosRouter);
        }
    
        /**
         * @notice Sets the main pool address
         * @param _pool New pool address
         */
        function setPool(address _pool) external onlyOwner {
            require(_pool != address(0), "Invalid address");
            address oldPool = address(pool);
            pool = IPool(_pool);
            emit ParameterUpdated("pool", oldPool, _pool);
        }
    
        /**
         * @notice Sets the borrow pool address used for flash loans
         * @param _borrowPool New borrow pool address
         */
        function setBorrowPool(address _borrowPool) external onlyOwner {
            require(_borrowPool != address(0), "Invalid address");
            address oldBorrowPool = address(borrowPool);
            borrowPool = IPool(_borrowPool);
            emit ParameterUpdated("borrowPool", oldBorrowPool, _borrowPool);
        }
    
        /**
         * @notice Sets the fee receiver address
         * @param _feeReceiver New fee receiver address
         */
        function setFeeReceiver(address _feeReceiver) external onlyOwner {
            require(_feeReceiver != address(0), "Invalid address");
            address oldFeeReceiver = feeReceiver;
            feeReceiver = _feeReceiver;
            emit ParameterUpdated("feeReceiver", oldFeeReceiver, _feeReceiver);
        }
    
        /**
         * @notice Helper function to get token decimals
         * @param token Address of the token
         * @return uint8 Token decimals
         */
        function getDecimals(address token) internal view returns (uint8) {
            (bool success, bytes memory data) = token.staticcall(abi.encodeWithSignature("decimals()"));
            require(success, "Failed to get decimals");
            return abi.decode(data, (uint8));
        }
    
        /**
         * @notice Converts amount from one token's decimals to another
         * @param amount Amount to convert
         * @param fromDecimals Source token decimals
         * @param toDecimals Target token decimals
         * @return Converted amount
         */
        function convertDecimals(
            uint256 amount,
            uint8 fromDecimals,
            uint8 toDecimals
        ) internal pure returns (uint256) {
            if (fromDecimals == toDecimals) {
                return amount;
            } else if (fromDecimals > toDecimals) {
                return amount / (10 ** (fromDecimals - toDecimals));
            } else {
                return amount * (10 ** (toDecimals - fromDecimals));
            }
        }
    
        struct DepositData {
            InputDepositData inputData;
            uint256 initialAmountAfterFee;
            address sender;
            address vaultDepositAsset;
        }
        struct InputDepositData {
            address depositAsset;
            address borrowAsset;
            uint256 initialAmount;
            uint256 borrowAmount;
            address vicunaVault;
            bytes swapParams;
        }
    
        /**
         * @notice Creates a leveraged position using flash loans
         */
        function leverageDeposit(InputDepositData calldata inputParameters) external {
            DepositData memory depositParams;
            depositParams.sender = msg.sender;
            depositParams.inputData = inputParameters;
    
            address ichiVault = IBeefyVault(inputParameters.vicunaVault).want();
            {
                address token0 = IICHIVault(ichiVault).token0();
                address token1 = IICHIVault(ichiVault).token1();
    
                depositParams.vaultDepositAsset = IICHIVault(ichiVault).allowToken0() ? token0 : token1;
    
                require(
                    inputParameters.depositAsset == depositParams.vaultDepositAsset ||
                        inputParameters.depositAsset == inputParameters.borrowAsset || depositParams.vaultDepositAsset == inputParameters.borrowAsset,
                    "Invalid deposit/borrow asset"
                );
    
            
                require(
                    inputParameters.borrowAmount > 0,
                    "BorrowAmount should be positive"
                );
            }
    
            IERC20(inputParameters.depositAsset).safeTransferFrom(
                msg.sender,
                address(this),
                inputParameters.initialAmount
            );
    
            // Calculate and transfer fee
            uint256 feeAmount = (inputParameters.initialAmount * fee) / 10000;
            if (feeAmount > 0) {
                IERC20(inputParameters.depositAsset).safeTransfer(feeReceiver, feeAmount);
            }
    
            depositParams.initialAmountAfterFee = inputParameters.initialAmount - feeAmount;
            uint256 neededToFlash = inputParameters.borrowAmount;
    
            bytes memory params = abi.encode(depositParams);
    
            // Borrow the asset needed to deposit in the vault
            address[] memory assets = new address[](1);
            assets[0] = inputParameters.borrowAsset;
            uint256[] memory amounts = new uint256[](1);
            amounts[0] = neededToFlash;
            uint256[] memory modes = new uint256[](1);
            modes[0] = 0;
            borrowPool.flashLoan(address(this), assets, amounts, modes, address(this), params, 0);
    
            emit LogWLabel("Flash", neededToFlash);
            emit LeverageDeposited(
                msg.sender,
                inputParameters.depositAsset,
                inputParameters.borrowAsset,
                inputParameters.initialAmount,
                ichiVault,
                inputParameters.vicunaVault
            );
        }
    
        /**
         * @notice Flash loan callback function
         * @param assets Assets received from flash loan
         * @param amounts Amounts of flash loaned assets
         * @param params Encoded parameters
         * @return success True if the operation was successful
         */
        function executeOperation(
            address[] calldata assets,
            uint256[] calldata amounts,
            uint256[] calldata,
            address,
            bytes calldata params
        ) external returns (bool) {
            require(msg.sender == address(borrowPool), "Only borrowPool can call this function");
    
            DepositData memory depositData = abi.decode(params, (DepositData));
            address vaultDepositAsset = depositData.vaultDepositAsset;
            address flashLoanAsset = assets[0];
            uint256 flashLoanAmount = amounts[0];
            // uint256 premium = premiums[0];
    
            uint256 depositAmount;
            if (depositData.inputData.depositAsset == vaultDepositAsset) {
                // If depositAsset is the same as vaultDepositAsset, use both the flash loan amount and user deposit
                depositAmount += depositData.initialAmountAfterFee;
            } 
            if (vaultDepositAsset == flashLoanAsset) {
                // If depositAsset is different from vaultDepositAsset, use only the flash loan amount
                depositAmount += flashLoanAmount;
            }
    
            uint256 swapAmountoutput;
            if (flashLoanAsset != vaultDepositAsset) {
                // Swap flash loaned asset to vault deposit asset
                // Approve the full amount needed for the swap
                IERC20(flashLoanAsset).safeApprove(odosRouter, type(uint256).max);
                uint256 beforeBalance = IERC20(vaultDepositAsset).balanceOf(address(this));
                // Execute the swap
                (bool success, ) = odosRouter.call(depositData.inputData.swapParams);
                require(success, "Swap failed");
                swapAmountoutput = IERC20(vaultDepositAsset).balanceOf(address(this)) - beforeBalance;
            } else if (flashLoanAsset == vaultDepositAsset && depositData.inputData.depositAsset != vaultDepositAsset) {
                IERC20(depositData.inputData.depositAsset).safeApprove(odosRouter, depositData.initialAmountAfterFee);
                uint256 beforeBalance = IERC20(vaultDepositAsset).balanceOf(address(this));
    
                (bool success, ) = odosRouter.call(depositData.inputData.swapParams);
                require(success, "Swap failed");
                swapAmountoutput = IERC20(vaultDepositAsset).balanceOf(address(this)) - beforeBalance;
            }
            depositAmount += swapAmountoutput;
    
            IICHIVault ichiVault = IICHIVault(IBeefyVault(depositData.inputData.vicunaVault).want());
            bool isToken0 = ichiVault.token0() == vaultDepositAsset;
            // Deposit into ICHI vault
            IERC20(vaultDepositAsset).safeApprove(address(ichiVault), depositAmount);
            IICHIVault(ichiVault).deposit(
                isToken0 ? depositAmount : 0,
                isToken0 ? 0 : depositAmount,
                address(this)
            );
    
            // Deposit ICHI LP tokens into Beefy vault
            uint256 ichiBalance = IERC20(address(ichiVault)).balanceOf(address(this));
            IERC20(address(ichiVault)).safeApprove(depositData.inputData.vicunaVault, ichiBalance);
            IBeefyVault(depositData.inputData.vicunaVault).deposit(ichiBalance);
    
            // Supply Beefy vault tokens to Aave
            uint256 vaultBalance = IERC20(depositData.inputData.vicunaVault).balanceOf(address(this));
            IERC20(depositData.inputData.vicunaVault).safeApprove(address(pool), vaultBalance);
            pool.supply(depositData.inputData.vicunaVault, vaultBalance, depositData.sender, 0);
    
    
            // Borrow from Aave
            pool.borrow(
                depositData.inputData.borrowAsset,
                flashLoanAmount,
                2,
                0,
                depositData.sender
            );
    
    
            // Approve and repay flash loan
            IERC20(flashLoanAsset).safeApprove(address(borrowPool), flashLoanAmount);
            return true;
        }
    
        /**
         * @notice Rescues tokens accidentally sent to the contract
         * @param token Address of the token to rescue
         * @param to Address to send the tokens to
         * @param amount Amount of tokens to rescue
         */
        function rescueTokens(address token, address to, uint256 amount) external onlyOwner {
            require(to != address(0), "Cannot send to zero address");
    
            IERC20(token).safeTransfer(to, amount);
    
            emit TokensRescued(token, to, amount);
        }
    
        /**
         * @notice Rescues ETH accidentally sent to the contract
         * @param to Address to send the ETH to
         * @param amount Amount of ETH to rescue
         */
        function rescueETH(address payable to, uint256 amount) external onlyOwner {
            require(to != address(0), "Cannot send to zero address");
            require(address(this).balance >= amount, "Insufficient ETH balance");
    
            (bool success, ) = to.call{value: amount}("");
            require(success, "ETH transfer failed");
    
            emit TokensRescued(address(0), to, amount);
        }
    
        /**
         * @notice Allows the contract to receive ETH
         */
        receive() external payable {}
    }

    // SPDX-License-Identifier: MIT
    // Chainlink Contracts v0.8
    pragma solidity ^0.8.0;
    
    interface AggregatorInterface {
      function latestAnswer() external view returns (int256);
    
      function latestTimestamp() external view returns (uint256);
    
      function latestRound() external view returns (uint256);
    
      function getAnswer(uint256 roundId) external view returns (int256);
    
      function getTimestamp(uint256 roundId) external view returns (uint256);
    
      function decimals() external view returns (uint8);
    
      event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);
    
      event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    /**
     * @dev Interface of the ERC20 standard as defined in the EIP.
     */
    interface IERC20 {
      /**
       * @dev Returns the amount of tokens in existence.
       */
      function totalSupply() external view returns (uint256);
    
      /**
       * @dev Returns the amount of tokens owned by `account`.
       */
      function balanceOf(address account) external view returns (uint256);
    
      /**
       * @dev Moves `amount` tokens from the caller's account to `recipient`.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transfer(address recipient, uint256 amount) external returns (bool);
    
      /**
       * @dev Returns the remaining number of tokens that `spender` will be
       * allowed to spend on behalf of `owner` through {transferFrom}. This is
       * zero by default.
       *
       * This value changes when {approve} or {transferFrom} are called.
       */
      function allowance(address owner, address spender) external view returns (uint256);
    
      /**
       * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * IMPORTANT: Beware that changing an allowance with this method brings the risk
       * that someone may use both the old and the new allowance by unfortunate
       * transaction ordering. One possible solution to mitigate this race
       * condition is to first reduce the spender's allowance to 0 and set the
       * desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       *
       * Emits an {Approval} event.
       */
      function approve(address spender, uint256 amount) external returns (bool);
    
      /**
       * @dev Moves `amount` tokens from `sender` to `recipient` using the
       * allowance mechanism. `amount` is then deducted from the caller's
       * allowance.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    
      /**
       * @dev Emitted when `value` tokens are moved from one account (`from`) to
       * another (`to`).
       *
       * Note that `value` may be zero.
       */
      event Transfer(address indexed from, address indexed to, uint256 value);
    
      /**
       * @dev Emitted when the allowance of a `spender` for an `owner` is set by
       * a call to {approve}. `value` is the new allowance.
       */
      event Approval(address indexed owner, address indexed spender, uint256 value);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
    
    pragma solidity ^0.8.0;
    
    import "IERC20.sol";
    import "Address.sol";
    
    /**
     * @title SafeERC20
     * @dev Wrappers around ERC20 operations that throw on failure (when the token
     * contract returns false). Tokens that return no value (and instead revert or
     * throw on failure) are also supported, non-reverting calls are assumed to be
     * successful.
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
     */
    library SafeERC20 {
      using Address for address;
    
      function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
      }
    
      function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(
          token,
          abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
      }
    
      /**
       * @dev Deprecated. This function has issues similar to the ones found in
       * {IERC20-approve}, and its usage is discouraged.
       *
       * Whenever possible, use {safeIncreaseAllowance} and
       * {safeDecreaseAllowance} instead.
       */
      function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
          (value == 0) || (token.allowance(address(this), spender) == 0),
          'SafeERC20: approve from non-zero to non-zero allowance'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
      }
    
      function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
          token,
          abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
      }
    
      function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
          uint256 oldAllowance = token.allowance(address(this), spender);
          require(oldAllowance >= value, 'SafeERC20: decreased allowance below zero');
          uint256 newAllowance = oldAllowance - value;
          _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
          );
        }
      }
    
      /**
       * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
       * on the return value: the return value is optional (but if data is returned, it must not be false).
       * @param token The token targeted by the call.
       * @param data The call data (encoded using abi.encode or one of its variants).
       */
      function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.
    
        bytes memory returndata = address(token).functionCall(data, 'SafeERC20: low-level call failed');
        if (returndata.length > 0) {
          // Return data is optional
          require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
        }
      }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
    
    pragma solidity ^0.8.0;
    
    /**
     * @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
       * ====
       */
      function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.
    
        uint256 size;
        assembly {
          size := extcodesize(account)
        }
        return size > 0;
      }
    
      /**
       * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
       * `recipient`, forwarding all available gas and reverting on errors.
       *
       * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
       * of certain opcodes, possibly making contracts go over the 2300 gas limit
       * imposed by `transfer`, making them unable to receive funds via
       * `transfer`. {sendValue} removes this limitation.
       *
       * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
       *
       * IMPORTANT: because control is transferred to `recipient`, care must be
       * taken to not create reentrancy vulnerabilities. Consider using
       * {ReentrancyGuard} or the
       * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
       */
      function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, 'Address: insufficient balance');
    
        (bool success, ) = recipient.call{value: amount}('');
        require(success, 'Address: unable to send value, recipient may have reverted');
      }
    
      /**
       * @dev Performs a Solidity function call using a low level `call`. A
       * plain `call` is an unsafe replacement for a function call: use this
       * function instead.
       *
       * If `target` reverts with a revert reason, it is bubbled up by this
       * function (like regular Solidity function calls).
       *
       * Returns the raw returned data. To convert to the expected return value,
       * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
       *
       * Requirements:
       *
       * - `target` must be a contract.
       * - calling `target` with `data` must not revert.
       *
       * _Available since v3.1._
       */
      function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, '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');
        require(isContract(target), 'Address: call to non-contract');
    
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), 'Address: static call to non-contract');
    
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), 'Address: delegate call to non-contract');
    
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
      }
    
      /**
       * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
       * revert reason 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 {
          // 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
    
            assembly {
              let returndata_size := mload(returndata)
              revert(add(32, returndata), returndata_size)
            }
          } else {
            revert(errorMessage);
          }
        }
      }
    }

    pragma solidity ^0.8.10;
    
    
    struct Price {
        // Price
        int64 price;
        // Confidence interval
        uint64 conf;
        // Price exponent
        int32 expo;
        // Unix timestamp describing when the price was published
        uint publishTime;
    }
    
    interface IPyth {
        function getPrice(bytes32 priceId) external view returns (Price memory);
        function getEmaPrice(bytes32 priceId) external view returns (Price memory);
        function getPriceUnsafe(bytes32 priceId) external view returns (Price memory);
        function getUpdateFee(bytes[] calldata priceUpdateData) external view returns (uint256);
        function updatePriceFeeds(bytes[] calldata priceUpdateData) external payable;
        function getPriceNoOlderThan(
            bytes32 id,
            uint age
        ) external view returns (Price memory price);
    }

    // SPDX-License-Identifier: MIT
    
    pragma solidity ^0.8.0;
    
    import "Context.sol";
    
    /**
     * @dev Contract module which provides a basic access control mechanism, where
     * there is an account (an owner) that can be granted exclusive access to
     * specific functions.
     *
     * By default, the owner account will be the one that deploys the contract. This
     * can later be changed with {transferOwnership}.
     *
     * This module is used through inheritance. It will make available the modifier
     * `onlyOwner`, which can be applied to your functions to restrict their use to
     * the owner.
     */
    contract Ownable is Context {
      address private _owner;
    
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
      /**
       * @dev Initializes the contract setting the deployer as the initial owner.
       */
      constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
      }
    
      /**
       * @dev Returns the address of the current owner.
       */
      function owner() public view returns (address) {
        return _owner;
      }
    
      /**
       * @dev Throws if called by any account other than the owner.
       */
      modifier onlyOwner() {
        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
        _;
      }
    
      /**
       * @dev Leaves the contract without owner. It will not be possible to call
       * `onlyOwner` functions anymore. Can only be called by the current owner.
       *
       * NOTE: Renouncing ownership will leave the contract without an owner,
       * thereby removing any functionality that is only available to the owner.
       */
      function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
      }
    
      /**
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
       * Can only be called by the current owner.
       */
      function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
      }
    }

    // SPDX-License-Identifier: MIT
    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 GSN 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 payable) {
        return payable(msg.sender);
      }
    
      function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
      }
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    
    
    
    interface IPeggedOracle {
        function decimals() external view returns (uint8);
        function latestAnswer() external view returns (int256);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    interface IICHIVault {
        /**
         * @notice Gets total supply of LP tokens
         * @return Total supply of LP tokens
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @notice Gets the address of token0
         * @return Address of token0
         */
        function token0() external view returns (address);
    
        /**
         * @notice Gets the address of token1
         * @return Address of token1
         */
        function token1() external view returns (address);
    
        /**
         * @notice Calculates total quantity of token0 and token1 in both positions (and unused in the ICHIVault)
         * @return total0 Quantity of token0 in both positions (and unused in the ICHIVault)
         * @return total1 Quantity of token1 in both positions (and unused in the ICHIVault)
         */
        function getTotalAmounts() external view returns (uint256 total0, uint256 total1);
    
        function allowToken0() external view returns(bool);
        function allowToken1() external view returns(bool);
        function deposit(uint256 amount0, uint256 amount1, address to) external returns(uint256 shares);
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    import {IPoolAddressesProvider} from "IPoolAddressesProvider.sol";
    import {DataTypes} from "DataTypes.sol";
    
    /**
     * @title IPool
     * @author Aave
     * @notice Defines the basic interface for an Aave Pool.
     */
    interface IPool {
      /**
       * @dev Emitted on mintUnbacked()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address initiating the supply
       * @param onBehalfOf The beneficiary of the supplied assets, receiving the aTokens
       * @param amount The amount of supplied assets
       * @param referralCode The referral code used
       */
      event MintUnbacked(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on backUnbacked()
       * @param reserve The address of the underlying asset of the reserve
       * @param backer The address paying for the backing
       * @param amount The amount added as backing
       * @param fee The amount paid in fees
       */
      event BackUnbacked(address indexed reserve, address indexed backer, uint256 amount, uint256 fee);
    
      /**
       * @dev Emitted on supply()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address initiating the supply
       * @param onBehalfOf The beneficiary of the supply, receiving the aTokens
       * @param amount The amount supplied
       * @param referralCode The referral code used
       */
      event Supply(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on withdraw()
       * @param reserve The address of the underlying asset being withdrawn
       * @param user The address initiating the withdrawal, owner of aTokens
       * @param to The address that will receive the underlying
       * @param amount The amount to be withdrawn
       */
      event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
    
      /**
       * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
       * @param reserve The address of the underlying asset being borrowed
       * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
       * initiator of the transaction on flashLoan()
       * @param onBehalfOf The address that will be getting the debt
       * @param amount The amount borrowed out
       * @param interestRateMode The rate mode: 1 for Stable, 2 for Variable
       * @param borrowRate The numeric rate at which the user has borrowed, expressed in ray
       * @param referralCode The referral code used
       */
      event Borrow(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 borrowRate,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on repay()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The beneficiary of the repayment, getting his debt reduced
       * @param repayer The address of the user initiating the repay(), providing the funds
       * @param amount The amount repaid
       * @param useATokens True if the repayment is done using aTokens, `false` if done with underlying asset directly
       */
      event Repay(
        address indexed reserve,
        address indexed user,
        address indexed repayer,
        uint256 amount,
        bool useATokens
      );
    
      /**
       * @dev Emitted on swapBorrowRateMode()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user swapping his rate mode
       * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
       */
      event SwapBorrowRateMode(
        address indexed reserve,
        address indexed user,
        DataTypes.InterestRateMode interestRateMode
      );
    
      /**
       * @dev Emitted on borrow(), repay() and liquidationCall() when using isolated assets
       * @param asset The address of the underlying asset of the reserve
       * @param totalDebt The total isolation mode debt for the reserve
       */
      event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);
    
      /**
       * @dev Emitted when the user selects a certain asset category for eMode
       * @param user The address of the user
       * @param categoryId The category id
       */
      event UserEModeSet(address indexed user, uint8 categoryId);
    
      /**
       * @dev Emitted on setUserUseReserveAsCollateral()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user enabling the usage as collateral
       */
      event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on setUserUseReserveAsCollateral()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user enabling the usage as collateral
       */
      event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on rebalanceStableBorrowRate()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user for which the rebalance has been executed
       */
      event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on flashLoan()
       * @param target The address of the flash loan receiver contract
       * @param initiator The address initiating the flash loan
       * @param asset The address of the asset being flash borrowed
       * @param amount The amount flash borrowed
       * @param interestRateMode The flashloan mode: 0 for regular flashloan, 1 for Stable debt, 2 for Variable debt
       * @param premium The fee flash borrowed
       * @param referralCode The referral code used
       */
      event FlashLoan(
        address indexed target,
        address initiator,
        address indexed asset,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 premium,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted when a borrower is liquidated.
       * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
       * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
       * @param user The address of the borrower getting liquidated
       * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
       * @param liquidatedCollateralAmount The amount of collateral received by the liquidator
       * @param liquidator The address of the liquidator
       * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
       * to receive the underlying collateral asset directly
       */
      event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateralAmount,
        address liquidator,
        bool receiveAToken
      );
    
      /**
       * @dev Emitted when the state of a reserve is updated.
       * @param reserve The address of the underlying asset of the reserve
       * @param liquidityRate The next liquidity rate
       * @param stableBorrowRate The next stable borrow rate
       * @param variableBorrowRate The next variable borrow rate
       * @param liquidityIndex The next liquidity index
       * @param variableBorrowIndex The next variable borrow index
       */
      event ReserveDataUpdated(
        address indexed reserve,
        uint256 liquidityRate,
        uint256 stableBorrowRate,
        uint256 variableBorrowRate,
        uint256 liquidityIndex,
        uint256 variableBorrowIndex
      );
    
      /**
       * @dev Emitted when the protocol treasury receives minted aTokens from the accrued interest.
       * @param reserve The address of the reserve
       * @param amountMinted The amount minted to the treasury
       */
      event MintedToTreasury(address indexed reserve, uint256 amountMinted);
    
      /**
       * @notice Mints an `amount` of aTokens to the `onBehalfOf`
       * @param asset The address of the underlying asset to mint
       * @param amount The amount to mint
       * @param onBehalfOf The address that will receive the aTokens
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function mintUnbacked(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Back the current unbacked underlying with `amount` and pay `fee`.
       * @param asset The address of the underlying asset to back
       * @param amount The amount to back
       * @param fee The amount paid in fees
       * @return The backed amount
       */
      function backUnbacked(address asset, uint256 amount, uint256 fee) external returns (uint256);
    
      /**
       * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
       * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    
      /**
       * @notice Supply with transfer approval of asset to be supplied done via permit function
       * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param deadline The deadline timestamp that the permit is valid
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       * @param permitV The V parameter of ERC712 permit sig
       * @param permitR The R parameter of ERC712 permit sig
       * @param permitS The S parameter of ERC712 permit sig
       */
      function supplyWithPermit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
      ) external;
    
      /**
       * @notice Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
       * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
       * @param asset The address of the underlying asset to withdraw
       * @param amount The underlying amount to be withdrawn
       *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
       * @param to The address that will receive the underlying, same as msg.sender if the user
       *   wants to receive it on his own wallet, or a different address if the beneficiary is a
       *   different wallet
       * @return The final amount withdrawn
       */
      function withdraw(address asset, uint256 amount, address to) external returns (uint256);
    
      /**
       * @notice Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
       * already supplied enough collateral, or he was given enough allowance by a credit delegator on the
       * corresponding debt token (StableDebtToken or VariableDebtToken)
       * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
       *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
       * @param asset The address of the underlying asset to borrow
       * @param amount The amount to be borrowed
       * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       * @param onBehalfOf The address of the user who will receive the debt. Should be the address of the borrower itself
       * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
       * if he has been given credit delegation allowance
       */
      function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
      ) external;
    
      /**
       * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
       * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @param onBehalfOf The address of the user who will get his debt reduced/removed. Should be the address of the
       * user calling the function if he wants to reduce/remove his own debt, or the address of any other
       * other borrower whose debt should be removed
       * @return The final amount repaid
       */
      function repay(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
      ) external returns (uint256);
    
      /**
       * @notice Repay with transfer approval of asset to be repaid done via permit function
       * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
       * user calling the function if he wants to reduce/remove his own debt, or the address of any other
       * other borrower whose debt should be removed
       * @param deadline The deadline timestamp that the permit is valid
       * @param permitV The V parameter of ERC712 permit sig
       * @param permitR The R parameter of ERC712 permit sig
       * @param permitS The S parameter of ERC712 permit sig
       * @return The final amount repaid
       */
      function repayWithPermit(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
      ) external returns (uint256);
    
      /**
       * @notice Repays a borrowed `amount` on a specific reserve using the reserve aTokens, burning the
       * equivalent debt tokens
       * - E.g. User repays 100 USDC using 100 aUSDC, burning 100 variable/stable debt tokens
       * @dev  Passing uint256.max as amount will clean up any residual aToken dust balance, if the user aToken
       * balance is not enough to cover the whole debt
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @return The final amount repaid
       */
      function repayWithATokens(
        address asset,
        uint256 amount,
        uint256 interestRateMode
      ) external returns (uint256);
    
      /**
       * @notice Allows a borrower to swap his debt between stable and variable mode, or vice versa
       * @param asset The address of the underlying asset borrowed
       * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
       */
      function swapBorrowRateMode(address asset, uint256 interestRateMode) external;
    
      /**
       * @notice Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
       * - Users can be rebalanced if the following conditions are satisfied:
       *     1. Usage ratio is above 95%
       *     2. the current supply APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too
       *        much has been borrowed at a stable rate and suppliers are not earning enough
       * @param asset The address of the underlying asset borrowed
       * @param user The address of the user to be rebalanced
       */
      function rebalanceStableBorrowRate(address asset, address user) external;
    
      /**
       * @notice Allows suppliers to enable/disable a specific supplied asset as collateral
       * @param asset The address of the underlying asset supplied
       * @param useAsCollateral True if the user wants to use the supply as collateral, false otherwise
       */
      function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
    
      /**
       * @notice Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
       * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
       *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
       * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
       * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
       * @param user The address of the borrower getting liquidated
       * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
       * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
       * to receive the underlying collateral asset directly
       */
      function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
      ) external;
    
      /**
       * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
       * as long as the amount taken plus a fee is returned.
       * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
       * into consideration. For further details please visit https://docs.aave.com/developers/
       * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanReceiver interface
       * @param assets The addresses of the assets being flash-borrowed
       * @param amounts The amounts of the assets being flash-borrowed
       * @param interestRateModes Types of the debt to open if the flash loan is not returned:
       *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
       *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
       *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
       * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
       * @param params Variadic packed params to pass to the receiver as extra information
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function flashLoan(
        address receiverAddress,
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata interestRateModes,
        address onBehalfOf,
        bytes calldata params,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
       * as long as the amount taken plus a fee is returned.
       * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
       * into consideration. For further details please visit https://docs.aave.com/developers/
       * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanSimpleReceiver interface
       * @param asset The address of the asset being flash-borrowed
       * @param amount The amount of the asset being flash-borrowed
       * @param params Variadic packed params to pass to the receiver as extra information
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Returns the user account data across all the reserves
       * @param user The address of the user
       * @return totalCollateralBase The total collateral of the user in the base currency used by the price feed
       * @return totalDebtBase The total debt of the user in the base currency used by the price feed
       * @return availableBorrowsBase The borrowing power left of the user in the base currency used by the price feed
       * @return currentLiquidationThreshold The liquidation threshold of the user
       * @return ltv The loan to value of The user
       * @return healthFactor The current health factor of the user
       */
      function getUserAccountData(
        address user
      )
        external
        view
        returns (
          uint256 totalCollateralBase,
          uint256 totalDebtBase,
          uint256 availableBorrowsBase,
          uint256 currentLiquidationThreshold,
          uint256 ltv,
          uint256 healthFactor
        );
    
      /**
       * @notice Initializes a reserve, activating it, assigning an aToken and debt tokens and an
       * interest rate strategy
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param aTokenAddress The address of the aToken that will be assigned to the reserve
       * @param stableDebtAddress The address of the StableDebtToken that will be assigned to the reserve
       * @param variableDebtAddress The address of the VariableDebtToken that will be assigned to the reserve
       * @param interestRateStrategyAddress The address of the interest rate strategy contract
       */
      function initReserve(
        address asset,
        address aTokenAddress,
        address stableDebtAddress,
        address variableDebtAddress,
        address interestRateStrategyAddress
      ) external;
    
      /**
       * @notice Drop a reserve
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       */
      function dropReserve(address asset) external;
    
      /**
       * @notice Updates the address of the interest rate strategy contract
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param rateStrategyAddress The address of the interest rate strategy contract
       */
      function setReserveInterestRateStrategyAddress(
        address asset,
        address rateStrategyAddress
      ) external;
    
      /**
       * @notice Sets the configuration bitmap of the reserve as a whole
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param configuration The new configuration bitmap
       */
      function setConfiguration(
        address asset,
        DataTypes.ReserveConfigurationMap calldata configuration
      ) external;
    
      /**
       * @notice Returns the configuration of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The configuration of the reserve
       */
      function getConfiguration(
        address asset
      ) external view returns (DataTypes.ReserveConfigurationMap memory);
    
      /**
       * @notice Returns the configuration of the user across all the reserves
       * @param user The user address
       * @return The configuration of the user
       */
      function getUserConfiguration(
        address user
      ) external view returns (DataTypes.UserConfigurationMap memory);
    
      /**
       * @notice Returns the normalized income of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The reserve's normalized income
       */
      function getReserveNormalizedIncome(address asset) external view returns (uint256);
    
      /**
       * @notice Returns the normalized variable debt per unit of asset
       * @dev WARNING: This function is intended to be used primarily by the protocol itself to get a
       * "dynamic" variable index based on time, current stored index and virtual rate at the current
       * moment (approx. a borrower would get if opening a position). This means that is always used in
       * combination with variable debt supply/balances.
       * If using this function externally, consider that is possible to have an increasing normalized
       * variable debt that is not equivalent to how the variable debt index would be updated in storage
       * (e.g. only updates with non-zero variable debt supply)
       * @param asset The address of the underlying asset of the reserve
       * @return The reserve normalized variable debt
       */
      function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
    
      /**
       * @notice Returns the state and configuration of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The state and configuration data of the reserve
       */
      function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
    
      /**
       * @notice Validates and finalizes an aToken transfer
       * @dev Only callable by the overlying aToken of the `asset`
       * @param asset The address of the underlying asset of the aToken
       * @param from The user from which the aTokens are transferred
       * @param to The user receiving the aTokens
       * @param amount The amount being transferred/withdrawn
       * @param balanceFromBefore The aToken balance of the `from` user before the transfer
       * @param balanceToBefore The aToken balance of the `to` user before the transfer
       */
      function finalizeTransfer(
        address asset,
        address from,
        address to,
        uint256 amount,
        uint256 balanceFromBefore,
        uint256 balanceToBefore
      ) external;
    
      /**
       * @notice Returns the list of the underlying assets of all the initialized reserves
       * @dev It does not include dropped reserves
       * @return The addresses of the underlying assets of the initialized reserves
       */
      function getReservesList() external view returns (address[] memory);
    
      /**
       * @notice Returns the address of the underlying asset of a reserve by the reserve id as stored in the DataTypes.ReserveData struct
       * @param id The id of the reserve as stored in the DataTypes.ReserveData struct
       * @return The address of the reserve associated with id
       */
      function getReserveAddressById(uint16 id) external view returns (address);
    
      /**
       * @notice Returns the PoolAddressesProvider connected to this contract
       * @return The address of the PoolAddressesProvider
       */
      function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
    
      /**
       * @notice Updates the protocol fee on the bridging
       * @param bridgeProtocolFee The part of the premium sent to the protocol treasury
       */
      function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;
    
      /**
       * @notice Updates flash loan premiums. Flash loan premium consists of two parts:
       * - A part is sent to aToken holders as extra, one time accumulated interest
       * - A part is collected by the protocol treasury
       * @dev The total premium is calculated on the total borrowed amount
       * @dev The premium to protocol is calculated on the total premium, being a percentage of `flashLoanPremiumTotal`
       * @dev Only callable by the PoolConfigurator contract
       * @param flashLoanPremiumTotal The total premium, expressed in bps
       * @param flashLoanPremiumToProtocol The part of the premium sent to the protocol treasury, expressed in bps
       */
      function updateFlashloanPremiums(
        uint128 flashLoanPremiumTotal,
        uint128 flashLoanPremiumToProtocol
      ) external;
    
      /**
       * @notice Configures a new category for the eMode.
       * @dev In eMode, the protocol allows very high borrowing power to borrow assets of the same category.
       * The category 0 is reserved as it's the default for volatile assets
       * @param id The id of the category
       * @param config The configuration of the category
       */
      function configureEModeCategory(uint8 id, DataTypes.EModeCategory memory config) external;
    
      /**
       * @notice Returns the data of an eMode category
       * @param id The id of the category
       * @return The configuration data of the category
       */
      function getEModeCategoryData(uint8 id) external view returns (DataTypes.EModeCategory memory);
    
      /**
       * @notice Allows a user to use the protocol in eMode
       * @param categoryId The id of the category
       */
      function setUserEMode(uint8 categoryId) external;
    
      /**
       * @notice Returns the eMode the user is using
       * @param user The address of the user
       * @return The eMode id
       */
      function getUserEMode(address user) external view returns (uint256);
    
      /**
       * @notice Resets the isolation mode total debt of the given asset to zero
       * @dev It requires the given asset has zero debt ceiling
       * @param asset The address of the underlying asset to reset the isolationModeTotalDebt
       */
      function resetIsolationModeTotalDebt(address asset) external;
    
      /**
       * @notice Returns the percentage of available liquidity that can be borrowed at once at stable rate
       * @return The percentage of available liquidity to borrow, expressed in bps
       */
      function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);
    
      /**
       * @notice Returns the total fee on flash loans
       * @return The total fee on flashloans
       */
      function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);
    
      /**
       * @notice Returns the part of the bridge fees sent to protocol
       * @return The bridge fee sent to the protocol treasury
       */
      function BRIDGE_PROTOCOL_FEE() external view returns (uint256);
    
      /**
       * @notice Returns the part of the flashloan fees sent to protocol
       * @return The flashloan fee sent to the protocol treasury
       */
      function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);
    
      /**
       * @notice Returns the maximum number of reserves supported to be listed in this Pool
       * @return The maximum number of reserves supported
       */
      function MAX_NUMBER_RESERVES() external view returns (uint16);
    
      /**
       * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens
       * @param assets The list of reserves for which the minting needs to be executed
       */
      function mintToTreasury(address[] calldata assets) external;
    
      /**
       * @notice Rescue and transfer tokens locked in this contract
       * @param token The address of the token
       * @param to The address of the recipient
       * @param amount The amount of token to transfer
       */
      function rescueTokens(address token, address to, uint256 amount) external;
    
      /**
       * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
       * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
       * @dev Deprecated: Use the `supply` function instead
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    /**
     * @title IPoolAddressesProvider
     * @author Aave
     * @notice Defines the basic interface for a Pool Addresses Provider.
     */
    interface IPoolAddressesProvider {
      /**
       * @dev Emitted when the market identifier is updated.
       * @param oldMarketId The old id of the market
       * @param newMarketId The new id of the market
       */
      event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
    
      /**
       * @dev Emitted when the pool is updated.
       * @param oldAddress The old address of the Pool
       * @param newAddress The new address of the Pool
       */
      event PoolUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the pool configurator is updated.
       * @param oldAddress The old address of the PoolConfigurator
       * @param newAddress The new address of the PoolConfigurator
       */
      event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the price oracle is updated.
       * @param oldAddress The old address of the PriceOracle
       * @param newAddress The new address of the PriceOracle
       */
      event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the ACL manager is updated.
       * @param oldAddress The old address of the ACLManager
       * @param newAddress The new address of the ACLManager
       */
      event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the ACL admin is updated.
       * @param oldAddress The old address of the ACLAdmin
       * @param newAddress The new address of the ACLAdmin
       */
      event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the price oracle sentinel is updated.
       * @param oldAddress The old address of the PriceOracleSentinel
       * @param newAddress The new address of the PriceOracleSentinel
       */
      event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the pool data provider is updated.
       * @param oldAddress The old address of the PoolDataProvider
       * @param newAddress The new address of the PoolDataProvider
       */
      event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when a new proxy is created.
       * @param id The identifier of the proxy
       * @param proxyAddress The address of the created proxy contract
       * @param implementationAddress The address of the implementation contract
       */
      event ProxyCreated(
        bytes32 indexed id,
        address indexed proxyAddress,
        address indexed implementationAddress
      );
    
      /**
       * @dev Emitted when a new non-proxied contract address is registered.
       * @param id The identifier of the contract
       * @param oldAddress The address of the old contract
       * @param newAddress The address of the new contract
       */
      event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the implementation of the proxy registered with id is updated
       * @param id The identifier of the contract
       * @param proxyAddress The address of the proxy contract
       * @param oldImplementationAddress The address of the old implementation contract
       * @param newImplementationAddress The address of the new implementation contract
       */
      event AddressSetAsProxy(
        bytes32 indexed id,
        address indexed proxyAddress,
        address oldImplementationAddress,
        address indexed newImplementationAddress
      );
    
      /**
       * @notice Returns the id of the Aave market to which this contract points to.
       * @return The market id
       */
      function getMarketId() external view returns (string memory);
    
      /**
       * @notice Associates an id with a specific PoolAddressesProvider.
       * @dev This can be used to create an onchain registry of PoolAddressesProviders to
       * identify and validate multiple Aave markets.
       * @param newMarketId The market id
       */
      function setMarketId(string calldata newMarketId) external;
    
      /**
       * @notice Returns an address by its identifier.
       * @dev The returned address might be an EOA or a contract, potentially proxied
       * @dev It returns ZERO if there is no registered address with the given id
       * @param id The id
       * @return The address of the registered for the specified id
       */
      function getAddress(bytes32 id) external view returns (address);
    
      /**
       * @notice General function to update the implementation of a proxy registered with
       * certain `id`. If there is no proxy registered, it will instantiate one and
       * set as implementation the `newImplementationAddress`.
       * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
       * setter function, in order to avoid unexpected consequences
       * @param id The id
       * @param newImplementationAddress The address of the new implementation
       */
      function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;
    
      /**
       * @notice Sets an address for an id replacing the address saved in the addresses map.
       * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
       * @param id The id
       * @param newAddress The address to set
       */
      function setAddress(bytes32 id, address newAddress) external;
    
      /**
       * @notice Returns the address of the Pool proxy.
       * @return The Pool proxy address
       */
      function getPool() external view returns (address);
    
      /**
       * @notice Updates the implementation of the Pool, or creates a proxy
       * setting the new `pool` implementation when the function is called for the first time.
       * @param newPoolImpl The new Pool implementation
       */
      function setPoolImpl(address newPoolImpl) external;
    
      /**
       * @notice Returns the address of the PoolConfigurator proxy.
       * @return The PoolConfigurator proxy address
       */
      function getPoolConfigurator() external view returns (address);
    
      /**
       * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
       * setting the new `PoolConfigurator` implementation when the function is called for the first time.
       * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
       */
      function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
    
      /**
       * @notice Returns the address of the price oracle.
       * @return The address of the PriceOracle
       */
      function getPriceOracle() external view returns (address);
    
      /**
       * @notice Updates the address of the price oracle.
       * @param newPriceOracle The address of the new PriceOracle
       */
      function setPriceOracle(address newPriceOracle) external;
    
      /**
       * @notice Returns the address of the ACL manager.
       * @return The address of the ACLManager
       */
      function getACLManager() external view returns (address);
    
      /**
       * @notice Updates the address of the ACL manager.
       * @param newAclManager The address of the new ACLManager
       */
      function setACLManager(address newAclManager) external;
    
      /**
       * @notice Returns the address of the ACL admin.
       * @return The address of the ACL admin
       */
      function getACLAdmin() external view returns (address);
    
      /**
       * @notice Updates the address of the ACL admin.
       * @param newAclAdmin The address of the new ACL admin
       */
      function setACLAdmin(address newAclAdmin) external;
    
      /**
       * @notice Returns the address of the price oracle sentinel.
       * @return The address of the PriceOracleSentinel
       */
      function getPriceOracleSentinel() external view returns (address);
    
      /**
       * @notice Updates the address of the price oracle sentinel.
       * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
       */
      function setPriceOracleSentinel(address newPriceOracleSentinel) external;
    
      /**
       * @notice Returns the address of the data provider.
       * @return The address of the DataProvider
       */
      function getPoolDataProvider() external view returns (address);
    
      /**
       * @notice Updates the address of the data provider.
       * @param newDataProvider The address of the new DataProvider
       */
      function setPoolDataProvider(address newDataProvider) external;
    }

    // SPDX-License-Identifier: BUSL-1.1
    pragma solidity ^0.8.0;
    
    library DataTypes {
      struct ReserveData {
        //stores the reserve configuration
        ReserveConfigurationMap configuration;
        //the liquidity index. Expressed in ray
        uint128 liquidityIndex;
        //the current supply rate. Expressed in ray
        uint128 currentLiquidityRate;
        //variable borrow index. Expressed in ray
        uint128 variableBorrowIndex;
        //the current variable borrow rate. Expressed in ray
        uint128 currentVariableBorrowRate;
        //the current stable borrow rate. Expressed in ray
        uint128 currentStableBorrowRate;
        //timestamp of last update
        uint40 lastUpdateTimestamp;
        //the id of the reserve. Represents the position in the list of the active reserves
        uint16 id;
        //aToken address
        address aTokenAddress;
        //stableDebtToken address
        address stableDebtTokenAddress;
        //variableDebtToken address
        address variableDebtTokenAddress;
        //address of the interest rate strategy
        address interestRateStrategyAddress;
        //the current treasury balance, scaled
        uint128 accruedToTreasury;
        //the outstanding unbacked aTokens minted through the bridging feature
        uint128 unbacked;
        //the outstanding debt borrowed against this asset in isolation mode
        uint128 isolationModeTotalDebt;
      }
    
      struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: stable rate borrowing enabled
        //bit 60: asset is paused
        //bit 61: borrowing in isolation mode is enabled
        //bit 62: siloed borrowing enabled
        //bit 63: flashloaning enabled
        //bit 64-79: reserve factor
        //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
        //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
        //bit 152-167 liquidation protocol fee
        //bit 168-175 eMode category
        //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
        //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
        //bit 252-255 unused
    
        uint256 data;
      }
    
      struct UserConfigurationMap {
        /**
         * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
         * The first bit indicates if an asset is used as collateral by the user, the second whether an
         * asset is borrowed by the user.
         */
        uint256 data;
      }
    
      struct EModeCategory {
        // each eMode category has a custom ltv and liquidation threshold
        uint16 ltv;
        uint16 liquidationThreshold;
        uint16 liquidationBonus;
        // each eMode category may or may not have a custom oracle to override the individual assets price oracles
        address priceSource;
        string label;
      }
    
      enum InterestRateMode {NONE, STABLE, VARIABLE}
    
      struct ReserveCache {
        uint256 currScaledVariableDebt;
        uint256 nextScaledVariableDebt;
        uint256 currPrincipalStableDebt;
        uint256 currAvgStableBorrowRate;
        uint256 currTotalStableDebt;
        uint256 nextAvgStableBorrowRate;
        uint256 nextTotalStableDebt;
        uint256 currLiquidityIndex;
        uint256 nextLiquidityIndex;
        uint256 currVariableBorrowIndex;
        uint256 nextVariableBorrowIndex;
        uint256 currLiquidityRate;
        uint256 currVariableBorrowRate;
        uint256 reserveFactor;
        ReserveConfigurationMap reserveConfiguration;
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        uint40 reserveLastUpdateTimestamp;
        uint40 stableDebtLastUpdateTimestamp;
      }
    
      struct ExecuteLiquidationCallParams {
        uint256 reservesCount;
        uint256 debtToCover;
        address collateralAsset;
        address debtAsset;
        address user;
        bool receiveAToken;
        address priceOracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
      }
    
      struct ExecuteSupplyParams {
        address asset;
        uint256 amount;
        address onBehalfOf;
        uint16 referralCode;
      }
    
      struct ExecuteBorrowParams {
        address asset;
        address user;
        address onBehalfOf;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint16 referralCode;
        bool releaseUnderlying;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
      }
    
      struct ExecuteRepayParams {
        address asset;
        uint256 amount;
        InterestRateMode interestRateMode;
        address onBehalfOf;
        bool useATokens;
      }
    
      struct ExecuteWithdrawParams {
        address asset;
        uint256 amount;
        address to;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
      }
    
      struct ExecuteSetUserEModeParams {
        uint256 reservesCount;
        address oracle;
        uint8 categoryId;
      }
    
      struct FinalizeTransferParams {
        address asset;
        address from;
        address to;
        uint256 amount;
        uint256 balanceFromBefore;
        uint256 balanceToBefore;
        uint256 reservesCount;
        address oracle;
        uint8 fromEModeCategory;
      }
    
      struct FlashloanParams {
        address receiverAddress;
        address[] assets;
        uint256[] amounts;
        uint256[] interestRateModes;
        address onBehalfOf;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address addressesProvider;
        uint8 userEModeCategory;
        bool isAuthorizedFlashBorrower;
      }
    
      struct FlashloanSimpleParams {
        address receiverAddress;
        address asset;
        uint256 amount;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
      }
    
      struct FlashLoanRepaymentParams {
        uint256 amount;
        uint256 totalPremium;
        uint256 flashLoanPremiumToProtocol;
        address asset;
        address receiverAddress;
        uint16 referralCode;
      }
    
      struct CalculateUserAccountDataParams {
        UserConfigurationMap userConfig;
        uint256 reservesCount;
        address user;
        address oracle;
        uint8 userEModeCategory;
      }
    
      struct ValidateBorrowParams {
        ReserveCache reserveCache;
        UserConfigurationMap userConfig;
        address asset;
        address userAddress;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint256 maxStableLoanPercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
        bool isolationModeActive;
        address isolationModeCollateralAddress;
        uint256 isolationModeDebtCeiling;
      }
    
      struct ValidateLiquidationCallParams {
        ReserveCache debtReserveCache;
        uint256 totalDebt;
        uint256 healthFactor;
        address priceOracleSentinel;
      }
    
      struct CalculateInterestRatesParams {
        uint256 unbacked;
        uint256 liquidityAdded;
        uint256 liquidityTaken;
        uint256 totalStableDebt;
        uint256 totalVariableDebt;
        uint256 averageStableBorrowRate;
        uint256 reserveFactor;
        address reserve;
        address aToken;
      }
    
      struct InitReserveParams {
        address asset;
        address aTokenAddress;
        address stableDebtAddress;
        address variableDebtAddress;
        address interestRateStrategyAddress;
        uint16 reservesCount;
        uint16 maxNumberReserves;
      }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    interface IBeefyVault {
        /**
         * @notice Gets the total supply of vault shares
         * @return Total supply of shares
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @notice Function for various UIs to display the current value of one of our yield tokens.
         * @return An uint256 with 18 decimals of how much underlying asset one vault share represents.
         */
        function getPricePerFullShare() external view returns (uint256);
    
        function want() external view returns (address);
    
        function deposit(uint256 amount) external;
    }

    Contract Name:
    AutoLeverager

    Contract Source Code:

    // SPDX-License-Identifier: BUSL-1.1
    pragma solidity ^0.8.10;
    
    import {AggregatorInterface} from "AggregatorInterface.sol";
    import {IERC20} from "IERC20.sol";
    import {SafeERC20} from "SafeERC20.sol";
    import {IPyth, Price} from "IPyth.sol";
    import {Ownable} from "Ownable.sol";
    import {IPeggedOracle} from "IPeggedOracle.sol";
    import {IICHIVault} from "IICHIVault.sol";
    import {IPool} from "IPool.sol";
    import {IBeefyVault} from "IBeefyVault.sol";
    
    /**
     * @title Autoleverager
     * @author Your Name
     * @notice This contract automates leveraged positions in AAVE markets using ICHI vaults and Beefy vaults
     * @dev Uses flash loans to achieve leverage and handles the complete flow of leverage deposit
     */
    contract AutoLeverager is Ownable {
        event Log(uint256);
        event LogWLabel(string, uint256);
        using SafeERC20 for IERC20;
    
        /// @notice Router used for token swaps
        address public odosRouter;
    
        /// @notice Address that receives fees
        address public feeReceiver;
    
        /// @notice Fee percentage (10000 = 100%)
        uint256 public fee;
    
        /// @notice Main pool for supply and borrow operations
        IPool public pool;
    
        /// @notice Pool used for flash loans
        IPool public borrowPool;
    
        /// @notice Emitted when a leveraged deposit is completed
        event LeverageDeposited(
            address indexed user,
            address depositAsset,
            address borrowAsset,
            uint256 initialAmount,
            address ichiVault,
            address vicunaVault
        );
    
        /// @notice Emitted when the fee percentage is updated
        event FeeUpdated(uint256 oldFee, uint256 newFee);
    
        /// @notice Emitted when a contract parameter is updated
        event ParameterUpdated(string paramName, address oldValue, address newValue);
    
        /// @notice Emitted when tokens are rescued in an emergency
        event TokensRescued(address indexed token, address indexed recipient, uint256 amount);
    
        /**
         * @notice Constructor to initialize the Autoleverager contract
         * @param _odosRouter Address of the ODOS router for swaps
         * @param _pool Address of the main pool for supply/borrow
         * @param _borrowPool Address of the pool for flash loans
         * @param _feeReceiver Address that will receive fees
         */
        constructor(address _odosRouter, address _pool, address _borrowPool, address _feeReceiver) {
            odosRouter = _odosRouter;
            pool = IPool(_pool);
            borrowPool = IPool(_borrowPool);
            feeReceiver = _feeReceiver;
        }
    
        /**
         * @notice Sets the fee percentage
         * @param _fee New fee percentage (10000 = 100%)
         */
        function setFee(uint256 _fee) external onlyOwner {
            require(_fee <= 10000, "Fee too high");
            uint256 oldFee = fee;
            fee = _fee;
            emit FeeUpdated(oldFee, _fee);
        }
    
        /**
         * @notice Sets the ODOS router address
         * @param _odosRouter New router address
         */
        function setOdosRouter(address _odosRouter) external onlyOwner {
            require(_odosRouter != address(0), "Invalid address");
            address oldRouter = odosRouter;
            odosRouter = _odosRouter;
            emit ParameterUpdated("odosRouter", oldRouter, _odosRouter);
        }
    
        /**
         * @notice Sets the main pool address
         * @param _pool New pool address
         */
        function setPool(address _pool) external onlyOwner {
            require(_pool != address(0), "Invalid address");
            address oldPool = address(pool);
            pool = IPool(_pool);
            emit ParameterUpdated("pool", oldPool, _pool);
        }
    
        /**
         * @notice Sets the borrow pool address used for flash loans
         * @param _borrowPool New borrow pool address
         */
        function setBorrowPool(address _borrowPool) external onlyOwner {
            require(_borrowPool != address(0), "Invalid address");
            address oldBorrowPool = address(borrowPool);
            borrowPool = IPool(_borrowPool);
            emit ParameterUpdated("borrowPool", oldBorrowPool, _borrowPool);
        }
    
        /**
         * @notice Sets the fee receiver address
         * @param _feeReceiver New fee receiver address
         */
        function setFeeReceiver(address _feeReceiver) external onlyOwner {
            require(_feeReceiver != address(0), "Invalid address");
            address oldFeeReceiver = feeReceiver;
            feeReceiver = _feeReceiver;
            emit ParameterUpdated("feeReceiver", oldFeeReceiver, _feeReceiver);
        }
    
        /**
         * @notice Helper function to get token decimals
         * @param token Address of the token
         * @return uint8 Token decimals
         */
        function getDecimals(address token) internal view returns (uint8) {
            (bool success, bytes memory data) = token.staticcall(abi.encodeWithSignature("decimals()"));
            require(success, "Failed to get decimals");
            return abi.decode(data, (uint8));
        }
    
        /**
         * @notice Converts amount from one token's decimals to another
         * @param amount Amount to convert
         * @param fromDecimals Source token decimals
         * @param toDecimals Target token decimals
         * @return Converted amount
         */
        function convertDecimals(
            uint256 amount,
            uint8 fromDecimals,
            uint8 toDecimals
        ) internal pure returns (uint256) {
            if (fromDecimals == toDecimals) {
                return amount;
            } else if (fromDecimals > toDecimals) {
                return amount / (10 ** (fromDecimals - toDecimals));
            } else {
                return amount * (10 ** (toDecimals - fromDecimals));
            }
        }
    
        struct DepositData {
            InputDepositData inputData;
            uint256 initialAmountAfterFee;
            address sender;
            address vaultDepositAsset;
        }
        struct InputDepositData {
            address depositAsset;
            address borrowAsset;
            uint256 initialAmount;
            uint256 borrowAmount;
            address vicunaVault;
            bytes swapParams;
        }
    
        /**
         * @notice Creates a leveraged position using flash loans
         */
        function leverageDeposit(InputDepositData calldata inputParameters) external {
            DepositData memory depositParams;
            depositParams.sender = msg.sender;
            depositParams.inputData = inputParameters;
    
            address ichiVault = IBeefyVault(inputParameters.vicunaVault).want();
            {
                address token0 = IICHIVault(ichiVault).token0();
                address token1 = IICHIVault(ichiVault).token1();
    
                depositParams.vaultDepositAsset = IICHIVault(ichiVault).allowToken0() ? token0 : token1;
    
                require(
                    inputParameters.depositAsset == depositParams.vaultDepositAsset ||
                        inputParameters.depositAsset == inputParameters.borrowAsset || depositParams.vaultDepositAsset == inputParameters.borrowAsset,
                    "Invalid deposit/borrow asset"
                );
    
            
                require(
                    inputParameters.borrowAmount > 0,
                    "BorrowAmount should be positive"
                );
            }
    
            IERC20(inputParameters.depositAsset).safeTransferFrom(
                msg.sender,
                address(this),
                inputParameters.initialAmount
            );
    
            // Calculate and transfer fee
            uint256 feeAmount = (inputParameters.initialAmount * fee) / 10000;
            if (feeAmount > 0) {
                IERC20(inputParameters.depositAsset).safeTransfer(feeReceiver, feeAmount);
            }
    
            depositParams.initialAmountAfterFee = inputParameters.initialAmount - feeAmount;
            uint256 neededToFlash = inputParameters.borrowAmount;
    
            bytes memory params = abi.encode(depositParams);
    
            // Borrow the asset needed to deposit in the vault
            address[] memory assets = new address[](1);
            assets[0] = inputParameters.borrowAsset;
            uint256[] memory amounts = new uint256[](1);
            amounts[0] = neededToFlash;
            uint256[] memory modes = new uint256[](1);
            modes[0] = 0;
            borrowPool.flashLoan(address(this), assets, amounts, modes, address(this), params, 0);
    
            emit LogWLabel("Flash", neededToFlash);
            emit LeverageDeposited(
                msg.sender,
                inputParameters.depositAsset,
                inputParameters.borrowAsset,
                inputParameters.initialAmount,
                ichiVault,
                inputParameters.vicunaVault
            );
        }
    
        /**
         * @notice Flash loan callback function
         * @param assets Assets received from flash loan
         * @param amounts Amounts of flash loaned assets
         * @param params Encoded parameters
         * @return success True if the operation was successful
         */
        function executeOperation(
            address[] calldata assets,
            uint256[] calldata amounts,
            uint256[] calldata,
            address,
            bytes calldata params
        ) external returns (bool) {
            require(msg.sender == address(borrowPool), "Only borrowPool can call this function");
    
            DepositData memory depositData = abi.decode(params, (DepositData));
            address vaultDepositAsset = depositData.vaultDepositAsset;
            address flashLoanAsset = assets[0];
            uint256 flashLoanAmount = amounts[0];
            // uint256 premium = premiums[0];
    
            uint256 depositAmount;
            if (depositData.inputData.depositAsset == vaultDepositAsset) {
                // If depositAsset is the same as vaultDepositAsset, use both the flash loan amount and user deposit
                depositAmount += depositData.initialAmountAfterFee;
            } 
            if (vaultDepositAsset == flashLoanAsset) {
                // If depositAsset is different from vaultDepositAsset, use only the flash loan amount
                depositAmount += flashLoanAmount;
            }
    
            uint256 swapAmountoutput;
            if (flashLoanAsset != vaultDepositAsset) {
                // Swap flash loaned asset to vault deposit asset
                // Approve the full amount needed for the swap
                IERC20(flashLoanAsset).safeApprove(odosRouter, type(uint256).max);
                uint256 beforeBalance = IERC20(vaultDepositAsset).balanceOf(address(this));
                // Execute the swap
                (bool success, ) = odosRouter.call(depositData.inputData.swapParams);
                require(success, "Swap failed");
                swapAmountoutput = IERC20(vaultDepositAsset).balanceOf(address(this)) - beforeBalance;
            } else if (flashLoanAsset == vaultDepositAsset && depositData.inputData.depositAsset != vaultDepositAsset) {
                IERC20(depositData.inputData.depositAsset).safeApprove(odosRouter, depositData.initialAmountAfterFee);
                uint256 beforeBalance = IERC20(vaultDepositAsset).balanceOf(address(this));
    
                (bool success, ) = odosRouter.call(depositData.inputData.swapParams);
                require(success, "Swap failed");
                swapAmountoutput = IERC20(vaultDepositAsset).balanceOf(address(this)) - beforeBalance;
            }
            depositAmount += swapAmountoutput;
    
            IICHIVault ichiVault = IICHIVault(IBeefyVault(depositData.inputData.vicunaVault).want());
            bool isToken0 = ichiVault.token0() == vaultDepositAsset;
            // Deposit into ICHI vault
            IERC20(vaultDepositAsset).safeApprove(address(ichiVault), depositAmount);
            IICHIVault(ichiVault).deposit(
                isToken0 ? depositAmount : 0,
                isToken0 ? 0 : depositAmount,
                address(this)
            );
    
            // Deposit ICHI LP tokens into Beefy vault
            uint256 ichiBalance = IERC20(address(ichiVault)).balanceOf(address(this));
            IERC20(address(ichiVault)).safeApprove(depositData.inputData.vicunaVault, ichiBalance);
            IBeefyVault(depositData.inputData.vicunaVault).deposit(ichiBalance);
    
            // Supply Beefy vault tokens to Aave
            uint256 vaultBalance = IERC20(depositData.inputData.vicunaVault).balanceOf(address(this));
            IERC20(depositData.inputData.vicunaVault).safeApprove(address(pool), vaultBalance);
            pool.supply(depositData.inputData.vicunaVault, vaultBalance, depositData.sender, 0);
    
    
            // Borrow from Aave
            pool.borrow(
                depositData.inputData.borrowAsset,
                flashLoanAmount,
                2,
                0,
                depositData.sender
            );
    
    
            // Approve and repay flash loan
            IERC20(flashLoanAsset).safeApprove(address(borrowPool), flashLoanAmount);
            return true;
        }
    
        /**
         * @notice Rescues tokens accidentally sent to the contract
         * @param token Address of the token to rescue
         * @param to Address to send the tokens to
         * @param amount Amount of tokens to rescue
         */
        function rescueTokens(address token, address to, uint256 amount) external onlyOwner {
            require(to != address(0), "Cannot send to zero address");
    
            IERC20(token).safeTransfer(to, amount);
    
            emit TokensRescued(token, to, amount);
        }
    
        /**
         * @notice Rescues ETH accidentally sent to the contract
         * @param to Address to send the ETH to
         * @param amount Amount of ETH to rescue
         */
        function rescueETH(address payable to, uint256 amount) external onlyOwner {
            require(to != address(0), "Cannot send to zero address");
            require(address(this).balance >= amount, "Insufficient ETH balance");
    
            (bool success, ) = to.call{value: amount}("");
            require(success, "ETH transfer failed");
    
            emit TokensRescued(address(0), to, amount);
        }
    
        /**
         * @notice Allows the contract to receive ETH
         */
        receive() external payable {}
    }

    // SPDX-License-Identifier: MIT
    // Chainlink Contracts v0.8
    pragma solidity ^0.8.0;
    
    interface AggregatorInterface {
      function latestAnswer() external view returns (int256);
    
      function latestTimestamp() external view returns (uint256);
    
      function latestRound() external view returns (uint256);
    
      function getAnswer(uint256 roundId) external view returns (int256);
    
      function getTimestamp(uint256 roundId) external view returns (uint256);
    
      function decimals() external view returns (uint8);
    
      event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);
    
      event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    /**
     * @dev Interface of the ERC20 standard as defined in the EIP.
     */
    interface IERC20 {
      /**
       * @dev Returns the amount of tokens in existence.
       */
      function totalSupply() external view returns (uint256);
    
      /**
       * @dev Returns the amount of tokens owned by `account`.
       */
      function balanceOf(address account) external view returns (uint256);
    
      /**
       * @dev Moves `amount` tokens from the caller's account to `recipient`.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transfer(address recipient, uint256 amount) external returns (bool);
    
      /**
       * @dev Returns the remaining number of tokens that `spender` will be
       * allowed to spend on behalf of `owner` through {transferFrom}. This is
       * zero by default.
       *
       * This value changes when {approve} or {transferFrom} are called.
       */
      function allowance(address owner, address spender) external view returns (uint256);
    
      /**
       * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * IMPORTANT: Beware that changing an allowance with this method brings the risk
       * that someone may use both the old and the new allowance by unfortunate
       * transaction ordering. One possible solution to mitigate this race
       * condition is to first reduce the spender's allowance to 0 and set the
       * desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       *
       * Emits an {Approval} event.
       */
      function approve(address spender, uint256 amount) external returns (bool);
    
      /**
       * @dev Moves `amount` tokens from `sender` to `recipient` using the
       * allowance mechanism. `amount` is then deducted from the caller's
       * allowance.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    
      /**
       * @dev Emitted when `value` tokens are moved from one account (`from`) to
       * another (`to`).
       *
       * Note that `value` may be zero.
       */
      event Transfer(address indexed from, address indexed to, uint256 value);
    
      /**
       * @dev Emitted when the allowance of a `spender` for an `owner` is set by
       * a call to {approve}. `value` is the new allowance.
       */
      event Approval(address indexed owner, address indexed spender, uint256 value);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
    
    pragma solidity ^0.8.0;
    
    import "IERC20.sol";
    import "Address.sol";
    
    /**
     * @title SafeERC20
     * @dev Wrappers around ERC20 operations that throw on failure (when the token
     * contract returns false). Tokens that return no value (and instead revert or
     * throw on failure) are also supported, non-reverting calls are assumed to be
     * successful.
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
     */
    library SafeERC20 {
      using Address for address;
    
      function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
      }
    
      function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(
          token,
          abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
      }
    
      /**
       * @dev Deprecated. This function has issues similar to the ones found in
       * {IERC20-approve}, and its usage is discouraged.
       *
       * Whenever possible, use {safeIncreaseAllowance} and
       * {safeDecreaseAllowance} instead.
       */
      function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
          (value == 0) || (token.allowance(address(this), spender) == 0),
          'SafeERC20: approve from non-zero to non-zero allowance'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
      }
    
      function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
          token,
          abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
      }
    
      function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
          uint256 oldAllowance = token.allowance(address(this), spender);
          require(oldAllowance >= value, 'SafeERC20: decreased allowance below zero');
          uint256 newAllowance = oldAllowance - value;
          _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
          );
        }
      }
    
      /**
       * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
       * on the return value: the return value is optional (but if data is returned, it must not be false).
       * @param token The token targeted by the call.
       * @param data The call data (encoded using abi.encode or one of its variants).
       */
      function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.
    
        bytes memory returndata = address(token).functionCall(data, 'SafeERC20: low-level call failed');
        if (returndata.length > 0) {
          // Return data is optional
          require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
        }
      }
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
    
    pragma solidity ^0.8.0;
    
    /**
     * @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
       * ====
       */
      function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.
    
        uint256 size;
        assembly {
          size := extcodesize(account)
        }
        return size > 0;
      }
    
      /**
       * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
       * `recipient`, forwarding all available gas and reverting on errors.
       *
       * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
       * of certain opcodes, possibly making contracts go over the 2300 gas limit
       * imposed by `transfer`, making them unable to receive funds via
       * `transfer`. {sendValue} removes this limitation.
       *
       * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
       *
       * IMPORTANT: because control is transferred to `recipient`, care must be
       * taken to not create reentrancy vulnerabilities. Consider using
       * {ReentrancyGuard} or the
       * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
       */
      function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, 'Address: insufficient balance');
    
        (bool success, ) = recipient.call{value: amount}('');
        require(success, 'Address: unable to send value, recipient may have reverted');
      }
    
      /**
       * @dev Performs a Solidity function call using a low level `call`. A
       * plain `call` is an unsafe replacement for a function call: use this
       * function instead.
       *
       * If `target` reverts with a revert reason, it is bubbled up by this
       * function (like regular Solidity function calls).
       *
       * Returns the raw returned data. To convert to the expected return value,
       * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
       *
       * Requirements:
       *
       * - `target` must be a contract.
       * - calling `target` with `data` must not revert.
       *
       * _Available since v3.1._
       */
      function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, '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');
        require(isContract(target), 'Address: call to non-contract');
    
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), 'Address: static call to non-contract');
    
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), 'Address: delegate call to non-contract');
    
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
      }
    
      /**
       * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
       * revert reason 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 {
          // 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
    
            assembly {
              let returndata_size := mload(returndata)
              revert(add(32, returndata), returndata_size)
            }
          } else {
            revert(errorMessage);
          }
        }
      }
    }

    pragma solidity ^0.8.10;
    
    
    struct Price {
        // Price
        int64 price;
        // Confidence interval
        uint64 conf;
        // Price exponent
        int32 expo;
        // Unix timestamp describing when the price was published
        uint publishTime;
    }
    
    interface IPyth {
        function getPrice(bytes32 priceId) external view returns (Price memory);
        function getEmaPrice(bytes32 priceId) external view returns (Price memory);
        function getPriceUnsafe(bytes32 priceId) external view returns (Price memory);
        function getUpdateFee(bytes[] calldata priceUpdateData) external view returns (uint256);
        function updatePriceFeeds(bytes[] calldata priceUpdateData) external payable;
        function getPriceNoOlderThan(
            bytes32 id,
            uint age
        ) external view returns (Price memory price);
    }

    // SPDX-License-Identifier: MIT
    
    pragma solidity ^0.8.0;
    
    import "Context.sol";
    
    /**
     * @dev Contract module which provides a basic access control mechanism, where
     * there is an account (an owner) that can be granted exclusive access to
     * specific functions.
     *
     * By default, the owner account will be the one that deploys the contract. This
     * can later be changed with {transferOwnership}.
     *
     * This module is used through inheritance. It will make available the modifier
     * `onlyOwner`, which can be applied to your functions to restrict their use to
     * the owner.
     */
    contract Ownable is Context {
      address private _owner;
    
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
      /**
       * @dev Initializes the contract setting the deployer as the initial owner.
       */
      constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
      }
    
      /**
       * @dev Returns the address of the current owner.
       */
      function owner() public view returns (address) {
        return _owner;
      }
    
      /**
       * @dev Throws if called by any account other than the owner.
       */
      modifier onlyOwner() {
        require(_owner == _msgSender(), 'Ownable: caller is not the owner');
        _;
      }
    
      /**
       * @dev Leaves the contract without owner. It will not be possible to call
       * `onlyOwner` functions anymore. Can only be called by the current owner.
       *
       * NOTE: Renouncing ownership will leave the contract without an owner,
       * thereby removing any functionality that is only available to the owner.
       */
      function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
      }
    
      /**
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
       * Can only be called by the current owner.
       */
      function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
      }
    }

    // SPDX-License-Identifier: MIT
    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 GSN 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 payable) {
        return payable(msg.sender);
      }
    
      function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
      }
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    
    
    
    interface IPeggedOracle {
        function decimals() external view returns (uint8);
        function latestAnswer() external view returns (int256);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    interface IICHIVault {
        /**
         * @notice Gets total supply of LP tokens
         * @return Total supply of LP tokens
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @notice Gets the address of token0
         * @return Address of token0
         */
        function token0() external view returns (address);
    
        /**
         * @notice Gets the address of token1
         * @return Address of token1
         */
        function token1() external view returns (address);
    
        /**
         * @notice Calculates total quantity of token0 and token1 in both positions (and unused in the ICHIVault)
         * @return total0 Quantity of token0 in both positions (and unused in the ICHIVault)
         * @return total1 Quantity of token1 in both positions (and unused in the ICHIVault)
         */
        function getTotalAmounts() external view returns (uint256 total0, uint256 total1);
    
        function allowToken0() external view returns(bool);
        function allowToken1() external view returns(bool);
        function deposit(uint256 amount0, uint256 amount1, address to) external returns(uint256 shares);
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    import {IPoolAddressesProvider} from "IPoolAddressesProvider.sol";
    import {DataTypes} from "DataTypes.sol";
    
    /**
     * @title IPool
     * @author Aave
     * @notice Defines the basic interface for an Aave Pool.
     */
    interface IPool {
      /**
       * @dev Emitted on mintUnbacked()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address initiating the supply
       * @param onBehalfOf The beneficiary of the supplied assets, receiving the aTokens
       * @param amount The amount of supplied assets
       * @param referralCode The referral code used
       */
      event MintUnbacked(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on backUnbacked()
       * @param reserve The address of the underlying asset of the reserve
       * @param backer The address paying for the backing
       * @param amount The amount added as backing
       * @param fee The amount paid in fees
       */
      event BackUnbacked(address indexed reserve, address indexed backer, uint256 amount, uint256 fee);
    
      /**
       * @dev Emitted on supply()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address initiating the supply
       * @param onBehalfOf The beneficiary of the supply, receiving the aTokens
       * @param amount The amount supplied
       * @param referralCode The referral code used
       */
      event Supply(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on withdraw()
       * @param reserve The address of the underlying asset being withdrawn
       * @param user The address initiating the withdrawal, owner of aTokens
       * @param to The address that will receive the underlying
       * @param amount The amount to be withdrawn
       */
      event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
    
      /**
       * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
       * @param reserve The address of the underlying asset being borrowed
       * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
       * initiator of the transaction on flashLoan()
       * @param onBehalfOf The address that will be getting the debt
       * @param amount The amount borrowed out
       * @param interestRateMode The rate mode: 1 for Stable, 2 for Variable
       * @param borrowRate The numeric rate at which the user has borrowed, expressed in ray
       * @param referralCode The referral code used
       */
      event Borrow(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 borrowRate,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted on repay()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The beneficiary of the repayment, getting his debt reduced
       * @param repayer The address of the user initiating the repay(), providing the funds
       * @param amount The amount repaid
       * @param useATokens True if the repayment is done using aTokens, `false` if done with underlying asset directly
       */
      event Repay(
        address indexed reserve,
        address indexed user,
        address indexed repayer,
        uint256 amount,
        bool useATokens
      );
    
      /**
       * @dev Emitted on swapBorrowRateMode()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user swapping his rate mode
       * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
       */
      event SwapBorrowRateMode(
        address indexed reserve,
        address indexed user,
        DataTypes.InterestRateMode interestRateMode
      );
    
      /**
       * @dev Emitted on borrow(), repay() and liquidationCall() when using isolated assets
       * @param asset The address of the underlying asset of the reserve
       * @param totalDebt The total isolation mode debt for the reserve
       */
      event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);
    
      /**
       * @dev Emitted when the user selects a certain asset category for eMode
       * @param user The address of the user
       * @param categoryId The category id
       */
      event UserEModeSet(address indexed user, uint8 categoryId);
    
      /**
       * @dev Emitted on setUserUseReserveAsCollateral()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user enabling the usage as collateral
       */
      event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on setUserUseReserveAsCollateral()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user enabling the usage as collateral
       */
      event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on rebalanceStableBorrowRate()
       * @param reserve The address of the underlying asset of the reserve
       * @param user The address of the user for which the rebalance has been executed
       */
      event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
    
      /**
       * @dev Emitted on flashLoan()
       * @param target The address of the flash loan receiver contract
       * @param initiator The address initiating the flash loan
       * @param asset The address of the asset being flash borrowed
       * @param amount The amount flash borrowed
       * @param interestRateMode The flashloan mode: 0 for regular flashloan, 1 for Stable debt, 2 for Variable debt
       * @param premium The fee flash borrowed
       * @param referralCode The referral code used
       */
      event FlashLoan(
        address indexed target,
        address initiator,
        address indexed asset,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 premium,
        uint16 indexed referralCode
      );
    
      /**
       * @dev Emitted when a borrower is liquidated.
       * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
       * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
       * @param user The address of the borrower getting liquidated
       * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
       * @param liquidatedCollateralAmount The amount of collateral received by the liquidator
       * @param liquidator The address of the liquidator
       * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
       * to receive the underlying collateral asset directly
       */
      event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateralAmount,
        address liquidator,
        bool receiveAToken
      );
    
      /**
       * @dev Emitted when the state of a reserve is updated.
       * @param reserve The address of the underlying asset of the reserve
       * @param liquidityRate The next liquidity rate
       * @param stableBorrowRate The next stable borrow rate
       * @param variableBorrowRate The next variable borrow rate
       * @param liquidityIndex The next liquidity index
       * @param variableBorrowIndex The next variable borrow index
       */
      event ReserveDataUpdated(
        address indexed reserve,
        uint256 liquidityRate,
        uint256 stableBorrowRate,
        uint256 variableBorrowRate,
        uint256 liquidityIndex,
        uint256 variableBorrowIndex
      );
    
      /**
       * @dev Emitted when the protocol treasury receives minted aTokens from the accrued interest.
       * @param reserve The address of the reserve
       * @param amountMinted The amount minted to the treasury
       */
      event MintedToTreasury(address indexed reserve, uint256 amountMinted);
    
      /**
       * @notice Mints an `amount` of aTokens to the `onBehalfOf`
       * @param asset The address of the underlying asset to mint
       * @param amount The amount to mint
       * @param onBehalfOf The address that will receive the aTokens
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function mintUnbacked(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Back the current unbacked underlying with `amount` and pay `fee`.
       * @param asset The address of the underlying asset to back
       * @param amount The amount to back
       * @param fee The amount paid in fees
       * @return The backed amount
       */
      function backUnbacked(address asset, uint256 amount, uint256 fee) external returns (uint256);
    
      /**
       * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
       * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    
      /**
       * @notice Supply with transfer approval of asset to be supplied done via permit function
       * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param deadline The deadline timestamp that the permit is valid
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       * @param permitV The V parameter of ERC712 permit sig
       * @param permitR The R parameter of ERC712 permit sig
       * @param permitS The S parameter of ERC712 permit sig
       */
      function supplyWithPermit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
      ) external;
    
      /**
       * @notice Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
       * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
       * @param asset The address of the underlying asset to withdraw
       * @param amount The underlying amount to be withdrawn
       *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
       * @param to The address that will receive the underlying, same as msg.sender if the user
       *   wants to receive it on his own wallet, or a different address if the beneficiary is a
       *   different wallet
       * @return The final amount withdrawn
       */
      function withdraw(address asset, uint256 amount, address to) external returns (uint256);
    
      /**
       * @notice Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
       * already supplied enough collateral, or he was given enough allowance by a credit delegator on the
       * corresponding debt token (StableDebtToken or VariableDebtToken)
       * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
       *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
       * @param asset The address of the underlying asset to borrow
       * @param amount The amount to be borrowed
       * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       * @param onBehalfOf The address of the user who will receive the debt. Should be the address of the borrower itself
       * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
       * if he has been given credit delegation allowance
       */
      function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
      ) external;
    
      /**
       * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
       * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @param onBehalfOf The address of the user who will get his debt reduced/removed. Should be the address of the
       * user calling the function if he wants to reduce/remove his own debt, or the address of any other
       * other borrower whose debt should be removed
       * @return The final amount repaid
       */
      function repay(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
      ) external returns (uint256);
    
      /**
       * @notice Repay with transfer approval of asset to be repaid done via permit function
       * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
       * user calling the function if he wants to reduce/remove his own debt, or the address of any other
       * other borrower whose debt should be removed
       * @param deadline The deadline timestamp that the permit is valid
       * @param permitV The V parameter of ERC712 permit sig
       * @param permitR The R parameter of ERC712 permit sig
       * @param permitS The S parameter of ERC712 permit sig
       * @return The final amount repaid
       */
      function repayWithPermit(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
      ) external returns (uint256);
    
      /**
       * @notice Repays a borrowed `amount` on a specific reserve using the reserve aTokens, burning the
       * equivalent debt tokens
       * - E.g. User repays 100 USDC using 100 aUSDC, burning 100 variable/stable debt tokens
       * @dev  Passing uint256.max as amount will clean up any residual aToken dust balance, if the user aToken
       * balance is not enough to cover the whole debt
       * @param asset The address of the borrowed underlying asset previously borrowed
       * @param amount The amount to repay
       * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
       * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
       * @return The final amount repaid
       */
      function repayWithATokens(
        address asset,
        uint256 amount,
        uint256 interestRateMode
      ) external returns (uint256);
    
      /**
       * @notice Allows a borrower to swap his debt between stable and variable mode, or vice versa
       * @param asset The address of the underlying asset borrowed
       * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
       */
      function swapBorrowRateMode(address asset, uint256 interestRateMode) external;
    
      /**
       * @notice Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
       * - Users can be rebalanced if the following conditions are satisfied:
       *     1. Usage ratio is above 95%
       *     2. the current supply APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too
       *        much has been borrowed at a stable rate and suppliers are not earning enough
       * @param asset The address of the underlying asset borrowed
       * @param user The address of the user to be rebalanced
       */
      function rebalanceStableBorrowRate(address asset, address user) external;
    
      /**
       * @notice Allows suppliers to enable/disable a specific supplied asset as collateral
       * @param asset The address of the underlying asset supplied
       * @param useAsCollateral True if the user wants to use the supply as collateral, false otherwise
       */
      function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
    
      /**
       * @notice Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
       * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
       *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
       * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
       * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
       * @param user The address of the borrower getting liquidated
       * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
       * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
       * to receive the underlying collateral asset directly
       */
      function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
      ) external;
    
      /**
       * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
       * as long as the amount taken plus a fee is returned.
       * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
       * into consideration. For further details please visit https://docs.aave.com/developers/
       * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanReceiver interface
       * @param assets The addresses of the assets being flash-borrowed
       * @param amounts The amounts of the assets being flash-borrowed
       * @param interestRateModes Types of the debt to open if the flash loan is not returned:
       *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
       *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
       *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
       * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
       * @param params Variadic packed params to pass to the receiver as extra information
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function flashLoan(
        address receiverAddress,
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata interestRateModes,
        address onBehalfOf,
        bytes calldata params,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
       * as long as the amount taken plus a fee is returned.
       * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
       * into consideration. For further details please visit https://docs.aave.com/developers/
       * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanSimpleReceiver interface
       * @param asset The address of the asset being flash-borrowed
       * @param amount The amount of the asset being flash-borrowed
       * @param params Variadic packed params to pass to the receiver as extra information
       * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
      ) external;
    
      /**
       * @notice Returns the user account data across all the reserves
       * @param user The address of the user
       * @return totalCollateralBase The total collateral of the user in the base currency used by the price feed
       * @return totalDebtBase The total debt of the user in the base currency used by the price feed
       * @return availableBorrowsBase The borrowing power left of the user in the base currency used by the price feed
       * @return currentLiquidationThreshold The liquidation threshold of the user
       * @return ltv The loan to value of The user
       * @return healthFactor The current health factor of the user
       */
      function getUserAccountData(
        address user
      )
        external
        view
        returns (
          uint256 totalCollateralBase,
          uint256 totalDebtBase,
          uint256 availableBorrowsBase,
          uint256 currentLiquidationThreshold,
          uint256 ltv,
          uint256 healthFactor
        );
    
      /**
       * @notice Initializes a reserve, activating it, assigning an aToken and debt tokens and an
       * interest rate strategy
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param aTokenAddress The address of the aToken that will be assigned to the reserve
       * @param stableDebtAddress The address of the StableDebtToken that will be assigned to the reserve
       * @param variableDebtAddress The address of the VariableDebtToken that will be assigned to the reserve
       * @param interestRateStrategyAddress The address of the interest rate strategy contract
       */
      function initReserve(
        address asset,
        address aTokenAddress,
        address stableDebtAddress,
        address variableDebtAddress,
        address interestRateStrategyAddress
      ) external;
    
      /**
       * @notice Drop a reserve
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       */
      function dropReserve(address asset) external;
    
      /**
       * @notice Updates the address of the interest rate strategy contract
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param rateStrategyAddress The address of the interest rate strategy contract
       */
      function setReserveInterestRateStrategyAddress(
        address asset,
        address rateStrategyAddress
      ) external;
    
      /**
       * @notice Sets the configuration bitmap of the reserve as a whole
       * @dev Only callable by the PoolConfigurator contract
       * @param asset The address of the underlying asset of the reserve
       * @param configuration The new configuration bitmap
       */
      function setConfiguration(
        address asset,
        DataTypes.ReserveConfigurationMap calldata configuration
      ) external;
    
      /**
       * @notice Returns the configuration of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The configuration of the reserve
       */
      function getConfiguration(
        address asset
      ) external view returns (DataTypes.ReserveConfigurationMap memory);
    
      /**
       * @notice Returns the configuration of the user across all the reserves
       * @param user The user address
       * @return The configuration of the user
       */
      function getUserConfiguration(
        address user
      ) external view returns (DataTypes.UserConfigurationMap memory);
    
      /**
       * @notice Returns the normalized income of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The reserve's normalized income
       */
      function getReserveNormalizedIncome(address asset) external view returns (uint256);
    
      /**
       * @notice Returns the normalized variable debt per unit of asset
       * @dev WARNING: This function is intended to be used primarily by the protocol itself to get a
       * "dynamic" variable index based on time, current stored index and virtual rate at the current
       * moment (approx. a borrower would get if opening a position). This means that is always used in
       * combination with variable debt supply/balances.
       * If using this function externally, consider that is possible to have an increasing normalized
       * variable debt that is not equivalent to how the variable debt index would be updated in storage
       * (e.g. only updates with non-zero variable debt supply)
       * @param asset The address of the underlying asset of the reserve
       * @return The reserve normalized variable debt
       */
      function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
    
      /**
       * @notice Returns the state and configuration of the reserve
       * @param asset The address of the underlying asset of the reserve
       * @return The state and configuration data of the reserve
       */
      function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
    
      /**
       * @notice Validates and finalizes an aToken transfer
       * @dev Only callable by the overlying aToken of the `asset`
       * @param asset The address of the underlying asset of the aToken
       * @param from The user from which the aTokens are transferred
       * @param to The user receiving the aTokens
       * @param amount The amount being transferred/withdrawn
       * @param balanceFromBefore The aToken balance of the `from` user before the transfer
       * @param balanceToBefore The aToken balance of the `to` user before the transfer
       */
      function finalizeTransfer(
        address asset,
        address from,
        address to,
        uint256 amount,
        uint256 balanceFromBefore,
        uint256 balanceToBefore
      ) external;
    
      /**
       * @notice Returns the list of the underlying assets of all the initialized reserves
       * @dev It does not include dropped reserves
       * @return The addresses of the underlying assets of the initialized reserves
       */
      function getReservesList() external view returns (address[] memory);
    
      /**
       * @notice Returns the address of the underlying asset of a reserve by the reserve id as stored in the DataTypes.ReserveData struct
       * @param id The id of the reserve as stored in the DataTypes.ReserveData struct
       * @return The address of the reserve associated with id
       */
      function getReserveAddressById(uint16 id) external view returns (address);
    
      /**
       * @notice Returns the PoolAddressesProvider connected to this contract
       * @return The address of the PoolAddressesProvider
       */
      function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
    
      /**
       * @notice Updates the protocol fee on the bridging
       * @param bridgeProtocolFee The part of the premium sent to the protocol treasury
       */
      function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;
    
      /**
       * @notice Updates flash loan premiums. Flash loan premium consists of two parts:
       * - A part is sent to aToken holders as extra, one time accumulated interest
       * - A part is collected by the protocol treasury
       * @dev The total premium is calculated on the total borrowed amount
       * @dev The premium to protocol is calculated on the total premium, being a percentage of `flashLoanPremiumTotal`
       * @dev Only callable by the PoolConfigurator contract
       * @param flashLoanPremiumTotal The total premium, expressed in bps
       * @param flashLoanPremiumToProtocol The part of the premium sent to the protocol treasury, expressed in bps
       */
      function updateFlashloanPremiums(
        uint128 flashLoanPremiumTotal,
        uint128 flashLoanPremiumToProtocol
      ) external;
    
      /**
       * @notice Configures a new category for the eMode.
       * @dev In eMode, the protocol allows very high borrowing power to borrow assets of the same category.
       * The category 0 is reserved as it's the default for volatile assets
       * @param id The id of the category
       * @param config The configuration of the category
       */
      function configureEModeCategory(uint8 id, DataTypes.EModeCategory memory config) external;
    
      /**
       * @notice Returns the data of an eMode category
       * @param id The id of the category
       * @return The configuration data of the category
       */
      function getEModeCategoryData(uint8 id) external view returns (DataTypes.EModeCategory memory);
    
      /**
       * @notice Allows a user to use the protocol in eMode
       * @param categoryId The id of the category
       */
      function setUserEMode(uint8 categoryId) external;
    
      /**
       * @notice Returns the eMode the user is using
       * @param user The address of the user
       * @return The eMode id
       */
      function getUserEMode(address user) external view returns (uint256);
    
      /**
       * @notice Resets the isolation mode total debt of the given asset to zero
       * @dev It requires the given asset has zero debt ceiling
       * @param asset The address of the underlying asset to reset the isolationModeTotalDebt
       */
      function resetIsolationModeTotalDebt(address asset) external;
    
      /**
       * @notice Returns the percentage of available liquidity that can be borrowed at once at stable rate
       * @return The percentage of available liquidity to borrow, expressed in bps
       */
      function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);
    
      /**
       * @notice Returns the total fee on flash loans
       * @return The total fee on flashloans
       */
      function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);
    
      /**
       * @notice Returns the part of the bridge fees sent to protocol
       * @return The bridge fee sent to the protocol treasury
       */
      function BRIDGE_PROTOCOL_FEE() external view returns (uint256);
    
      /**
       * @notice Returns the part of the flashloan fees sent to protocol
       * @return The flashloan fee sent to the protocol treasury
       */
      function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);
    
      /**
       * @notice Returns the maximum number of reserves supported to be listed in this Pool
       * @return The maximum number of reserves supported
       */
      function MAX_NUMBER_RESERVES() external view returns (uint16);
    
      /**
       * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens
       * @param assets The list of reserves for which the minting needs to be executed
       */
      function mintToTreasury(address[] calldata assets) external;
    
      /**
       * @notice Rescue and transfer tokens locked in this contract
       * @param token The address of the token
       * @param to The address of the recipient
       * @param amount The amount of token to transfer
       */
      function rescueTokens(address token, address to, uint256 amount) external;
    
      /**
       * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
       * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
       * @dev Deprecated: Use the `supply` function instead
       * @param asset The address of the underlying asset to supply
       * @param amount The amount to be supplied
       * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
       *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
       *   is a different wallet
       * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
       *   0 if the action is executed directly by the user, without any middle-man
       */
      function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
    }

    // SPDX-License-Identifier: AGPL-3.0
    pragma solidity ^0.8.0;
    
    /**
     * @title IPoolAddressesProvider
     * @author Aave
     * @notice Defines the basic interface for a Pool Addresses Provider.
     */
    interface IPoolAddressesProvider {
      /**
       * @dev Emitted when the market identifier is updated.
       * @param oldMarketId The old id of the market
       * @param newMarketId The new id of the market
       */
      event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);
    
      /**
       * @dev Emitted when the pool is updated.
       * @param oldAddress The old address of the Pool
       * @param newAddress The new address of the Pool
       */
      event PoolUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the pool configurator is updated.
       * @param oldAddress The old address of the PoolConfigurator
       * @param newAddress The new address of the PoolConfigurator
       */
      event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the price oracle is updated.
       * @param oldAddress The old address of the PriceOracle
       * @param newAddress The new address of the PriceOracle
       */
      event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the ACL manager is updated.
       * @param oldAddress The old address of the ACLManager
       * @param newAddress The new address of the ACLManager
       */
      event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the ACL admin is updated.
       * @param oldAddress The old address of the ACLAdmin
       * @param newAddress The new address of the ACLAdmin
       */
      event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the price oracle sentinel is updated.
       * @param oldAddress The old address of the PriceOracleSentinel
       * @param newAddress The new address of the PriceOracleSentinel
       */
      event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the pool data provider is updated.
       * @param oldAddress The old address of the PoolDataProvider
       * @param newAddress The new address of the PoolDataProvider
       */
      event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when a new proxy is created.
       * @param id The identifier of the proxy
       * @param proxyAddress The address of the created proxy contract
       * @param implementationAddress The address of the implementation contract
       */
      event ProxyCreated(
        bytes32 indexed id,
        address indexed proxyAddress,
        address indexed implementationAddress
      );
    
      /**
       * @dev Emitted when a new non-proxied contract address is registered.
       * @param id The identifier of the contract
       * @param oldAddress The address of the old contract
       * @param newAddress The address of the new contract
       */
      event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);
    
      /**
       * @dev Emitted when the implementation of the proxy registered with id is updated
       * @param id The identifier of the contract
       * @param proxyAddress The address of the proxy contract
       * @param oldImplementationAddress The address of the old implementation contract
       * @param newImplementationAddress The address of the new implementation contract
       */
      event AddressSetAsProxy(
        bytes32 indexed id,
        address indexed proxyAddress,
        address oldImplementationAddress,
        address indexed newImplementationAddress
      );
    
      /**
       * @notice Returns the id of the Aave market to which this contract points to.
       * @return The market id
       */
      function getMarketId() external view returns (string memory);
    
      /**
       * @notice Associates an id with a specific PoolAddressesProvider.
       * @dev This can be used to create an onchain registry of PoolAddressesProviders to
       * identify and validate multiple Aave markets.
       * @param newMarketId The market id
       */
      function setMarketId(string calldata newMarketId) external;
    
      /**
       * @notice Returns an address by its identifier.
       * @dev The returned address might be an EOA or a contract, potentially proxied
       * @dev It returns ZERO if there is no registered address with the given id
       * @param id The id
       * @return The address of the registered for the specified id
       */
      function getAddress(bytes32 id) external view returns (address);
    
      /**
       * @notice General function to update the implementation of a proxy registered with
       * certain `id`. If there is no proxy registered, it will instantiate one and
       * set as implementation the `newImplementationAddress`.
       * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
       * setter function, in order to avoid unexpected consequences
       * @param id The id
       * @param newImplementationAddress The address of the new implementation
       */
      function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;
    
      /**
       * @notice Sets an address for an id replacing the address saved in the addresses map.
       * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
       * @param id The id
       * @param newAddress The address to set
       */
      function setAddress(bytes32 id, address newAddress) external;
    
      /**
       * @notice Returns the address of the Pool proxy.
       * @return The Pool proxy address
       */
      function getPool() external view returns (address);
    
      /**
       * @notice Updates the implementation of the Pool, or creates a proxy
       * setting the new `pool` implementation when the function is called for the first time.
       * @param newPoolImpl The new Pool implementation
       */
      function setPoolImpl(address newPoolImpl) external;
    
      /**
       * @notice Returns the address of the PoolConfigurator proxy.
       * @return The PoolConfigurator proxy address
       */
      function getPoolConfigurator() external view returns (address);
    
      /**
       * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
       * setting the new `PoolConfigurator` implementation when the function is called for the first time.
       * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
       */
      function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;
    
      /**
       * @notice Returns the address of the price oracle.
       * @return The address of the PriceOracle
       */
      function getPriceOracle() external view returns (address);
    
      /**
       * @notice Updates the address of the price oracle.
       * @param newPriceOracle The address of the new PriceOracle
       */
      function setPriceOracle(address newPriceOracle) external;
    
      /**
       * @notice Returns the address of the ACL manager.
       * @return The address of the ACLManager
       */
      function getACLManager() external view returns (address);
    
      /**
       * @notice Updates the address of the ACL manager.
       * @param newAclManager The address of the new ACLManager
       */
      function setACLManager(address newAclManager) external;
    
      /**
       * @notice Returns the address of the ACL admin.
       * @return The address of the ACL admin
       */
      function getACLAdmin() external view returns (address);
    
      /**
       * @notice Updates the address of the ACL admin.
       * @param newAclAdmin The address of the new ACL admin
       */
      function setACLAdmin(address newAclAdmin) external;
    
      /**
       * @notice Returns the address of the price oracle sentinel.
       * @return The address of the PriceOracleSentinel
       */
      function getPriceOracleSentinel() external view returns (address);
    
      /**
       * @notice Updates the address of the price oracle sentinel.
       * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
       */
      function setPriceOracleSentinel(address newPriceOracleSentinel) external;
    
      /**
       * @notice Returns the address of the data provider.
       * @return The address of the DataProvider
       */
      function getPoolDataProvider() external view returns (address);
    
      /**
       * @notice Updates the address of the data provider.
       * @param newDataProvider The address of the new DataProvider
       */
      function setPoolDataProvider(address newDataProvider) external;
    }

    // SPDX-License-Identifier: BUSL-1.1
    pragma solidity ^0.8.0;
    
    library DataTypes {
      struct ReserveData {
        //stores the reserve configuration
        ReserveConfigurationMap configuration;
        //the liquidity index. Expressed in ray
        uint128 liquidityIndex;
        //the current supply rate. Expressed in ray
        uint128 currentLiquidityRate;
        //variable borrow index. Expressed in ray
        uint128 variableBorrowIndex;
        //the current variable borrow rate. Expressed in ray
        uint128 currentVariableBorrowRate;
        //the current stable borrow rate. Expressed in ray
        uint128 currentStableBorrowRate;
        //timestamp of last update
        uint40 lastUpdateTimestamp;
        //the id of the reserve. Represents the position in the list of the active reserves
        uint16 id;
        //aToken address
        address aTokenAddress;
        //stableDebtToken address
        address stableDebtTokenAddress;
        //variableDebtToken address
        address variableDebtTokenAddress;
        //address of the interest rate strategy
        address interestRateStrategyAddress;
        //the current treasury balance, scaled
        uint128 accruedToTreasury;
        //the outstanding unbacked aTokens minted through the bridging feature
        uint128 unbacked;
        //the outstanding debt borrowed against this asset in isolation mode
        uint128 isolationModeTotalDebt;
      }
    
      struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: stable rate borrowing enabled
        //bit 60: asset is paused
        //bit 61: borrowing in isolation mode is enabled
        //bit 62: siloed borrowing enabled
        //bit 63: flashloaning enabled
        //bit 64-79: reserve factor
        //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
        //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
        //bit 152-167 liquidation protocol fee
        //bit 168-175 eMode category
        //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
        //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
        //bit 252-255 unused
    
        uint256 data;
      }
    
      struct UserConfigurationMap {
        /**
         * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
         * The first bit indicates if an asset is used as collateral by the user, the second whether an
         * asset is borrowed by the user.
         */
        uint256 data;
      }
    
      struct EModeCategory {
        // each eMode category has a custom ltv and liquidation threshold
        uint16 ltv;
        uint16 liquidationThreshold;
        uint16 liquidationBonus;
        // each eMode category may or may not have a custom oracle to override the individual assets price oracles
        address priceSource;
        string label;
      }
    
      enum InterestRateMode {NONE, STABLE, VARIABLE}
    
      struct ReserveCache {
        uint256 currScaledVariableDebt;
        uint256 nextScaledVariableDebt;
        uint256 currPrincipalStableDebt;
        uint256 currAvgStableBorrowRate;
        uint256 currTotalStableDebt;
        uint256 nextAvgStableBorrowRate;
        uint256 nextTotalStableDebt;
        uint256 currLiquidityIndex;
        uint256 nextLiquidityIndex;
        uint256 currVariableBorrowIndex;
        uint256 nextVariableBorrowIndex;
        uint256 currLiquidityRate;
        uint256 currVariableBorrowRate;
        uint256 reserveFactor;
        ReserveConfigurationMap reserveConfiguration;
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        uint40 reserveLastUpdateTimestamp;
        uint40 stableDebtLastUpdateTimestamp;
      }
    
      struct ExecuteLiquidationCallParams {
        uint256 reservesCount;
        uint256 debtToCover;
        address collateralAsset;
        address debtAsset;
        address user;
        bool receiveAToken;
        address priceOracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
      }
    
      struct ExecuteSupplyParams {
        address asset;
        uint256 amount;
        address onBehalfOf;
        uint16 referralCode;
      }
    
      struct ExecuteBorrowParams {
        address asset;
        address user;
        address onBehalfOf;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint16 referralCode;
        bool releaseUnderlying;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
      }
    
      struct ExecuteRepayParams {
        address asset;
        uint256 amount;
        InterestRateMode interestRateMode;
        address onBehalfOf;
        bool useATokens;
      }
    
      struct ExecuteWithdrawParams {
        address asset;
        uint256 amount;
        address to;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
      }
    
      struct ExecuteSetUserEModeParams {
        uint256 reservesCount;
        address oracle;
        uint8 categoryId;
      }
    
      struct FinalizeTransferParams {
        address asset;
        address from;
        address to;
        uint256 amount;
        uint256 balanceFromBefore;
        uint256 balanceToBefore;
        uint256 reservesCount;
        address oracle;
        uint8 fromEModeCategory;
      }
    
      struct FlashloanParams {
        address receiverAddress;
        address[] assets;
        uint256[] amounts;
        uint256[] interestRateModes;
        address onBehalfOf;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address addressesProvider;
        uint8 userEModeCategory;
        bool isAuthorizedFlashBorrower;
      }
    
      struct FlashloanSimpleParams {
        address receiverAddress;
        address asset;
        uint256 amount;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
      }
    
      struct FlashLoanRepaymentParams {
        uint256 amount;
        uint256 totalPremium;
        uint256 flashLoanPremiumToProtocol;
        address asset;
        address receiverAddress;
        uint16 referralCode;
      }
    
      struct CalculateUserAccountDataParams {
        UserConfigurationMap userConfig;
        uint256 reservesCount;
        address user;
        address oracle;
        uint8 userEModeCategory;
      }
    
      struct ValidateBorrowParams {
        ReserveCache reserveCache;
        UserConfigurationMap userConfig;
        address asset;
        address userAddress;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint256 maxStableLoanPercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
        bool isolationModeActive;
        address isolationModeCollateralAddress;
        uint256 isolationModeDebtCeiling;
      }
    
      struct ValidateLiquidationCallParams {
        ReserveCache debtReserveCache;
        uint256 totalDebt;
        uint256 healthFactor;
        address priceOracleSentinel;
      }
    
      struct CalculateInterestRatesParams {
        uint256 unbacked;
        uint256 liquidityAdded;
        uint256 liquidityTaken;
        uint256 totalStableDebt;
        uint256 totalVariableDebt;
        uint256 averageStableBorrowRate;
        uint256 reserveFactor;
        address reserve;
        address aToken;
      }
    
      struct InitReserveParams {
        address asset;
        address aTokenAddress;
        address stableDebtAddress;
        address variableDebtAddress;
        address interestRateStrategyAddress;
        uint16 reservesCount;
        uint16 maxNumberReserves;
      }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    interface IBeefyVault {
        /**
         * @notice Gets the total supply of vault shares
         * @return Total supply of shares
         */
        function totalSupply() external view returns (uint256);
    
        /**
         * @notice Function for various UIs to display the current value of one of our yield tokens.
         * @return An uint256 with 18 decimals of how much underlying asset one vault share represents.
         */
        function getPricePerFullShare() external view returns (uint256);
    
        function want() external view returns (address);
    
        function deposit(uint256 amount) external;
    }

    Context size (optional):