OneInchV5Evaluator

{{
  "language": "Solidity",
  "sources": {
    "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}
"
    },
    "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165Upgradeable is Initializable, IERC165 {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}
"
    },
    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
    },
    "@openzeppelin/contracts/utils/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}
"
    },
    "@openzeppelin/contracts/utils/introspection/IERC165.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
"
    },
    "contracts/compiler/libraries/Path.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

library Path {
    using Path for bytes;

    uint256 internal constant ADDRESS_LEN = 20;
    uint256 internal constant POOL_ID_LEN = 4;
    uint256 internal constant NEXT_OFFSET = ADDRESS_LEN + POOL_ID_LEN;

    error InvalidPathLength(uint256);

    function extractTokenIn(bytes calldata _path) internal pure returns (address tokenIn_) {
        _path.ensureValid();
        tokenIn_ = _path.extractTokenInUnsafe();
    }

    function extractTokenInUnsafe(bytes calldata _path) internal pure returns (address tokenIn_) {
        tokenIn_ = address(bytes20(_path[0:ADDRESS_LEN]));
    }

    function extractTokenOut(bytes calldata _path) internal pure returns (address tokenOut_) {
        _path.ensureValid();
        tokenOut_ = _path.extractTokenOutUnsafe();
    }

    function extractTokenOutUnsafe(bytes calldata _path) internal pure returns (address tokenOut_) {
        uint256 len = _path.length;
        tokenOut_ = address(bytes20(_path[len - ADDRESS_LEN:len]));
    }

    /* solhint-disable var-name-mixedcase */
    function extractPool(
        bytes calldata _path,
        uint256 _poolNumber
    ) internal pure returns (address tokenIn__, address tokenOut_, uint32 poolId_____) {
        /* solhint-enable var-name-mixedcase */
        _path.ensureValid();
        uint256 ptr = _poolNumber * NEXT_OFFSET;

        tokenIn__ = address(bytes20(_path[ptr:(ptr = ptr + ADDRESS_LEN)]));
        poolId_____ = uint32(bytes4(_path[ptr:(ptr = ptr + POOL_ID_LEN)]));
        tokenOut_ = address(bytes20(_path[ptr:(ptr = ptr + ADDRESS_LEN)]));
    }

    function getNumberOfPools(bytes calldata _path) internal pure returns (uint256) {
        _path.ensureValid();
        return (_path.length - ADDRESS_LEN) / NEXT_OFFSET;
    }

    function ensureValid(bytes calldata _path) internal pure {
        if (!isValid(_path)) revert InvalidPathLength(_path.length);
    }

    function isValid(bytes calldata _path) private pure returns (bool) {
        if (_path.length < ADDRESS_LEN) return false;
        return (_path.length - ADDRESS_LEN) % NEXT_OFFSET == 0;
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorClipper.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IClipperRouter
} from "contracts/interfaces/compliance/internal/oneInchV5/IClipperRouter.sol";

abstract contract OneInchV5ConstructorClipper {
    function constructClipperSwap(
        address clipperExchange,
        address srcToken,
        address dstToken,
        uint256 inputAmount,
        uint256 outputAmount,
        uint256 goodUntil,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(
                IClipperRouter.clipperSwap,
                (clipperExchange, srcToken, dstToken, inputAmount, outputAmount, goodUntil, r, vs)
            );
    }

    function constructClipperSwapTo(
        address clipperExchange,
        address payable recipient,
        address srcToken,
        address dstToken,
        uint256 inputAmount,
        uint256 outputAmount,
        uint256 goodUntil,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(
                IClipperRouter.clipperSwapTo,
                (
                    clipperExchange,
                    recipient,
                    srcToken,
                    dstToken,
                    inputAmount,
                    outputAmount,
                    goodUntil,
                    r,
                    vs
                )
            );
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorGeneric.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IGenericRouter
} from "contracts/interfaces/compliance/internal/oneInchV5/IGenericRouter.sol";

abstract contract OneInchV5ConstructorGeneric {
    function constructSwap(
        address caller,
        IGenericRouter.SwapDescription memory desc,
        bytes memory permit,
        bytes memory data
    ) internal pure returns (bytes memory) {
        return abi.encodeCall(IGenericRouter.swap, (caller, desc, permit, data));
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorOrderMixin.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IOrderLib,
    IOrderMixin
} from "contracts/interfaces/compliance/internal/oneInchV5/IOrderMixin.sol";

abstract contract OneInchV5ConstructorOrderMixin {
    function constructFillOrder(
        IOrderLib.Order memory order,
        bytes memory signature,
        bytes memory interaction,
        uint256 makingAmount,
        uint256 takingAmount,
        uint256 skipPermitAndThresholdAmount
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(
                IOrderMixin.fillOrder,
                (
                    order,
                    signature,
                    interaction,
                    makingAmount,
                    takingAmount,
                    skipPermitAndThresholdAmount
                )
            );
    }

    function constructFillOrderTo(
        IOrderLib.Order memory order,
        bytes memory signature,
        bytes memory interaction,
        uint256 makingAmount,
        uint256 takingAmount,
        uint256 skipPermitAndThresholdAmount,
        address target
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(
                IOrderMixin.fillOrderTo,
                (
                    order,
                    signature,
                    interaction,
                    makingAmount,
                    takingAmount,
                    skipPermitAndThresholdAmount,
                    target
                )
            );
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorOrderRFQMixin.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IOrderRFQLib,
    IOrderRFQMixin
} from "contracts/interfaces/compliance/internal/oneInchV5/IOrderRFQMixin.sol";

abstract contract OneInchV5ConstructorOrderRFQMixin {
    function constructFillOrderRFQ(
        IOrderRFQLib.OrderRFQ memory order,
        bytes memory signature,
        uint256 flagsAndAmount
    ) internal pure returns (bytes memory) {
        return abi.encodeCall(IOrderRFQMixin.fillOrderRFQ, (order, signature, flagsAndAmount));
    }

    function constructFillOrderRFQCompact(
        IOrderRFQLib.OrderRFQ memory order,
        bytes32 r,
        bytes32 vs,
        uint256 flagsAndAmount
    ) internal pure returns (bytes memory) {
        return abi.encodeCall(IOrderRFQMixin.fillOrderRFQCompact, (order, r, vs, flagsAndAmount));
    }

    function constructFillOrderRFQTo(
        IOrderRFQLib.OrderRFQ memory order,
        bytes memory signature,
        uint256 flagsAndAmount,
        address target
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(
                IOrderRFQMixin.fillOrderRFQTo,
                (order, signature, flagsAndAmount, target)
            );
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorUniswapV3.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IUniswapV3Router
} from "contracts/interfaces/compliance/internal/oneInchV5/IUniswapV3Router.sol";

abstract contract OneInchV5ConstructorUniswapV3 {
    function constructUniswapV3Swap(
        uint256 amount,
        uint256 minReturn,
        uint256[] memory pools
    ) internal pure returns (bytes memory) {
        return abi.encodeCall(IUniswapV3Router.uniswapV3Swap, (amount, minReturn, pools));
    }

    function constructUniswapV3SwapTo(
        address payable recipient,
        uint256 amount,
        uint256 minReturn,
        uint256[] memory pools
    ) internal pure returns (bytes memory) {
        return
            abi.encodeCall(IUniswapV3Router.uniswapV3SwapTo, (recipient, amount, minReturn, pools));
    }
}
"
    },
    "contracts/compiler/oneInchV5/actions/OneInchV5ConstructorUnoswap.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IUnoswapRouter
} from "contracts/interfaces/compliance/internal/oneInchV5/IUnoswapRouter.sol";

abstract contract OneInchV5ConstructorUnoswap {
    function constructUnoswap(
        address srcToken,
        uint256 amount,
        uint256 minReturn,
        uint256[] memory pools
    ) internal pure returns (bytes memory data_) {
        return abi.encodeCall(IUnoswapRouter.unoswap, (srcToken, amount, minReturn, pools));
    }

    function constructUnoswapTo(
        address payable recipient,
        address srcToken,
        uint256 amount,
        uint256 minReturn,
        uint256[] memory pools
    ) internal pure returns (bytes memory data_) {
        return
            abi.encodeCall(
                IUnoswapRouter.unoswapTo,
                (recipient, srcToken, amount, minReturn, pools)
            );
    }
}
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5Hub.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {IClipperRouter, OneInchV5HubClipper} from "./OneInchV5HubClipper.sol";
import {IGenericRouter, OneInchV5HubGeneric} from "./OneInchV5HubGeneric.sol";
import {IOrderMixin, OneInchV5HubOrderMixin} from "./OneInchV5HubOrderMixin.sol";
import {IOrderRFQMixin, OneInchV5HubOrderRFQMixin} from "./OneInchV5HubOrderRFQMixin.sol";
import {IUniswapV3Router, OneInchV5HubUniswapV3} from "./OneInchV5HubUniswapV3.sol";
import {IUnoswapRouter, OneInchV5HubUnoswap} from "./OneInchV5HubUnoswap.sol";

struct SwitchResult {
    address tokenIn;
    address tokenOut;
    bytes data;
}

/* solhint-disable ordering */
abstract contract OneInchV5Hub is
    OneInchV5HubClipper,
    OneInchV5HubGeneric,
    OneInchV5HubOrderMixin,
    OneInchV5HubOrderRFQMixin,
    OneInchV5HubUniswapV3,
    OneInchV5HubUnoswap
{
    error UnsupportedOneInchRouterV5Function(bytes4 selector);

    function switchBySelector(
        bytes calldata extraData,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal view returns (SwitchResult memory result) {
        bytes4 selector = bytes4(extraData[:4]);
        bytes calldata payload = extraData[4:];
        if (selector == IGenericRouter.swap.selector) {
            result = swap(payload, amountIn, minAmountOut, recipient);
        } else if (selector == IUnoswapRouter.unoswap.selector) {
            result = unoswap(payload, amountIn, minAmountOut);
        } else if (selector == IUnoswapRouter.unoswapTo.selector) {
            result = unoswapTo(payload, amountIn, minAmountOut, recipient);
        } else if (selector == IUniswapV3Router.uniswapV3Swap.selector) {
            result = uniswapV3Swap(payload, amountIn, minAmountOut);
        } else if (selector == IUniswapV3Router.uniswapV3SwapTo.selector) {
            result = uniswapV3SwapTo(payload, amountIn, minAmountOut, recipient);
        } else if (selector == IClipperRouter.clipperSwap.selector) {
            result = clipperSwap(payload, amountIn, minAmountOut);
        } else if (selector == IClipperRouter.clipperSwapTo.selector) {
            result = clipperSwapTo(payload, amountIn, minAmountOut, recipient);
        } else if (selector == IOrderMixin.fillOrder.selector) {
            result = fillOrder(payload, amountIn, minAmountOut);
        } else if (selector == IOrderMixin.fillOrderTo.selector) {
            result = fillOrderTo(payload, amountIn, minAmountOut, recipient);
        } else if (selector == IOrderRFQMixin.fillOrderRFQ.selector) {
            result = fillOrderRFQ(payload, amountIn);
        } else if (selector == IOrderRFQMixin.fillOrderRFQTo.selector) {
            result = fillOrderRFQTo(payload, amountIn, recipient);
        } else if (selector == IOrderRFQMixin.fillOrderRFQCompact.selector) {
            result = fillOrderRFQCompact(payload, amountIn);
        } else {
            revert UnsupportedOneInchRouterV5Function(selector);
        }
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubClipper.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IClipperRouter,
    OneInchV5ConstructorClipper
} from "../actions/OneInchV5ConstructorClipper.sol";
/* solhint-enable no-unused-import */
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubClipper is OneInchV5ConstructorClipper {
    function clipperSwap(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut
    ) internal pure virtual returns (SwitchResult memory result) {
        (
            address clipperExchange,
            address srcToken,
            address dstToken,
            ,
            ,
            uint256 goodUntil,
            bytes32 r,
            bytes32 vs
        ) = abi.decode(
                payload,
                (address, address, address, uint256, uint256, uint256, bytes32, bytes32)
            );
        result.tokenIn = srcToken;
        result.tokenOut = dstToken;
        result.data = constructClipperSwap(
            clipperExchange,
            srcToken,
            dstToken,
            amountIn,
            minAmountOut,
            goodUntil,
            r,
            vs
        );
    }

    function clipperSwapTo(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal pure virtual returns (SwitchResult memory result) {
        (
            address clipperExchange,
            ,
            address srcToken,
            address dstToken,
            ,
            ,
            uint256 goodUntil,
            bytes32 r,
            bytes32 vs
        ) = abi.decode(
                payload,
                (address, address, address, address, uint256, uint256, uint256, bytes32, bytes32)
            );
        result.tokenIn = srcToken;
        result.tokenOut = dstToken;
        result.data = constructClipperSwapTo(
            clipperExchange,
            recipient,
            srcToken,
            dstToken,
            amountIn,
            minAmountOut,
            goodUntil,
            r,
            vs
        );
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubGeneric.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IGenericRouter,
    OneInchV5ConstructorGeneric
} from "../actions/OneInchV5ConstructorGeneric.sol";
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubGeneric is OneInchV5ConstructorGeneric {
    function swap(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal pure virtual returns (SwitchResult memory result) {
        (
            address executor,
            IGenericRouter.SwapDescription memory desc,
            bytes memory permit,
            bytes memory data
        ) = abi.decode(payload, (address, IGenericRouter.SwapDescription, bytes, bytes));
        desc.amount = amountIn;
        desc.minReturnAmount = minAmountOut;
        desc.dstReceiver = recipient;
        result.tokenIn = desc.srcToken;
        result.tokenOut = desc.dstToken;
        result.data = constructSwap(executor, desc, permit, data);
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubOrderMixin.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IOrderLib,
    IOrderMixin,
    OneInchV5ConstructorOrderMixin
} from "../actions/OneInchV5ConstructorOrderMixin.sol";
/* solhint-enable no-unused-import */
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubOrderMixin is OneInchV5ConstructorOrderMixin {
    function fillOrder(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut
    ) internal pure virtual returns (SwitchResult memory result) {
        (
            IOrderLib.Order memory order,
            bytes memory signature,
            bytes memory interaction,
            ,
            ,
            uint256 skipPermitAndThresholdAmount
        ) = abi.decode(payload, (IOrderLib.Order, bytes, bytes, uint256, uint256, uint256));
        result.tokenIn = order.makerAsset;
        result.tokenOut = order.takerAsset;
        result.data = constructFillOrder(
            order,
            signature,
            interaction,
            minAmountOut,
            amountIn,
            skipPermitAndThresholdAmount
        );
    }

    function fillOrderTo(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal pure virtual returns (SwitchResult memory result) {
        (
            IOrderLib.Order memory order,
            bytes memory signature,
            bytes memory interaction,
            ,
            ,
            uint256 skipPermitAndThresholdAmount,

        ) = abi.decode(
                payload,
                (IOrderLib.Order, bytes, bytes, uint256, uint256, uint256, address)
            );
        result.tokenIn = order.makerAsset;
        result.tokenOut = order.takerAsset;
        result.data = constructFillOrderTo(
            order,
            signature,
            interaction,
            minAmountOut,
            amountIn,
            skipPermitAndThresholdAmount,
            recipient
        );
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubOrderRFQMixin.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IOrderRFQLib,
    IOrderRFQMixin,
    OneInchV5ConstructorOrderRFQMixin
} from "../actions/OneInchV5ConstructorOrderRFQMixin.sol";
/* solhint-enable no-unused-import */
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubOrderRFQMixin is OneInchV5ConstructorOrderRFQMixin {
    uint256 internal constant _MAKER_AMOUNT_FLAG =
        0x8000000000000000000000000000000000000000000000000000000000000000;
    uint256 internal constant _AMOUNT_MASK =
        0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    error MakerAmountFlagIsSet();

    function _getFlagsAndAmount(
        uint256 flagsWithOldAmount,
        uint256 amount
    ) internal pure returns (uint256) {
        if (flagsWithOldAmount & _MAKER_AMOUNT_FLAG != 0) revert MakerAmountFlagIsSet();
        return (flagsWithOldAmount & ~_AMOUNT_MASK) | amount;
    }

    function fillOrderRFQ(
        bytes calldata payload,
        uint256 amountIn
    ) internal pure virtual returns (SwitchResult memory result) {
        (IOrderRFQLib.OrderRFQ memory order, bytes memory signature, uint256 flagsAndAmount) = abi
            .decode(payload, (IOrderRFQLib.OrderRFQ, bytes, uint256));
        result.tokenIn = order.makerAsset;
        result.tokenOut = order.takerAsset;
        flagsAndAmount = _getFlagsAndAmount(flagsAndAmount, amountIn);
        result.data = constructFillOrderRFQ(order, signature, flagsAndAmount);
    }

    function fillOrderRFQCompact(
        bytes calldata payload,
        uint256 amountIn
    ) internal pure virtual returns (SwitchResult memory result) {
        (IOrderRFQLib.OrderRFQ memory order, bytes32 r, bytes32 vs, uint256 flagsAndAmount) = abi
            .decode(payload, (IOrderRFQLib.OrderRFQ, bytes32, bytes32, uint256));
        result.tokenIn = order.makerAsset;
        result.tokenOut = order.takerAsset;
        flagsAndAmount = _getFlagsAndAmount(flagsAndAmount, amountIn);
        result.data = constructFillOrderRFQCompact(order, r, vs, flagsAndAmount);
    }

    function fillOrderRFQTo(
        bytes calldata payload,
        uint256 amountIn,
        address payable recipient
    ) internal pure virtual returns (SwitchResult memory result) {
        (IOrderRFQLib.OrderRFQ memory order, bytes memory signature, uint256 flagsAndAmount, ) = abi
            .decode(payload, (IOrderRFQLib.OrderRFQ, bytes, uint256, address));
        result.tokenIn = order.makerAsset;
        result.tokenOut = order.takerAsset;
        flagsAndAmount = _getFlagsAndAmount(flagsAndAmount, amountIn);
        result.data = constructFillOrderRFQTo(order, signature, flagsAndAmount, recipient);
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubUniswapV3.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IUniswapV3Router,
    OneInchV5ConstructorUniswapV3
} from "../actions/OneInchV5ConstructorUniswapV3.sol";
/* solhint-enable no-unused-import */
import {UniswapTokens} from "../libraries/UniswapTokens.sol";
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubUniswapV3 is OneInchV5ConstructorUniswapV3 {
    using UniswapTokens for uint256;

    function uniswapV3Swap(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut
    ) internal view virtual returns (SwitchResult memory result) {
        (, , uint256[] memory pools) = abi.decode(payload, (uint256, uint256, uint256[]));
        result.tokenIn = pools[0].getUniswapSrcToken();
        result.tokenOut = pools[pools.length - 1].getUniswapDstToken();
        result.data = constructUniswapV3Swap(amountIn, minAmountOut, pools);
    }

    function uniswapV3SwapTo(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal view virtual returns (SwitchResult memory result) {
        (, , , uint256[] memory pools) = abi.decode(
            payload,
            (address, uint256, uint256, uint256[])
        );
        result.tokenIn = pools[0].getUniswapSrcToken();
        result.tokenOut = pools[pools.length - 1].getUniswapDstToken();
        result.data = constructUniswapV3SwapTo(recipient, amountIn, minAmountOut, pools);
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5HubUnoswap.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IUnoswapRouter,
    OneInchV5ConstructorUnoswap
} from "../actions/OneInchV5ConstructorUnoswap.sol";
/* solhint-enable no-unused-import */
import {UniswapTokens} from "../libraries/UniswapTokens.sol";
import {SwitchResult} from "./OneInchV5Hub.sol";

/* solhint-disable ordering */
abstract contract OneInchV5HubUnoswap is OneInchV5ConstructorUnoswap {
    using UniswapTokens for uint256;

    function unoswap(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut
    ) internal view virtual returns (SwitchResult memory result) {
        (address srcToken, , , uint256[] memory pools) = abi.decode(
            payload,
            (address, uint256, uint256, uint256[])
        );
        result.tokenIn = srcToken;
        result.tokenOut = pools[pools.length - 1].getUniswapDstToken();
        result.data = constructUnoswap(srcToken, amountIn, minAmountOut, pools);
    }

    function unoswapTo(
        bytes calldata payload,
        uint256 amountIn,
        uint256 minAmountOut,
        address payable recipient
    ) internal view virtual returns (SwitchResult memory result) {
        (, address srcToken, , , uint256[] memory pools) = abi.decode(
            payload,
            (address, address, uint256, uint256, uint256[])
        );
        result.tokenIn = srcToken;
        result.tokenOut = pools[pools.length - 1].getUniswapDstToken();
        result.data = constructUnoswapTo(recipient, srcToken, amountIn, minAmountOut, pools);
    }
}
/* solhint-enable ordering */
"
    },
    "contracts/compiler/oneInchV5/base/OneInchV5ImmutableState.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

contract OneInchV5ImmutableState {
    address internal constant SWAP_ROUTER = 0x1111111254EEB25477B68fb85Ed929f73A960582;
    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
}
"
    },
    "contracts/compiler/oneInchV5/libraries/UniswapTokens.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;

import {IUniswapPool} from "contracts/interfaces/compliance/internal/oneInchV5/IUniswapPool.sol";

library UniswapTokens {
    uint256 private constant REVERSE_MASK =
        0x8000000000000000000000000000000000000000000000000000000000000000;

    function getUniswapDstToken(uint256 poolUint) internal view returns (address) {
        IUniswapPool pool = IUniswapPool(address(uint160(poolUint)));
        return poolUint & REVERSE_MASK == 0 ? pool.token1() : pool.token0();
    }

    function getUniswapSrcToken(uint256 poolUint) internal view returns (address) {
        IUniswapPool pool = IUniswapPool(address(uint160(poolUint)));
        return poolUint & REVERSE_MASK == 0 ? pool.token0() : pool.token1();
    }
}
"
    },
    "contracts/compiler/oneInchV5/OneInchV5Evaluator.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {IExchangeEvaluator} from "contracts/interfaces/compiler/adapters/index.sol";

import {
    OneInchV5ImmutableState
} from "contracts/compiler/oneInchV5/base/OneInchV5ImmutableState.sol";
import {Address} from "contracts/libraries/Address.sol";
import {Command} from "contracts/libraries/CommandLibrary.sol";

import {Path} from "../libraries/Path.sol";
import {OneInchV5Hub, SwitchResult} from "./base/OneInchV5Hub.sol";

contract OneInchV5Evaluator is IExchangeEvaluator, OneInchV5Hub, OneInchV5ImmutableState {
    using Address for address;
    using Path for bytes;

    function evaluate(
        address,
        ExchangeRequest calldata _request
    ) external view override returns (Command[] memory cmds_) {
        SwitchResult memory result = switchBySelector(
            _request.extraData,
            _request.amountIn,
            _request.minAmountOut,
            payable(_request.recipient)
        );

        if (result.tokenIn.isEth()) {
            cmds_ = Command({target: SWAP_ROUTER, value: _request.amountIn, payload: result.data})
                .asArray();
        } else {
            cmds_ = Command({target: SWAP_ROUTER, value: 0, payload: result.data})
                .populateWithApprove(result.tokenIn, _request.amountIn);
        }
    }
}
"
    },
    "contracts/interfaces/base/CommonErrors.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/**
 * @notice An error indicating that the amount for the specified token is zero.
 * @param token The address of the token with a zero amount.
 */
error AmountMustNotBeZero(address token);

/**
 * @notice An error indicating that an address must not be zero.
 */
error AddressMustNotBeZero();

/**
 * @notice An error indicating that an array must not be empty.
 */
error ArrayMustNotBeEmpty();

/**
 * @notice An error indicating that an string must not be empty.
 */
error StringMustNotBeEmpty();

/**
 * @notice An error indicating storage is already up to date and doesn't need further processing.
 * @dev This error is thrown when attempting to update an entity(s) that is(are) already up to date.
 */
error AlreadyUpToDate();

/**
 * @notice An error indicating that an action is unauthorized for the specified account.
 * @param account The address of the unauthorized account.
 */
error UnauthorizedAccount(address account);

/**
 * @notice An error indicating that the min amount out must not be zero.
 */
error MinAmountOutMustNotBeZero();
"
    },
    "contracts/interfaces/base/IERC165Extended.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {
    IERC165
} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
/* solhint-enable no-unused-import */

/**
 * @notice An error indicating that an address does not support the expected interface
 * @param implementation The address that does not implement the required interface
 */
error UnsupportedInterface(address implementation);

/**
 * @dev Extended interface of the ERC165 standard to ensure compatibility
 * with Diamond facets as defined in EIP-2535.
 *
 * This interface extends the basic ERC165 mechanism to provide additional
 * flexibility for querying supported interfaces, which can then be
 * dynamically resolved by one of facets in a Diamond.
 */
interface IERC165Extended {
    /**
     * @notice Checks if the given interface ID is supported by the contract.
     * @param interfaceId The ID of the interface to query.
     * @return isSupported Boolean value indicating whether the interface is supported.
     */
    function supportsInterfaceExtended(bytes4 interfaceId) external pure returns (bool isSupported);
}
"
    },
    "contracts/interfaces/compiler/adapters/IDecreasePositionEvaluator.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {Asset} from "contracts/libraries/AssetLibrary.sol";
import {Command} from "../Command.sol";
import {PositionDescriptor} from "./PositionDescriptor.sol";

interface IDecreasePositionEvaluator {
    /**
     * @notice Request structure for decreasing a position.
     * @dev `descriptor`: The [`PositionDescriptor`](/interfaces/compiler/adapters/PositionDescriptor.sol/struct.PositionDescriptor.html)
     *  struct.
     * @dev `liquidity`: Abstract amount that can be interpreted differently in different protocols (e.g., amount of LP tokens to burn).
     * @dev `minOutput`: [`Asset`](/interfaces/compliance/Asset.sol/struct.Asset.html) array with minimum amounts that must be retrieved from the position.
     */
    struct DecreasePositionRequest {
        PositionDescriptor descriptor;
        uint256 liquidity;
        Asset[] minOutput;
    }

    /**
     * @notice Evaluate a decrease position request.
     * @param _operator Address which initiated the request
     * @param _request The [`DecreasePositionRequest`](#decreasepositionrequest) struct containing decrease position details.
     * @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
     */
    function evaluate(
        address _operator,
        DecreasePositionRequest calldata _request
    ) external returns (Command[] memory cmds_);
}
"
    },
    "contracts/interfaces/compiler/adapters/IExchangeEvaluator.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {Command} from "../Command.sol";

/**
 * @title IExchangeEvaluator
 * @notice Interface for compiling commands for token exchanges for different protocols.
 */
interface IExchangeEvaluator {
    /**
     * @notice Structure for an exchange token request.
     * @dev `path`: Encoded path of tokens to follow in the exchange, including pool identifiers.
     * 20 bytes(tokenA) + 4 byte(poolId_A_B) + 20 bytes(tokenB) + ...
     * ... + 4 byte(poolId_N-1_N) + 20 bytes(tokenN).
     * @dev `extraData`: Additional data specific to a particular protocol, such as the response from a 1Inch Exchange API.
     * @dev `amountIn`: The amount of tokenA to spend.
     * @dev `minAmountOut`: The minimum amount of tokenN to receive.
     * @dev `recipient`: The recipient of tokenN.
     */
    struct ExchangeRequest {
        bytes path;
        bytes extraData;
        uint256 amountIn;
        uint256 minAmountOut;
        address recipient;
    }

    /**
     * @notice Constructs an exchange token request.
     * @param _operator Address which initiated the request
     * @param _request The [`ExchangeRequest`](#exchangerequest) struct containing exchange token details.
     * @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
     */
    function evaluate(
        address _operator,
        ExchangeRequest calldata _request
    ) external view returns (Command[] memory cmds_);
}
"
    },
    "contracts/interfaces/compiler/adapters/IIncreasePositionEvaluator.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {Asset} from "contracts/libraries/AssetLibrary.sol";
import {Command} from "../Command.sol";
import {PositionDescriptor} from "./PositionDescriptor.sol";

interface IIncreasePositionEvaluator {
    /**
     * @notice Structure for an increase position request.
     * @dev `descriptor`: The [`PositionDescriptor`](/interfaces/compiler/adapters/PositionDescriptor.sol/struct.PositionDescriptor.html)
     *  struct.
     * @dev `input`: An array of [`Asset`](/interfaces/compliance/Asset.sol/struct.Asset.html) representing the token-amounts that will be added to the position.
     * @dev `minLiquidityOut`: An abstract amount that can be interpreted differently in different protocols (e.g., minimum amount of LP tokens to receive).
     */
    struct IncreasePositionRequest {
        PositionDescriptor descriptor;
        Asset[] input;
        uint256 minLiquidityOut;
    }

    /**
     * @notice Evaluate a increase position request.
     * @param _operator Address which initiated the request
     * @param _request The [`IncreasePositionRequest`](#increasepositionrequest) struct containing increase position details.
     * @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
     */
    function evaluate(
        address _operator,
        IncreasePositionRequest calldata _request
    ) external returns (Command[] memory cmds_);
}
"
    },
    "contracts/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

/* solhint-disable no-unused-import */
import {AlreadyUpToDate} from "contracts/interfaces/base/CommonErrors.sol";
import {
    Status,
    TokenIsNotSupported
} from "contracts/interfaces/compliance/IWhitelistingController.sol";
/* solhint-enable no-unused-import */

/**
 * @notice Error indicating that the pool ID was not found.
 * @param encodedPool The encoded pool data that was searched for.
 */
error PoolIdNotFound(bytes encodedPool);

/**
 * @notice Error indicating that the pool does not exist.
 * @param poolId The unique identifier of the pool that was searched for.
 */
error PoolIsNotSupported(uint256 poolId);

/**
 * @notice Error indicating that the pool is suspended.
 * @param poolId The unique identifier of the pool that is suspended.
 */
error PoolIsSuspended(uint256 poolId);

/**
 * @title ILiquidityPoolsRepository
 * @notice Interface for managing liquidity pools and their support status.
 */
interface ILiquidityPoolsRepository {
    /**
     * @notice Update the support status of a liquidity pool.
     * @param _encodedPool The encoded pool data.
     * @param _supported Whether the pool is supported or not.
     * @return poolId_ The unique identifier of the pool.
     * @dev Reverts with a [`PoolIdNotFound()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIdNotFound.html)
     *  error if the pool does not exist.
     */
    function updatePoolSupport(
        bytes calldata _encodedPool,
        bool _supported
    ) external returns (uint256 poolId_);

    /**
     * @notice Get the status of a specific pool.
     * @param _poolId The unique identifier of the pool.
     * @return status The status of the pool.
     * @dev Reverts with a [`PoolIsNotSupported()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIsNotSupported.html)
     *  error if the pool does not exist.
     */
    function getPoolStatus(uint256 _poolId) external returns (Status status);

    /**
     * @notice Get the unique identifier (pool ID) of a specific pool.
     * @param _encodedPool The encoded pool data.
     * @return poolId_ The unique identifier of the pool.
     * @dev Reverts with a [`PoolIsNotSupported()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIsNotSupported.html)
     *  error if the pool does not exist.
     */
    function getPoolId(bytes calldata _encodedPool) external view returns (uint256 poolId_);
}
"
    },
    "contracts/interfaces/compiler/adapters/index.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {
    IDecreasePositionEvaluator
} from "contracts/interfaces/compiler/adapters/IDecreasePositionEvaluator.sol";
import {IExchangeEvaluator} from "contracts/interfaces/compiler/adapters/IExchangeEvaluator.sol";
import {
    IIncreasePositionEvaluator
} from "contracts/interfaces/compiler/adapters/IIncreasePositionEvaluator.sol";
import {
    AlreadyUpToDate,
    ILiquidityPoolsRepository,
    PoolIdNotFound,
    PoolIsNotSupported,
    PoolIsSuspended,
    Status,
    TokenIsNotSupported
} from "contracts/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol";
import {PositionDescriptor} from "contracts/interfaces/compiler/adapters/PositionDescriptor.sol";
"
    },
    "contracts/interfaces/compiler/adapters/PositionDescriptor.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

// TODO CRYPTO-145: Possibly move into appropriate interface?
/**
 * @notice Used to determine the required position for an operation.
 * @dev `poolId`: An identifier that is unique within a single protocol.
 * @dev `extraData`: Additional data used to specify the position, for example
 * this is used in OneInchV5Evaluator to pass swap tx generated via 1inch API.
 */
struct PositionDescriptor {
    uint256 poolId;
    bytes extraData;
}
"
    },
    "contracts/interfaces/compiler/Command.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {CommandLibrary} from "contracts/libraries/CommandLibrary.sol";

/**
 * @title Command
 * @notice Contains arguments for a low-level call.
 * @dev This struct allows deferring the call's execution, suspending it by passing it to another function or contract.
 * @dev `target` The address to be called.
 * @dev `value` Value to send in the call.
 * @dev `payload` Encoded call with function selector and arguments.
 */
struct Command {
    address target;
    uint256 value;
    bytes payload;
}

using CommandLibrary for Command global;
"
    },
    "contracts/interfaces/compliance/Asset.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

import {AssetLibrary} from "contracts/libraries/AssetLibrary.sol";

/**
 * @title Asset
 * @dev Represents an asset with its token address and the amount.
 * @param token The address of the asset's token.
 * @param amount The amount of the asset.
 */
struct Asset {
    address token;
    uint256 amount;
}

using AssetLibrary for Asset global;
"
    },
    "contracts/interfaces/compliance/internal/oneInchV5/IClipperRouter.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

interface IClipperRouter {
    /// @notice Same as `clipperSwapTo` but uses `msg.sender` as recipient
    /// @param srcToken Source token
    /// @param dstToken Destination token
    /// @param inputAmount Amount of source tokens to swap
    /// @param outputAmount Amount of destination tokens to receive
    /// @param goodUntil Timestamp until the swap will be valid
    /// @param r Clipper order signature (r part)
    /// @param vs Clipper order signature (vs part)
    /// @return returnAmount Amount of destination tokens received
    function clipperSwap(
        address clipperExchange,
        address srcToken,
        address dstToken,
        uint256 inputAmount,
        uint256 outputAmount,
        uint256 goodUntil,
        bytes32 r,
        bytes32 vs
    ) external payable returns (uint256 returnAmount);

    /// @notice Performs swap using Clipper exchange. Wraps and unwraps ETH if required.
    /// Sending non-zero `msg.value` for anything but ETH swaps is prohibited
    /// @param recipient Address that will receive swap funds
    /// @param srcToken Source token
    /// @param dstToken Destination token
    /// @param inputAmount Amount of source tokens to swap
    /// @param outputAmount Amount of destination tokens to receive
    /// @param goodUntil Timestamp until the swap will be valid
    /// @param r Clipper order signature (r part)
    /// @param vs Clipper order signature (vs part)
    /// @return returnAmount Amount of destination tokens received
    function clipperSwapTo(
        address clipperExchange,
        address payable recipient,
        address srcToken,
        address dstToken,
        uint256 inputAmount,
        uint256 outputAmount,
        uint256 goodUntil,
        bytes32 r,
        bytes32 vs
    ) external payable returns (uint256 returnAmount);
}
"
    },
    "contracts/interfaces/compliance/internal/oneInchV5/IGenericRouter.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

interface IGenericRouter {
    struct SwapDescription {
        address srcToken;
        address dstToken;
        address payable srcReceiver;
        address payable dstReceiver;
        uint256 amount;
        uint256 minReturnAmount;
        uint256 flags;
    }

    /// @notice Performs a swap, delegating all calls encoded in `data` to `executor`. See tests for usage examples
    /// @dev router keeps 1 wei of every token on the contract balance for gas optimizations reasons. This affects first swap of every token by leaving 1 wei on the contract.
    /// @param executor Aggregation executor that executes calls described in `data`
    /// @param desc Swap description
    /// @param permit Should contain valid permit that can be used in `addressPermit.permit` calls.
    /// @param data Encoded calls that `caller` should execute in between of swaps
    /// @return returnAmount Resulting token amount
    /// @return spentAmount Source token amount
    function swap(
        address executor,
        SwapDescription calldata desc,
        bytes calldata permit,
        bytes calldata data
    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
}
"
    },
    "contracts/interfaces/compliance/internal/oneInchV5/IOrderLib.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;

interfa