AliceV2PositionParser

{{
  "language": "Solidity",
  "sources": {
    "contracts/release/extensions/external-position-manager/external-positions/alice-v2/AliceV2PositionParser.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity 0.8.19;

import {IAliceInstantOrderV2} from "../../../../../external-interfaces/IAliceInstantOrderV2.sol";
import {IERC20} from "../../../../../external-interfaces/IERC20.sol";
import {AddressArrayLib} from "../../../../../utils/0.8.19/AddressArrayLib.sol";
import {Uint256ArrayLib} from "../../../../../utils/0.8.19/Uint256ArrayLib.sol";
import {IExternalPositionParser} from "../../IExternalPositionParser.sol";
import {AliceV2PositionLibBase1} from "./bases/AliceV2PositionLibBase1.sol";
import {IAliceV2Position} from "./IAliceV2Position.sol";

/// @title AliceV2PositionParser
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice Parser for Morpho Positions
contract AliceV2PositionParser is IExternalPositionParser {
    using AddressArrayLib for address[];
    using Uint256ArrayLib for uint256[];

    address public constant ALICE_NATIVE_ETH = address(0);
    IAliceInstantOrderV2 public immutable ALICE_V2_ORDER_MANAGER;
    address public immutable WRAPPED_NATIVE_TOKEN_ADDRESS;

    error InvalidActionId();

    error DuplicateOrderId();

    error UnknownOrderId();

    constructor(address _aliceV2OrderManagerAddress, address _wrappedNativeAssetAddress) {
        ALICE_V2_ORDER_MANAGER = IAliceInstantOrderV2(_aliceV2OrderManagerAddress);
        WRAPPED_NATIVE_TOKEN_ADDRESS = _wrappedNativeAssetAddress;
    }

    /// @notice Parses the assets to send and receive for the callOnExternalPosition
    /// @param _externalPositionAddress The address of the ExternalPositionProxy
    /// @param _actionId The _actionId for the callOnExternalPosition
    /// @param _encodedActionArgs The encoded parameters for the callOnExternalPosition
    /// @return assetsToTransfer_ The assets to be transferred from the Vault
    /// @return amountsToTransfer_ The amounts to be transferred from the Vault
    /// @return assetsToReceive_ The assets to be received at the Vault
    function parseAssetsForAction(address _externalPositionAddress, uint256 _actionId, bytes memory _encodedActionArgs)
        external
        view
        override
        returns (
            address[] memory assetsToTransfer_,
            uint256[] memory amountsToTransfer_,
            address[] memory assetsToReceive_
        )
    {
        if (_actionId == uint256(IAliceV2Position.Actions.PlaceOrder)) {
            IAliceV2Position.PlaceOrderActionArgs memory placeOrderArgs =
                abi.decode(_encodedActionArgs, (IAliceV2Position.PlaceOrderActionArgs));

            assetsToTransfer_ = new address[](1);
            amountsToTransfer_ = new uint256[](1);

            assetsToTransfer_[0] = __parseAliceV2Asset({_rawAssetAddress: placeOrderArgs.tokenToSell});
            amountsToTransfer_[0] = placeOrderArgs.quantityToSell;
        } else if (_actionId == uint256(IAliceV2Position.Actions.Sweep)) {
            IAliceV2Position.SweepActionArgs memory sweepArgs =
                abi.decode(_encodedActionArgs, (IAliceV2Position.SweepActionArgs));

            // Validate input: check for duplicates and unknown order IDs
            __validateSweepOrderIds(_externalPositionAddress, sweepArgs.orderIds);

            // Sweep can return either the outgoing or incoming asset (depending on if order is settled or cancelled) so we need to include both
            for (uint256 i; i < sweepArgs.orderIds.length; i++) {
                AliceV2PositionLibBase1.OrderDetails memory orderDetails =
                    IAliceV2Position(_externalPositionAddress).getOrderDetails(sweepArgs.orderIds[i]);

                uint256 outgoingAssetBalance = orderDetails.outgoingAssetAddress == ALICE_NATIVE_ETH
                    ? _externalPositionAddress.balance
                    : IERC20(orderDetails.outgoingAssetAddress).balanceOf(_externalPositionAddress);
                uint256 incomingAssetBalance = orderDetails.incomingAssetAddress == ALICE_NATIVE_ETH
                    ? _externalPositionAddress.balance
                    : IERC20(orderDetails.incomingAssetAddress).balanceOf(_externalPositionAddress);

                if (outgoingAssetBalance > 0) {
                    assetsToReceive_ = assetsToReceive_.addUniqueItem(
                        __parseAliceV2Asset({_rawAssetAddress: orderDetails.outgoingAssetAddress})
                    );
                }

                if (incomingAssetBalance > 0) {
                    assetsToReceive_ = assetsToReceive_.addUniqueItem(
                        __parseAliceV2Asset({_rawAssetAddress: orderDetails.incomingAssetAddress})
                    );
                }
            }
        } else if (_actionId == uint256(IAliceV2Position.Actions.RefundOrder)) {
            IAliceV2Position.RefundOrderActionArgs memory refundOrderArgs =
                abi.decode(_encodedActionArgs, (IAliceV2Position.RefundOrderActionArgs));

            AliceV2PositionLibBase1.OrderDetails memory orderDetails =
                IAliceV2Position(_externalPositionAddress).getOrderDetails(refundOrderArgs.orderId);

            assetsToReceive_ = new address[](1);
            assetsToReceive_[0] = __parseAliceV2Asset({_rawAssetAddress: orderDetails.outgoingAssetAddress});
        } else if (_actionId == uint256(IAliceV2Position.Actions.PlaceOrderWithRefId)) {
            IAliceV2Position.PlaceOrderActionArgs memory placeOrderWithRefIdArgs =
                abi.decode(_encodedActionArgs, (IAliceV2Position.PlaceOrderActionArgs));

            assetsToTransfer_ = new address[](1);
            amountsToTransfer_ = new uint256[](1);
            assetsToReceive_ = new address[](2);

            assetsToTransfer_[0] = __parseAliceV2Asset({_rawAssetAddress: placeOrderWithRefIdArgs.tokenToSell});
            amountsToTransfer_[0] = placeOrderWithRefIdArgs.quantityToSell;
            // Adding the incoming token since this can be settled externally
            assetsToReceive_[0] = __parseAliceV2Asset({_rawAssetAddress: placeOrderWithRefIdArgs.tokenToBuy});
            // Adding the outgoing token since this can be cancelled externally
            assetsToReceive_[1] = __parseAliceV2Asset({_rawAssetAddress: placeOrderWithRefIdArgs.tokenToSell});
        } else {
            revert InvalidActionId();
        }

        return (assetsToTransfer_, amountsToTransfer_, assetsToReceive_);
    }

    /// @dev Parses AliceV2 Native Asset into the wrapped native asset, otherwise returns the asset unchanged.
    function __parseAliceV2Asset(address _rawAssetAddress) private view returns (address parsedAssetAddress_) {
        return _rawAssetAddress == ALICE_NATIVE_ETH ? WRAPPED_NATIVE_TOKEN_ADDRESS : _rawAssetAddress;
    }

    /// @dev Helper to validate sweep order IDs for duplicates and unknown orders
    function __validateSweepOrderIds(address _externalPositionAddress, uint256[] memory _orderIds) private view {
        // Check for duplicates using Uint256ArrayLib helper
        if (!_orderIds.isUniqueSet()) {
            revert DuplicateOrderId();
        }

        // Check for unknown order IDs
        for (uint256 i; i < _orderIds.length; i++) {
            AliceV2PositionLibBase1.OrderDetails memory orderDetails =
                IAliceV2Position(_externalPositionAddress).getOrderDetails(_orderIds[i]);
            if (orderDetails.outgoingAssetAddress == address(0) && orderDetails.incomingAssetAddress == address(0)) {
                revert UnknownOrderId();
            }
        }
    }

    /// @notice Parse and validate input arguments to be used when initializing a newly-deployed ExternalPositionProxy
    function parseInitArgs(address, bytes memory) external pure override returns (bytes memory) {
        return "";
    }
}
"
    },
    "contracts/external-interfaces/IAliceInstantOrderV2.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity >=0.6.0 <0.9.0;

/// @title IAliceInstantOrderV2 Interface
/// @author Enzyme Foundation <security@enzyme.finance>
interface IAliceInstantOrderV2 {
    function placeOrder(address _tokenToSell, address _tokenToBuy, uint256 _quantityToSell, uint256 _limitAmountToGet)
        external
        payable;

    function placeOrder(
        address _tokenToSell,
        address _tokenToBuy,
        uint256 _quantityToSell,
        uint256 _limitAmountToGet,
        address _receiver,
        bytes32 _referenceId
    ) external payable;

    function refundOrder(
        uint256 _orderId,
        address _user,
        address _tokenToSell,
        address _tokenToBuy,
        uint256 _quantityToSell,
        uint256 _limitAmountToGet,
        uint256 _timestamp
    ) external;

    function getOrderHash(uint256 _orderId) external view returns (bytes32 orderHash_);

    function getMostRecentOrderId() external view returns (uint256 orderId_);
}
"
    },
    "contracts/external-interfaces/IERC20.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.9.0;

/// @title IERC20 Interface
/// @author Enzyme Foundation <security@enzyme.finance>
interface IERC20 {
    // IERC20 - strict

    function allowance(address _owner, address _spender) external view returns (uint256 allowance_);

    function approve(address _spender, uint256 _value) external returns (bool approve_);

    function balanceOf(address _account) external view returns (uint256 balanceOf_);

    function totalSupply() external view returns (uint256 totalSupply_);

    function transfer(address _to, uint256 _value) external returns (bool transfer_);

    function transferFrom(address _from, address _to, uint256 _value) external returns (bool transferFrom_);

    // IERC20 - typical

    function decimals() external view returns (uint8 decimals_);

    function name() external view returns (string memory name_);

    function symbol() external view returns (string memory symbol_);
}
"
    },
    "contracts/utils/0.8.19/AddressArrayLib.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity 0.8.19;

/// @title AddressArray Library
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice A library to extend the address array data type
library AddressArrayLib {
    /////////////
    // STORAGE //
    /////////////

    /// @dev Helper to remove an item from a storage array
    function removeStorageItem(address[] storage _self, address _itemToRemove) internal returns (bool removed_) {
        uint256 itemCount = _self.length;
        for (uint256 i; i < itemCount; i++) {
            if (_self[i] == _itemToRemove) {
                if (i < itemCount - 1) {
                    _self[i] = _self[itemCount - 1];
                }
                _self.pop();
                removed_ = true;
                break;
            }
        }

        return removed_;
    }

    /// @dev Helper to verify if a storage array contains a particular value
    function storageArrayContains(address[] storage _self, address _target) internal view returns (bool doesContain_) {
        uint256 arrLength = _self.length;
        for (uint256 i; i < arrLength; i++) {
            if (_target == _self[i]) {
                return true;
            }
        }
        return false;
    }

    ////////////
    // MEMORY //
    ////////////

    /// @dev Helper to add an item to an array. Does not assert uniqueness of the new item.
    function addItem(address[] memory _self, address _itemToAdd) internal pure returns (address[] memory nextArray_) {
        nextArray_ = new address[](_self.length + 1);
        for (uint256 i; i < _self.length; i++) {
            nextArray_[i] = _self[i];
        }
        nextArray_[_self.length] = _itemToAdd;

        return nextArray_;
    }

    /// @dev Helper to add an item to an array, only if it is not already in the array.
    function addUniqueItem(address[] memory _self, address _itemToAdd)
        internal
        pure
        returns (address[] memory nextArray_)
    {
        if (contains(_self, _itemToAdd)) {
            return _self;
        }

        return addItem(_self, _itemToAdd);
    }

    /// @dev Helper to verify if an array contains a particular value
    function contains(address[] memory _self, address _target) internal pure returns (bool doesContain_) {
        for (uint256 i; i < _self.length; i++) {
            if (_target == _self[i]) {
                return true;
            }
        }
        return false;
    }

    /// @dev Helper to merge the unique items of a second array.
    /// Does not consider uniqueness of either array, only relative uniqueness.
    /// Preserves ordering.
    function mergeArray(address[] memory _self, address[] memory _arrayToMerge)
        internal
        pure
        returns (address[] memory nextArray_)
    {
        uint256 newUniqueItemCount;
        for (uint256 i; i < _arrayToMerge.length; i++) {
            if (!contains(_self, _arrayToMerge[i])) {
                newUniqueItemCount++;
            }
        }

        if (newUniqueItemCount == 0) {
            return _self;
        }

        nextArray_ = new address[](_self.length + newUniqueItemCount);
        for (uint256 i; i < _self.length; i++) {
            nextArray_[i] = _self[i];
        }
        uint256 nextArrayIndex = _self.length;
        for (uint256 i; i < _arrayToMerge.length; i++) {
            if (!contains(_self, _arrayToMerge[i])) {
                nextArray_[nextArrayIndex] = _arrayToMerge[i];
                nextArrayIndex++;
            }
        }

        return nextArray_;
    }

    /// @dev Helper to verify if array is a set of unique values.
    /// Does not assert length > 0.
    function isUniqueSet(address[] memory _self) internal pure returns (bool isUnique_) {
        if (_self.length <= 1) {
            return true;
        }

        uint256 arrayLength = _self.length;
        for (uint256 i; i < arrayLength; i++) {
            for (uint256 j = i + 1; j < arrayLength; j++) {
                if (_self[i] == _self[j]) {
                    return false;
                }
            }
        }

        return true;
    }

    /// @dev Helper to remove items from an array. Removes all matching occurrences of each item.
    /// Does not assert uniqueness of either array.
    function removeItems(address[] memory _self, address[] memory _itemsToRemove)
        internal
        pure
        returns (address[] memory nextArray_)
    {
        if (_itemsToRemove.length == 0) {
            return _self;
        }

        bool[] memory indexesToRemove = new bool[](_self.length);
        uint256 remainingItemsCount = _self.length;
        for (uint256 i; i < _self.length; i++) {
            if (contains(_itemsToRemove, _self[i])) {
                indexesToRemove[i] = true;
                remainingItemsCount--;
            }
        }

        if (remainingItemsCount == _self.length) {
            nextArray_ = _self;
        } else if (remainingItemsCount > 0) {
            nextArray_ = new address[](remainingItemsCount);
            uint256 nextArrayIndex;
            for (uint256 i; i < _self.length; i++) {
                if (!indexesToRemove[i]) {
                    nextArray_[nextArrayIndex] = _self[i];
                    nextArrayIndex++;
                }
            }
        }

        return nextArray_;
    }
}
"
    },
    "contracts/utils/0.8.19/Uint256ArrayLib.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity 0.8.19;

/// @title Uint256Array Library
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice A library to extend the uint256 array data type
library Uint256ArrayLib {
    /////////////
    // STORAGE //
    /////////////

    /// @dev Helper to remove an item from a storage array
    function removeStorageItem(uint256[] storage _self, uint256 _itemToRemove) internal returns (bool removed_) {
        uint256 itemCount = _self.length;
        for (uint256 i; i < itemCount; i++) {
            if (_self[i] == _itemToRemove) {
                if (i < itemCount - 1) {
                    _self[i] = _self[itemCount - 1];
                }
                _self.pop();
                removed_ = true;
                break;
            }
        }

        return removed_;
    }

    /// @dev Helper to verify if a storage array contains a particular value
    function storageArrayContains(uint256[] storage _self, uint256 _target) internal view returns (bool doesContain_) {
        uint256 arrLength = _self.length;
        for (uint256 i; i < arrLength; i++) {
            if (_target == _self[i]) {
                return true;
            }
        }
        return false;
    }

    ////////////
    // MEMORY //
    ////////////

    /// @dev Helper to add an item to an array. Does not assert uniqueness of the new item.
    function addItem(uint256[] memory _self, uint256 _itemToAdd) internal pure returns (uint256[] memory nextArray_) {
        nextArray_ = new uint256[](_self.length + 1);
        for (uint256 i; i < _self.length; i++) {
            nextArray_[i] = _self[i];
        }
        nextArray_[_self.length] = _itemToAdd;

        return nextArray_;
    }

    /// @dev Helper to add an item to an array, only if it is not already in the array.
    function addUniqueItem(uint256[] memory _self, uint256 _itemToAdd)
        internal
        pure
        returns (uint256[] memory nextArray_)
    {
        if (contains(_self, _itemToAdd)) {
            return _self;
        }

        return addItem(_self, _itemToAdd);
    }

    /// @dev Helper to verify if an array contains a particular value
    function contains(uint256[] memory _self, uint256 _target) internal pure returns (bool doesContain_) {
        for (uint256 i; i < _self.length; i++) {
            if (_target == _self[i]) {
                return true;
            }
        }
        return false;
    }

    /// @dev Helper to merge the unique items of a second array.
    /// Does not consider uniqueness of either array, only relative uniqueness.
    /// Preserves ordering.
    function mergeArray(uint256[] memory _self, uint256[] memory _arrayToMerge)
        internal
        pure
        returns (uint256[] memory nextArray_)
    {
        uint256 newUniqueItemCount;
        for (uint256 i; i < _arrayToMerge.length; i++) {
            if (!contains(_self, _arrayToMerge[i])) {
                newUniqueItemCount++;
            }
        }

        if (newUniqueItemCount == 0) {
            return _self;
        }

        nextArray_ = new uint256[](_self.length + newUniqueItemCount);
        for (uint256 i; i < _self.length; i++) {
            nextArray_[i] = _self[i];
        }
        uint256 nextArrayIndex = _self.length;
        for (uint256 i; i < _arrayToMerge.length; i++) {
            if (!contains(_self, _arrayToMerge[i])) {
                nextArray_[nextArrayIndex] = _arrayToMerge[i];
                nextArrayIndex++;
            }
        }

        return nextArray_;
    }

    /// @dev Helper to verify if array is a set of unique values.
    /// Does not assert length > 0.
    function isUniqueSet(uint256[] memory _self) internal pure returns (bool isUnique_) {
        if (_self.length <= 1) {
            return true;
        }

        uint256 arrayLength = _self.length;
        for (uint256 i; i < arrayLength; i++) {
            for (uint256 j = i + 1; j < arrayLength; j++) {
                if (_self[i] == _self[j]) {
                    return false;
                }
            }
        }

        return true;
    }

    /// @dev Helper to remove items from an array. Removes all matching occurrences of each item.
    /// Does not assert uniqueness of either array.
    function removeItems(uint256[] memory _self, uint256[] memory _itemsToRemove)
        internal
        pure
        returns (uint256[] memory nextArray_)
    {
        if (_itemsToRemove.length == 0) {
            return _self;
        }

        bool[] memory indexesToRemove = new bool[](_self.length);
        uint256 remainingItemsCount = _self.length;
        for (uint256 i; i < _self.length; i++) {
            if (contains(_itemsToRemove, _self[i])) {
                indexesToRemove[i] = true;
                remainingItemsCount--;
            }
        }

        if (remainingItemsCount == _self.length) {
            nextArray_ = _self;
        } else if (remainingItemsCount > 0) {
            nextArray_ = new uint256[](remainingItemsCount);
            uint256 nextArrayIndex;
            for (uint256 i; i < _self.length; i++) {
                if (!indexesToRemove[i]) {
                    nextArray_[nextArrayIndex] = _self[i];
                    nextArrayIndex++;
                }
            }
        }

        return nextArray_;
    }
}
"
    },
    "contracts/release/extensions/external-position-manager/IExternalPositionParser.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity >=0.6.0 <0.9.0;

/// @title IExternalPositionParser Interface
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice Interface for all external position parsers
interface IExternalPositionParser {
    function parseAssetsForAction(address _externalPosition, uint256 _actionId, bytes memory _encodedActionArgs)
        external
        returns (
            address[] memory assetsToTransfer_,
            uint256[] memory amountsToTransfer_,
            address[] memory assetsToReceive_
        );

    function parseInitArgs(address _vaultProxy, bytes memory _initializationData)
        external
        returns (bytes memory initArgs_);
}
"
    },
    "contracts/release/extensions/external-position-manager/external-positions/alice-v2/bases/AliceV2PositionLibBase1.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.

    (c) Enzyme Foundation <security@enzyme.finance>

    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity 0.8.19;

/// @title AliceV2PositionLibBase1 Contract
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice A persistent contract containing all required storage variables and
/// required functions for a AliceV2PositionLib implementation
/// @dev DO NOT EDIT CONTRACT. If new events or storage are necessary, they should be added to
/// a numbered AliceV2PositionLibBaseXXX that inherits the previous base.
/// e.g., `AliceV2PositionLibBase2 is AliceV2PositionLibBase1`
abstract contract AliceV2PositionLibBase1 {
    struct OrderDetails {
        address outgoingAssetAddress;
        address incomingAssetAddress;
        uint256 outgoingAmount;
    }

    event OrderIdAdded(uint256 indexed orderId, OrderDetails orderDetails);

    event OrderIdRemoved(uint256 indexed orderId);

    event ReferenceIdAdded(bytes32 indexed referenceId);

    event ReferenceIdRemoved(bytes32 indexed referenceId);

    uint256[] internal orderIds;

    mapping(uint256 orderId => OrderDetails) orderIdToOrderDetails;

    mapping(bytes32 referenceId => bool isPending) internal referenceIdToIsPending;
}
"
    },
    "contracts/release/extensions/external-position-manager/external-positions/alice-v2/IAliceV2Position.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.
    (c) Enzyme Foundation <security@enzyme.finance>
    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

import {IExternalPosition} from "../../IExternalPosition.sol";
import {AliceV2PositionLibBase1} from "./bases/AliceV2PositionLibBase1.sol";

pragma solidity >=0.6.0 <0.9.0;

/// @title IAliceV2Position Interface
/// @author Enzyme Foundation <security@enzyme.finance>
interface IAliceV2Position is IExternalPosition {
    enum Actions {
        PlaceOrder,
        RefundOrder,
        Sweep,
        PlaceOrderWithRefId
    }

    struct PlaceOrderActionArgs {
        address tokenToSell;
        address tokenToBuy;
        uint256 quantityToSell;
        uint256 limitAmountToGet;
    }

    struct SweepActionArgs {
        uint256[] orderIds;
    }

    struct RefundOrderActionArgs {
        uint256 orderId;
        address tokenToSell;
        address tokenToBuy;
        uint256 quantityToSell;
        uint256 limitAmountToGet;
        uint256 timestamp;
    }

    function getOrderDetails(uint256 _orderId)
        external
        view
        returns (AliceV2PositionLibBase1.OrderDetails memory orderDetails_);

    function getOrderIds() external view returns (uint256[] memory orderIds_);

    function isPendingReferenceId(bytes32 _referenceId) external view returns (bool isPending_);
}
"
    },
    "contracts/release/extensions/external-position-manager/IExternalPosition.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.
    (c) Enzyme Foundation <security@enzyme.finance>
    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity >=0.6.0 <0.9.0;

import {IExternalPositionLibCore} from "../../../persistent/external-positions/IExternalPositionLibCore.sol";

/// @title IExternalPosition Contract
/// @author Enzyme Foundation <security@enzyme.finance>
interface IExternalPosition is IExternalPositionLibCore {
    function getDebtAssets() external returns (address[] memory assets_, uint256[] memory amounts_);

    function getManagedAssets() external returns (address[] memory assets_, uint256[] memory amounts_);

    function init(bytes memory _data) external;
}
"
    },
    "contracts/persistent/external-positions/IExternalPositionLibCore.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0

/*
    This file is part of the Enzyme Protocol.
    (c) Enzyme Foundation <security@enzyme.finance>
    For the full license information, please view the LICENSE
    file that was distributed with this source code.
*/

pragma solidity >=0.6.0 <0.9.0;

/// @title IExternalPositionLibCore interface
/// @author Enzyme Foundation <security@enzyme.finance>
/// @notice An interface for core required functions of an IExternalPositionLib instance
interface IExternalPositionLibCore {
    function receiveCallFromVault(bytes memory _data) external;
}
"
    }
  },
  "settings": {
    "remappings": [
      "@openzeppelin/contracts/=lib/openzeppelin-solc-0.6/contracts/",
      "@uniswap/v3-core/=lib/uniswap-v3-core/",
      "ds-test/=lib/forge-std/lib/ds-test/src/",
      "forge-std/=lib/forge-std/src/",
      "morpho-blue/=lib/morpho-blue/src/libraries/",
      "openzeppelin-solc-0.6/=lib/openzeppelin-solc-0.6/contracts/",
      "openzeppelin-solc-0.7/=lib/openzeppelin-solc-0.7/contracts/",
      "openzeppelin-solc-0.8/=lib/openzeppelin-solc-0.8/contracts/",
      "uniswap-v3-core/=lib/uniswap-v3-core/",
      "uniswap-v3-core-0.8/=lib/uniswap-v3-core-0.8/",
      "uniswap-v3-periphery/=lib/uniswap-v3-periphery/contracts/"
    ],
    "optimizer": {
      "enabled": true,
      "runs": 200,
      "details": {
        "yul": false
      }
    },
    "metadata": {
      "useLiteralContent": false,
      "bytecodeHash": "none",
      "appendCBOR": false
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "evmVersion": "paris",
    "viaIR": false
  }
}}