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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// https://github.com/velodrome-finance/universal-router/blob/main/contracts/libraries/Commands.sol

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.17;

/// @title Commands
/// @notice Command Flags used to decode commands
library AerodromeCommands {
  // Masks to extract certain bits of commands
  bytes1 internal constant FLAG_ALLOW_REVERT = 0x80;
  bytes1 internal constant COMMAND_TYPE_MASK = 0x3f;

  // Command Types. Maximum supported command at this moment is 0x3f.

  // Command Types where value<0x08, executed in the first nested-if block
  uint256 constant V3_SWAP_EXACT_IN = 0x00;
  uint256 constant V3_SWAP_EXACT_OUT = 0x01;
  uint256 constant PERMIT2_TRANSFER_FROM = 0x02;
  uint256 constant PERMIT2_PERMIT_BATCH = 0x03;
  uint256 constant SWEEP = 0x04;
  uint256 constant TRANSFER = 0x05;
  uint256 constant PAY_PORTION = 0x06;
  // COMMAND_PLACEHOLDER = 0x07;

  // The commands are executed in nested if blocks to minimise gas consumption
  // The following constant defines one of the boundaries where the if blocks split commands
  uint256 constant FIRST_IF_BOUNDARY = 0x08;

  // Command Types where 0x08<=value<=0x0f, executed in the second nested-if block
  uint256 constant V2_SWAP_EXACT_IN = 0x08;
  uint256 constant V2_SWAP_EXACT_OUT = 0x09;
  uint256 constant PERMIT2_PERMIT = 0x0a;
  uint256 constant WRAP_ETH = 0x0b;
  uint256 constant UNWRAP_WETH = 0x0c;
  uint256 constant PERMIT2_TRANSFER_FROM_BATCH = 0x0d;
  uint256 constant BALANCE_CHECK_ERC20 = 0x0e;
  // COMMAND_PLACEHOLDER = 0x0f;

  // The commands are executed in nested if blocks to minimise gas consumption
  // The following constant defines one of the boundaries where the if blocks split commands
  uint256 constant SECOND_IF_BOUNDARY = 0x10;

  // Command Types where 0x10<=value<0x18, executed in the third nested-if block
  uint256 constant SEAPORT_V1_5 = 0x10;
  uint256 constant LOOKS_RARE_V2 = 0x11;
  uint256 constant NFTX = 0x12;
  uint256 constant CRYPTOPUNKS = 0x13;
  // 0x14;
  uint256 constant OWNER_CHECK_721 = 0x15;
  uint256 constant OWNER_CHECK_1155 = 0x16;
  uint256 constant SWEEP_ERC721 = 0x17;

  // The commands are executed in nested if blocks to minimise gas consumption
  // The following constant defines one of the boundaries where the if blocks split commands
  uint256 constant THIRD_IF_BOUNDARY = 0x18;

  // Command Types where 0x18<=value<=0x1f, executed in the final nested-if block
  uint256 constant X2Y2_721 = 0x18;
  uint256 constant SUDOSWAP = 0x19;
  uint256 constant NFT20 = 0x1a;
  uint256 constant X2Y2_1155 = 0x1b;
  uint256 constant FOUNDATION = 0x1c;
  uint256 constant SWEEP_ERC1155 = 0x1d;
  uint256 constant ELEMENT_MARKET = 0x1e;
  // COMMAND_PLACEHOLDER = 0x1f;

  // The commands are executed in nested if blocks to minimise gas consumption
  // The following constant defines one of the boundaries where the if blocks split commands
  uint256 constant FOURTH_IF_BOUNDARY = 0x20;

  // Command Types where 0x20<=value
  uint256 constant SEAPORT_V1_4 = 0x20;
  uint256 constant EXECUTE_SUB_PLAN = 0x21;
  uint256 constant APPROVE_ERC20 = 0x22;
  // COMMAND_PLACEHOLDER for 0x23 to 0x3f (all unused)
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@uniswap/v3-periphery/contracts/interfaces/IPeripheryImmutableState.sol';
import '../interfaces/IAerodromeLpSugar.sol';
import '../interfaces/IAerodromeVoter.sol';
import '../interfaces/IAerodromePoolFactory.sol';
import '../interfaces/IAerodromeRouter.sol';
import '../interfaces/IAerodromeUniversalRouter.sol';
import '../interfaces/IV3TwapUtilities.sol';
import './UniswapDexAdapter.sol';
import { AerodromeCommands } from '../libraries/AerodromeCommands.sol';

contract AerodromeDexAdapter is UniswapDexAdapter {
  using SafeERC20 for IERC20;

  address constant AERO = 0x940181a94A35A4569E4529A3CDfB74e38FD98631;
  address constant CL_FACTORY = 0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A;
  address constant LP_SUGAR = 0xf739E2BC37fD5C1D3614dA67756dEEaEE0025667;
  int24 constant TICK_SPACING = 200;

  constructor(
    IV3TwapUtilities _v3TwapUtilities,
    address _v2Router,
    address _v3Router
  ) UniswapDexAdapter(_v3TwapUtilities, _v2Router, _v3Router, true) {}

  function WETH() external view virtual override returns (address) {
    return address(IAerodromeRouter(V2_ROUTER).weth());
  }

  function getV3Pool(
    address _token0,
    address _token1,
    int24 _tickSpacing
  ) external view override returns (address) {
    return V3_TWAP_UTILS.getV3Pool(CL_FACTORY, _token0, _token1, _tickSpacing);
  }

  function getV3Pool(
    address,
    address,
    uint24
  ) external view virtual override returns (address _p) {
    _p;
    require(false, 'I0');
  }

  function getV2Pool(
    address _token0,
    address _token1
  ) public view override returns (address) {
    return
      IAerodromePoolFactory(IAerodromeRouter(V2_ROUTER).defaultFactory())
        .getPool(_token0, _token1, 0);
  }

  function createV2Pool(
    address _token0,
    address _token1
  ) external override returns (address) {
    return
      IAerodromePoolFactory(IAerodromeRouter(V2_ROUTER).defaultFactory())
        .createPool(_token0, _token1, 0);
  }

  function swapV2Single(
    address _tokenIn,
    address _tokenOut,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external override returns (uint256 _amountOut) {
    uint256 _outBefore = IERC20(_tokenOut).balanceOf(_recipient);
    if (_amountIn == 0) {
      _amountIn = IERC20(_tokenIn).balanceOf(address(this));
    } else {
      IERC20(_tokenIn).safeTransferFrom(_msgSender(), address(this), _amountIn);
    }
    IAerodromeRouter.Route[] memory _routes = new IAerodromeRouter.Route[](1);
    _routes[0] = IAerodromeRouter.Route({
      from: _tokenIn,
      to: _tokenOut,
      stable: false,
      factory: IAerodromeRouter(V2_ROUTER).defaultFactory()
    });
    IERC20(_tokenIn).safeIncreaseAllowance(V2_ROUTER, _amountIn);
    IAerodromeRouter(V2_ROUTER)
      .swapExactTokensForTokensSupportingFeeOnTransferTokens(
        _amountIn,
        _amountOutMin,
        _routes,
        _recipient,
        block.timestamp
      );

    return IERC20(_tokenOut).balanceOf(_recipient) - _outBefore;
  }

  function swapV3Single(
    address _tokenIn,
    address _tokenOut,
    uint24,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external override returns (uint256 _amountOut) {
    uint256 _outBefore = IERC20(_tokenOut).balanceOf(_recipient);
    if (_amountIn == 0) {
      _amountIn = IERC20(_tokenIn).balanceOf(address(this));
    } else {
      IERC20(_tokenIn).safeTransferFrom(_msgSender(), address(this), _amountIn);
    }
    IERC20(_tokenIn).safeIncreaseAllowance(V3_ROUTER, _amountIn);
    bytes memory _commands = abi.encodePacked(
      bytes1(uint8(AerodromeCommands.V3_SWAP_EXACT_IN))
    );
    bytes[] memory _inputs = new bytes[](1);
    bytes memory _path = abi.encodePacked(_tokenIn, TICK_SPACING, _tokenOut);
    _inputs[0] = abi.encode(_recipient, _amountIn, _amountOutMin, _path, true);
    IAerodromeUniversalRouter(V3_ROUTER).execute(
      _commands,
      _inputs,
      block.timestamp
    );

    return IERC20(_tokenOut).balanceOf(_recipient) - _outBefore;
  }

  function addLiquidity(
    address _tokenA,
    address _tokenB,
    uint256 _amountADesired,
    uint256 _amountBDesired,
    uint256 _amountAMin,
    uint256 _amountBMin,
    address _to,
    uint256 _deadline
  ) external virtual override {
    uint256 _aBefore = IERC20(_tokenA).balanceOf(address(this));
    uint256 _bBefore = IERC20(_tokenB).balanceOf(address(this));
    IERC20(_tokenA).safeTransferFrom(
      _msgSender(),
      address(this),
      _amountADesired
    );
    IERC20(_tokenB).safeTransferFrom(
      _msgSender(),
      address(this),
      _amountBDesired
    );
    IERC20(_tokenA).safeIncreaseAllowance(V2_ROUTER, _amountADesired);
    IERC20(_tokenB).safeIncreaseAllowance(V2_ROUTER, _amountBDesired);
    IAerodromeRouter(V2_ROUTER).addLiquidity(
      _tokenA,
      _tokenB,
      false,
      _amountADesired,
      _amountBDesired,
      _amountAMin,
      _amountBMin,
      _to,
      _deadline
    );
    if (IERC20(_tokenA).balanceOf(address(this)) > _aBefore) {
      IERC20(_tokenA).safeTransfer(
        _to,
        IERC20(_tokenA).balanceOf(address(this)) - _aBefore
      );
    }
    if (IERC20(_tokenB).balanceOf(address(this)) > _bBefore) {
      IERC20(_tokenB).safeTransfer(
        _to,
        IERC20(_tokenB).balanceOf(address(this)) - _bBefore
      );
    }
  }

  function removeLiquidity(
    address _tokenA,
    address _tokenB,
    uint256 _liquidity,
    uint256 _amountAMin,
    uint256 _amountBMin,
    address _to,
    uint256 _deadline
  ) external virtual override {
    address _pool = IAerodromePoolFactory(
      IAerodromeRouter(V2_ROUTER).defaultFactory()
    ).getPool(_tokenA, _tokenB, 0);
    uint256 _lpBefore = IERC20(_pool).balanceOf(address(this));
    IERC20(_pool).safeTransferFrom(_msgSender(), address(this), _liquidity);
    IERC20(_pool).safeIncreaseAllowance(V2_ROUTER, _liquidity);
    IAerodromeRouter(V2_ROUTER).removeLiquidity(
      _tokenA,
      _tokenB,
      false,
      _liquidity,
      _amountAMin,
      _amountBMin,
      _to,
      _deadline
    );
    if (IERC20(_pool).balanceOf(address(this)) > _lpBefore) {
      IERC20(_pool).safeTransfer(
        _to,
        IERC20(_pool).balanceOf(address(this)) - _lpBefore
      );
    }
  }

  function extraRewardsHook(
    address _token0,
    address _token1
  )
    external
    override
    returns (address[] memory _tokens, uint256[] memory _amounts)
  {
    _tokens[0] = AERO;
    uint256 _aeroBefore = IERC20(AERO).balanceOf(address(this));
    address _pool = getV2Pool(_token0, _token1);
    IAerodromeVoter _voter = IAerodromeVoter(
      IAerodromeLpSugar(LP_SUGAR).voter()
    );
    address[] memory _gauges = new address[](1);
    _gauges[0] = _voter.gauges(_pool);
    _voter.claimRewards(_gauges);
    _amounts[0] = IERC20(AERO).balanceOf(address(this)) - _aeroBefore;
  }
}

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

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IAerodromeLpSugar {
  function voter() external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IAerodromePoolFactory {
  event SetFeeManager(address feeManager);
  event SetPauser(address pauser);
  event SetPauseState(bool state);
  event SetVoter(address voter);
  event PoolCreated(
    address indexed token0,
    address indexed token1,
    bool indexed stable,
    address pool,
    uint256
  );
  event SetCustomFee(address indexed pool, uint256 fee);

  error FeeInvalid();
  error FeeTooHigh();
  error InvalidPool();
  error NotFeeManager();
  error NotPauser();
  error NotVoter();
  error PoolAlreadyExists();
  error SameAddress();
  error ZeroFee();
  error ZeroAddress();

  /// @notice returns the number of pools created from this factory
  function allPoolsLength() external view returns (uint256);

  /// @notice Is a valid pool created by this factory.
  /// @param .
  function isPool(address pool) external view returns (bool);

  /// @notice Return address of pool created by this factory
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable True if stable, false if volatile
  function getPool(
    address tokenA,
    address tokenB,
    bool stable
  ) external view returns (address);

  /// @notice Support for v3-style pools which wraps around getPool(tokenA,tokenB,stable)
  /// @dev fee is converted to stable boolean.
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee  1 if stable, 0 if volatile, else returns address(0)
  function getPool(
    address tokenA,
    address tokenB,
    uint24 fee
  ) external view returns (address);

  /// @dev Only called once to set to Voter.sol - Voter does not have a function
  ///      to call this contract method, so once set it's immutable.
  ///      This also follows convention of setVoterAndDistributor() in VotingEscrow.sol
  /// @param _voter .
  function setVoter(address _voter) external;

  function setPauser(address _pauser) external;

  function setPauseState(bool _state) external;

  function setFeeManager(address _feeManager) external;

  /// @notice Set default fee for stable and volatile pools.
  /// @dev Throws if higher than maximum fee.
  ///      Throws if fee is zero.
  /// @param _stable Stable or volatile pool.
  /// @param _fee .
  function setFee(bool _stable, uint256 _fee) external;

  /// @notice Set overriding fee for a pool from the default
  /// @dev A custom fee of zero means the default fee will be used.
  function setCustomFee(address _pool, uint256 _fee) external;

  /// @notice Returns fee for a pool, as custom fees are possible.
  function getFee(address _pool, bool _stable) external view returns (uint256);

  /// @notice Create a pool given two tokens and if they're stable/volatile
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable .
  function createPool(
    address tokenA,
    address tokenB,
    bool stable
  ) external returns (address pool);

  /// @notice Support for v3-style pools which wraps around createPool(tokena,tokenB,stable)
  /// @dev fee is converted to stable boolean
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee 1 if stable, 0 if volatile, else revert
  function createPool(
    address tokenA,
    address tokenB,
    uint24 fee
  ) external returns (address pool);

  function isPaused() external view returns (bool);

  function voter() external view returns (address);

  function implementation() external view returns (address);
}

// https://github.com/aerodrome-finance/contracts/blob/main/contracts/interfaces/IRouter.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { IWETH } from './IWETH.sol';

interface IAerodromeRouter {
  struct Route {
    address from;
    address to;
    bool stable;
    address factory;
  }

  error ETHTransferFailed();
  error Expired();
  error InsufficientAmount();
  error InsufficientAmountA();
  error InsufficientAmountB();
  error InsufficientAmountADesired();
  error InsufficientAmountBDesired();
  error InsufficientAmountAOptimal();
  error InsufficientLiquidity();
  error InsufficientOutputAmount();
  error InvalidAmountInForETHDeposit();
  error InvalidTokenInForETHDeposit();
  error InvalidPath();
  error InvalidRouteA();
  error InvalidRouteB();
  error OnlyWETH();
  error PoolDoesNotExist();
  error PoolFactoryDoesNotExist();
  error SameAddresses();
  error ZeroAddress();

  /// @notice Address of FactoryRegistry.sol
  function factoryRegistry() external view returns (address);

  /// @notice Address of Protocol PoolFactory.sol
  function defaultFactory() external view returns (address);

  /// @notice Address of Voter.sol
  function voter() external view returns (address);

  /// @notice Interface of WETH contract used for WETH => ETH wrapping/unwrapping
  function weth() external view returns (IWETH);

  /// @dev Represents Ether. Used by zapper to determine whether to return assets as ETH/WETH.
  function ETHER() external view returns (address);

  /// @dev Struct containing information necessary to zap in and out of pools
  /// @param tokenA           .
  /// @param tokenB           .
  /// @param stable           Stable or volatile pool
  /// @param factory          factory of pool
  /// @param amountOutMinA    Minimum amount expected from swap leg of zap via routesA
  /// @param amountOutMinB    Minimum amount expected from swap leg of zap via routesB
  /// @param amountAMin       Minimum amount of tokenA expected from liquidity leg of zap
  /// @param amountBMin       Minimum amount of tokenB expected from liquidity leg of zap
  struct Zap {
    address tokenA;
    address tokenB;
    bool stable;
    address factory;
    uint256 amountOutMinA;
    uint256 amountOutMinB;
    uint256 amountAMin;
    uint256 amountBMin;
  }

  /// @notice Sort two tokens by which address value is less than the other
  /// @param tokenA   Address of token to sort
  /// @param tokenB   Address of token to sort
  /// @return token0  Lower address value between tokenA and tokenB
  /// @return token1  Higher address value between tokenA and tokenB
  function sortTokens(
    address tokenA,
    address tokenB
  ) external pure returns (address token0, address token1);

  /// @notice Calculate the address of a pool by its' factory.
  ///         Used by all Router functions containing a `Route[]` or `_factory` argument.
  ///         Reverts if _factory is not approved by the FactoryRegistry
  /// @dev Returns a randomly generated address for a nonexistent pool
  /// @param tokenA   Address of token to query
  /// @param tokenB   Address of token to query
  /// @param stable   True if pool is stable, false if volatile
  /// @param _factory Address of factory which created the pool
  function poolFor(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory
  ) external view returns (address pool);

  /// @notice Fetch and sort the reserves for a pool
  /// @param tokenA       .
  /// @param tokenB       .
  /// @param stable       True if pool is stable, false if volatile
  /// @param _factory     Address of PoolFactory for tokenA and tokenB
  /// @return reserveA    Amount of reserves of the sorted token A
  /// @return reserveB    Amount of reserves of the sorted token B
  function getReserves(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory
  ) external view returns (uint256 reserveA, uint256 reserveB);

  /// @notice Perform chained getAmountOut calculations on any number of pools
  function getAmountsOut(
    uint256 amountIn,
    Route[] memory routes
  ) external view returns (uint256[] memory amounts);

  // **** ADD LIQUIDITY ****

  /// @notice Quote the amount deposited into a Pool
  /// @param tokenA           .
  /// @param tokenB           .
  /// @param stable           True if pool is stable, false if volatile
  /// @param _factory         Address of PoolFactory for tokenA and tokenB
  /// @param amountADesired   Amount of tokenA desired to deposit
  /// @param amountBDesired   Amount of tokenB desired to deposit
  /// @return amountA         Amount of tokenA to actually deposit
  /// @return amountB         Amount of tokenB to actually deposit
  /// @return liquidity       Amount of liquidity token returned from deposit
  function quoteAddLiquidity(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory,
    uint256 amountADesired,
    uint256 amountBDesired
  ) external view returns (uint256 amountA, uint256 amountB, uint256 liquidity);

  /// @notice Quote the amount of liquidity removed from a Pool
  /// @param tokenA       .
  /// @param tokenB       .
  /// @param stable       True if pool is stable, false if volatile
  /// @param _factory     Address of PoolFactory for tokenA and tokenB
  /// @param liquidity    Amount of liquidity to remove
  /// @return amountA     Amount of tokenA received
  /// @return amountB     Amount of tokenB received
  function quoteRemoveLiquidity(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory,
    uint256 liquidity
  ) external view returns (uint256 amountA, uint256 amountB);

  /// @notice Add liquidity of two tokens to a Pool
  /// @param tokenA           .
  /// @param tokenB           .
  /// @param stable           True if pool is stable, false if volatile
  /// @param amountADesired   Amount of tokenA desired to deposit
  /// @param amountBDesired   Amount of tokenB desired to deposit
  /// @param amountAMin       Minimum amount of tokenA to deposit
  /// @param amountBMin       Minimum amount of tokenB to deposit
  /// @param to               Recipient of liquidity token
  /// @param deadline         Deadline to receive liquidity
  /// @return amountA         Amount of tokenA to actually deposit
  /// @return amountB         Amount of tokenB to actually deposit
  /// @return liquidity       Amount of liquidity token returned from deposit
  function addLiquidity(
    address tokenA,
    address tokenB,
    bool stable,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

  /// @notice Add liquidity of a token and WETH (transferred as ETH) to a Pool
  /// @param token                .
  /// @param stable               True if pool is stable, false if volatile
  /// @param amountTokenDesired   Amount of token desired to deposit
  /// @param amountTokenMin       Minimum amount of token to deposit
  /// @param amountETHMin         Minimum amount of ETH to deposit
  /// @param to                   Recipient of liquidity token
  /// @param deadline             Deadline to add liquidity
  /// @return amountToken         Amount of token to actually deposit
  /// @return amountETH           Amount of tokenETH to actually deposit
  /// @return liquidity           Amount of liquidity token returned from deposit
  function addLiquidityETH(
    address token,
    bool stable,
    uint256 amountTokenDesired,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  )
    external
    payable
    returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);

  // **** REMOVE LIQUIDITY ****

  /// @notice Remove liquidity of two tokens from a Pool
  /// @param tokenA       .
  /// @param tokenB       .
  /// @param stable       True if pool is stable, false if volatile
  /// @param liquidity    Amount of liquidity to remove
  /// @param amountAMin   Minimum amount of tokenA to receive
  /// @param amountBMin   Minimum amount of tokenB to receive
  /// @param to           Recipient of tokens received
  /// @param deadline     Deadline to remove liquidity
  /// @return amountA     Amount of tokenA received
  /// @return amountB     Amount of tokenB received
  function removeLiquidity(
    address tokenA,
    address tokenB,
    bool stable,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountA, uint256 amountB);

  /// @notice Remove liquidity of a token and WETH (returned as ETH) from a Pool
  /// @param token            .
  /// @param stable           True if pool is stable, false if volatile
  /// @param liquidity        Amount of liquidity to remove
  /// @param amountTokenMin   Minimum amount of token to receive
  /// @param amountETHMin     Minimum amount of ETH to receive
  /// @param to               Recipient of liquidity token
  /// @param deadline         Deadline to receive liquidity
  /// @return amountToken     Amount of token received
  /// @return amountETH       Amount of ETH received
  function removeLiquidityETH(
    address token,
    bool stable,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountToken, uint256 amountETH);

  /// @notice Remove liquidity of a fee-on-transfer token and WETH (returned as ETH) from a Pool
  /// @param token            .
  /// @param stable           True if pool is stable, false if volatile
  /// @param liquidity        Amount of liquidity to remove
  /// @param amountTokenMin   Minimum amount of token to receive
  /// @param amountETHMin     Minimum amount of ETH to receive
  /// @param to               Recipient of liquidity token
  /// @param deadline         Deadline to receive liquidity
  /// @return amountETH       Amount of ETH received
  function removeLiquidityETHSupportingFeeOnTransferTokens(
    address token,
    bool stable,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountETH);

  // **** SWAP ****

  /// @notice Swap one token for another
  /// @param amountIn     Amount of token in
  /// @param amountOutMin Minimum amount of desired token received
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  /// @return amounts     Array of amounts returned per route
  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  /// @notice Swap ETH for a token
  /// @param amountOutMin Minimum amount of desired token received
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  /// @return amounts     Array of amounts returned per route
  function swapExactETHForTokens(
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  /// @notice Swap a token for WETH (returned as ETH)
  /// @param amountIn     Amount of token in
  /// @param amountOutMin Minimum amount of desired ETH
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  /// @return amounts     Array of amounts returned per route
  function swapExactTokensForETH(
    uint256 amountIn,
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  /// @notice Swap one token for another without slippage protection
  /// @return amounts     Array of amounts to swap  per route
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  function UNSAFE_swapExactTokensForTokens(
    uint256[] memory amounts,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory);

  // **** SWAP (supporting fee-on-transfer tokens) ****

  /// @notice Swap one token for another supporting fee-on-transfer tokens
  /// @param amountIn     Amount of token in
  /// @param amountOutMin Minimum amount of desired token received
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external;

  /// @notice Swap ETH for a token supporting fee-on-transfer tokens
  /// @param amountOutMin Minimum amount of desired token received
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external payable;

  /// @notice Swap a token for WETH (returned as ETH) supporting fee-on-transfer tokens
  /// @param amountIn     Amount of token in
  /// @param amountOutMin Minimum amount of desired ETH
  /// @param routes       Array of trade routes used in the swap
  /// @param to           Recipient of the tokens received
  /// @param deadline     Deadline to receive tokens
  function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    Route[] calldata routes,
    address to,
    uint256 deadline
  ) external;

  /// @notice Zap a token A into a pool (B, C). (A can be equal to B or C).
  ///         Supports standard ERC20 tokens only (i.e. not fee-on-transfer tokens etc).
  ///         Slippage is required for the initial swap.
  ///         Additional slippage may be required when adding liquidity as the
  ///         price of the token may have changed.
  /// @param tokenIn      Token you are zapping in from (i.e. input token).
  /// @param amountInA    Amount of input token you wish to send down routesA
  /// @param amountInB    Amount of input token you wish to send down routesB
  /// @param zapInPool    Contains zap struct information. See Zap struct.
  /// @param routesA      Route used to convert input token to tokenA
  /// @param routesB      Route used to convert input token to tokenB
  /// @param to           Address you wish to mint liquidity to.
  /// @param stake        Auto-stake liquidity in corresponding gauge.
  /// @return liquidity   Amount of LP tokens created from zapping in.
  function zapIn(
    address tokenIn,
    uint256 amountInA,
    uint256 amountInB,
    Zap calldata zapInPool,
    Route[] calldata routesA,
    Route[] calldata routesB,
    address to,
    bool stake
  ) external payable returns (uint256 liquidity);

  /// @notice Zap out a pool (B, C) into A.
  ///         Supports standard ERC20 tokens only (i.e. not fee-on-transfer tokens etc).
  ///         Slippage is required for the removal of liquidity.
  ///         Additional slippage may be required on the swap as the
  ///         price of the token may have changed.
  /// @param tokenOut     Token you are zapping out to (i.e. output token).
  /// @param liquidity    Amount of liquidity you wish to remove.
  /// @param zapOutPool   Contains zap struct information. See Zap struct.
  /// @param routesA      Route used to convert tokenA into output token.
  /// @param routesB      Route used to convert tokenB into output token.
  function zapOut(
    address tokenOut,
    uint256 liquidity,
    Zap calldata zapOutPool,
    Route[] calldata routesA,
    Route[] calldata routesB
  ) external;

  /// @notice Used to generate params required for zapping in.
  ///         Zap in => remove liquidity then swap.
  ///         Apply slippage to expected swap values to account for changes in reserves in between.
  /// @dev Output token refers to the token you want to zap in from.
  /// @param tokenA           .
  /// @param tokenB           .
  /// @param stable           .
  /// @param _factory         .
  /// @param amountInA        Amount of input token you wish to send down routesA
  /// @param amountInB        Amount of input token you wish to send down routesB
  /// @param routesA          Route used to convert input token to tokenA
  /// @param routesB          Route used to convert input token to tokenB
  /// @return amountOutMinA   Minimum output expected from swapping input token to tokenA.
  /// @return amountOutMinB   Minimum output expected from swapping input token to tokenB.
  /// @return amountAMin      Minimum amount of tokenA expected from depositing liquidity.
  /// @return amountBMin      Minimum amount of tokenB expected from depositing liquidity.
  function generateZapInParams(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory,
    uint256 amountInA,
    uint256 amountInB,
    Route[] calldata routesA,
    Route[] calldata routesB
  )
    external
    view
    returns (
      uint256 amountOutMinA,
      uint256 amountOutMinB,
      uint256 amountAMin,
      uint256 amountBMin
    );

  /// @notice Used to generate params required for zapping out.
  ///         Zap out => swap then add liquidity.
  ///         Apply slippage to expected liquidity values to account for changes in reserves in between.
  /// @dev Output token refers to the token you want to zap out of.
  /// @param tokenA           .
  /// @param tokenB           .
  /// @param stable           .
  /// @param _factory         .
  /// @param liquidity        Amount of liquidity being zapped out of into a given output token.
  /// @param routesA          Route used to convert tokenA into output token.
  /// @param routesB          Route used to convert tokenB into output token.
  /// @return amountOutMinA   Minimum output expected from swapping tokenA into output token.
  /// @return amountOutMinB   Minimum output expected from swapping tokenB into output token.
  /// @return amountAMin      Minimum amount of tokenA expected from withdrawing liquidity.
  /// @return amountBMin      Minimum amount of tokenB expected from withdrawing liquidity.
  function generateZapOutParams(
    address tokenA,
    address tokenB,
    bool stable,
    address _factory,
    uint256 liquidity,
    Route[] calldata routesA,
    Route[] calldata routesB
  )
    external
    view
    returns (
      uint256 amountOutMinA,
      uint256 amountOutMinB,
      uint256 amountAMin,
      uint256 amountBMin
    );

  /// @notice Used by zapper to determine appropriate ratio of A to B to deposit liquidity. Assumes stable pool.
  /// @dev Returns stable liquidity ratio of B to (A + B).
  ///      E.g. if ratio is 0.4, it means there is more of A than there is of B.
  ///      Therefore you should deposit more of token A than B.
  /// @param tokenA   tokenA of stable pool you are zapping into.
  /// @param tokenB   tokenB of stable pool you are zapping into.
  /// @param factory  Factory that created stable pool.
  /// @return ratio   Ratio of token0 to token1 required to deposit into zap.
  function quoteStableLiquidityRatio(
    address tokenA,
    address tokenB,
    address factory
  ) external view returns (uint256 ratio);
}

// https://github.com/velodrome-finance/universal-router/blob/main/contracts/interfaces/IUniversalRouter.sol

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.17;

interface IAerodromeUniversalRouter {
  /// @notice Executes encoded commands along with provided inputs. Reverts if deadline has expired.
  /// @param commands A set of concatenated commands, each 1 byte in length
  /// @param inputs An array of byte strings containing abi encoded inputs for each command
  /// @param deadline The deadline by which the transaction must be executed
  function execute(
    bytes calldata commands,
    bytes[] calldata inputs,
    uint256 deadline
  ) external payable;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IAerodromeVoter {
  function gauges(address pool) external view returns (address);

  function claimRewards(address[] memory _gauges) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IDexAdapter {
  function ASYNC_INITIALIZE() external view returns (bool);

  function V2_ROUTER() external view returns (address);

  function V3_ROUTER() external view returns (address);

  function WETH() external view returns (address);

  function getV3Pool(
    address _token0,
    address _token1,
    int24 _tickSpacing
  ) external view returns (address _pool);

  function getV3Pool(
    address _token0,
    address _token1,
    uint24 _poolFee
  ) external view returns (address _pool);

  function getV2Pool(
    address _token0,
    address _token1
  ) external view returns (address _pool);

  function createV2Pool(
    address _token0,
    address _token1
  ) external returns (address _pool);

  function swapV2Single(
    address _tokenIn,
    address _tokenOut,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external returns (uint256 _amountOut);

  function swapV3Single(
    address _tokenIn,
    address _tokenOut,
    uint24 _fee,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external returns (uint256 _amountOut);

  function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external;

  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external;

  function extraRewardsHook(
    address _token0,
    address _token1
  ) external returns (address[] memory tokens, uint256[] memory amounts);
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Immutable state
/// @notice Functions that return immutable state of the router
interface IPeripheryImmutableState {
    /// @return Returns the address of the Uniswap V3 factory
    function factory() external view returns (address);

    /// @return Returns the address of WETH9
    function WETH9() external view returns (address);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.19;

interface ISwapRouter02 {
  struct ExactInputSingleParams {
    address tokenIn;
    address tokenOut;
    uint24 fee;
    address recipient;
    uint256 amountIn;
    uint256 amountOutMinimum;
    uint160 sqrtPriceLimitX96;
  }

  function exactInputSingle(
    ExactInputSingleParams calldata params
  ) external payable returns (uint256 amountOut);

  struct ExactInputParams {
    bytes path;
    address recipient;
    uint256 amountIn;
    uint256 amountOutMinimum;
  }

  function exactInput(
    ExactInputParams calldata params
  ) external payable returns (uint256 amountOut);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IUniswapV2Factory {
  function createPair(
    address tokenA,
    address tokenB
  ) external returns (address pair);

  function getPair(
    address tokenA,
    address tokenB
  ) external view returns (address pair);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IUniswapV2Router02 {
  function factory() external view returns (address);

  function WETH() external view returns (address);

  function addLiquidity(
    address tokenA,
    address tokenB,
    uint amountADesired,
    uint amountBDesired,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
  ) external returns (uint amountA, uint amountB, uint liquidity);

  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint liquidity,
    uint amountAMin,
    uint amountBMin,
    address to,
    uint deadline
  ) external returns (uint amountA, uint amountB);

  function swapETHForExactTokens(
    uint256 amountOut,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint amountIn,
    uint amountOutMin,
    address[] calldata path,
    address to,
    uint deadline
  ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IV3TwapUtilities {
  function getV3Pool(
    address v3Factory,
    address token0,
    address token1
  ) external view returns (address);

  function getV3Pool(
    address v3Factory,
    address token0,
    address token1,
    uint24 poolFee
  ) external view returns (address);

  function getV3Pool(
    address v3Factory,
    address token0,
    address token1,
    int24 tickSpacing
  ) external view returns (address);

  function getPoolPriceUSDX96(
    address pricePool,
    address nativeStablePool,
    address WETH9
  ) external view returns (uint256);

  function sqrtPriceX96FromPoolAndInterval(
    address pool
  ) external view returns (uint160);

  function priceX96FromSqrtPriceX96(
    uint160 sqrtPriceX96
  ) external pure returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IWETH {
  function deposit() external payable;

  function withdraw(uint256 _amount) external;
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@uniswap/v3-periphery/contracts/interfaces/IPeripheryImmutableState.sol';
import '../interfaces/IDexAdapter.sol';
import '../interfaces/ISwapRouter02.sol';
import '../interfaces/IUniswapV2Factory.sol';
import '../interfaces/IUniswapV2Router02.sol';
import '../interfaces/IV3TwapUtilities.sol';

contract UniswapDexAdapter is IDexAdapter, Context {
  using SafeERC20 for IERC20;

  IV3TwapUtilities public immutable V3_TWAP_UTILS;
  address public immutable override V2_ROUTER;
  address public immutable override V3_ROUTER;
  bool public immutable override ASYNC_INITIALIZE;

  constructor(
    IV3TwapUtilities _v3TwapUtilities,
    address _v2Router,
    address _v3Router,
    bool _asyncInit
  ) {
    V3_TWAP_UTILS = _v3TwapUtilities;
    V2_ROUTER = _v2Router;
    V3_ROUTER = _v3Router;
    ASYNC_INITIALIZE = _asyncInit;
  }

  function WETH() external view virtual override returns (address) {
    return IUniswapV2Router02(V2_ROUTER).WETH();
  }

  function getV3Pool(
    address,
    address,
    int24
  ) external view virtual override returns (address _p) {
    _p;
    require(false, 'I0');
  }

  function getV3Pool(
    address _token0,
    address _token1,
    uint24 _poolFee
  ) external view virtual override returns (address) {
    return
      V3_TWAP_UTILS.getV3Pool(
        IPeripheryImmutableState(V3_ROUTER).factory(),
        _token0,
        _token1,
        _poolFee
      );
  }

  function getV2Pool(
    address _token0,
    address _token1
  ) external view virtual override returns (address) {
    return
      IUniswapV2Factory(IUniswapV2Router02(V2_ROUTER).factory()).getPair(
        _token0,
        _token1
      );
  }

  function createV2Pool(
    address _token0,
    address _token1
  ) external virtual override returns (address) {
    return
      IUniswapV2Factory(IUniswapV2Router02(V2_ROUTER).factory()).createPair(
        _token0,
        _token1
      );
  }

  function swapV2Single(
    address _tokenIn,
    address _tokenOut,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external virtual override returns (uint256 _amountOut) {
    uint256 _outBefore = IERC20(_tokenOut).balanceOf(_recipient);
    if (_amountIn == 0) {
      _amountIn = IERC20(_tokenIn).balanceOf(address(this));
    } else {
      IERC20(_tokenIn).safeTransferFrom(_msgSender(), address(this), _amountIn);
    }
    address[] memory _path = new address[](2);
    _path[0] = _tokenIn;
    _path[1] = _tokenOut;
    IERC20(_tokenIn).safeIncreaseAllowance(V2_ROUTER, _amountIn);
    IUniswapV2Router02(V2_ROUTER)
      .swapExactTokensForTokensSupportingFeeOnTransferTokens(
        _amountIn,
        _amountOutMin,
        _path,
        _recipient,
        block.timestamp
      );
    return IERC20(_tokenOut).balanceOf(_recipient) - _outBefore;
  }

  function swapV3Single(
    address _tokenIn,
    address _tokenOut,
    uint24 _fee,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address _recipient
  ) external virtual override returns (uint256 _amountOut) {
    uint256 _outBefore = IERC20(_tokenOut).balanceOf(_recipient);
    if (_amountIn == 0) {
      _amountIn = IERC20(_tokenIn).balanceOf(address(this));
    } else {
      IERC20(_tokenIn).safeTransferFrom(_msgSender(), address(this), _amountIn);
    }
    IERC20(_tokenIn).safeIncreaseAllowance(V3_ROUTER, _amountIn);
    ISwapRouter02(V3_ROUTER).exactInputSingle(
      ISwapRouter02.ExactInputSingleParams({
        tokenIn: _tokenIn,
        tokenOut: _tokenOut,
        fee: _fee,
        recipient: _recipient,
        amountIn: _amountIn,
        amountOutMinimum: _amountOutMin,
        sqrtPriceLimitX96: 0
      })
    );
    return IERC20(_tokenOut).balanceOf(_recipient) - _outBefore;
  }

  function addLiquidity(
    address _tokenA,
    address _tokenB,
    uint256 _amountADesired,
    uint256 _amountBDesired,
    uint256 _amountAMin,
    uint256 _amountBMin,
    address _to,
    uint256 _deadline
  ) external virtual override {
    uint256 _aBefore = IERC20(_tokenA).balanceOf(address(this));
    uint256 _bBefore = IERC20(_tokenB).balanceOf(address(this));
    IERC20(_tokenA).safeTransferFrom(
      _msgSender(),
      address(this),
      _amountADesired
    );
    IERC20(_tokenB).safeTransferFrom(
      _msgSender(),
      address(this),
      _amountBDesired
    );
    IERC20(_tokenA).safeIncreaseAllowance(V2_ROUTER, _amountADesired);
    IERC20(_tokenB).safeIncreaseAllowance(V2_ROUTER, _amountBDesired);
    IUniswapV2Router02(V2_ROUTER).addLiquidity(
      _tokenA,
      _tokenB,
      _amountADesired,
      _amountBDesired,
      _amountAMin,
      _amountBMin,
      _to,
      _deadline
    );
    if (IERC20(_tokenA).balanceOf(address(this)) > _aBefore) {
      IERC20(_tokenA).safeTransfer(
        _to,
        IERC20(_tokenA).balanceOf(address(this)) - _aBefore
      );
    }
    if (IERC20(_tokenB).balanceOf(address(this)) > _bBefore) {
      IERC20(_tokenB).safeTransfer(
        _to,
        IERC20(_tokenB).balanceOf(address(this)) - _bBefore
      );
    }
  }

  function removeLiquidity(
    address _tokenA,
    address _tokenB,
    uint256 _liquidity,
    uint256 _amountAMin,
    uint256 _amountBMin,
    address _to,
    uint256 _deadline
  ) external virtual override {
    address _pool = IUniswapV2Factory(IUniswapV2Router02(V2_ROUTER).factory())
      .getPair(_tokenA, _tokenB);
    uint256 _lpBefore = IERC20(_pool).balanceOf(address(this));
    IERC20(_pool).safeTransferFrom(_msgSender(), address(this), _liquidity);
    IERC20(_pool).safeIncreaseAllowance(V2_ROUTER, _liquidity);
    IUniswapV2Router02(V2_ROUTER).removeLiquidity(
      _tokenA,
      _tokenB,
      _liquidity,
      _amountAMin,
      _amountBMin,
      _to,
      _deadline
    );
    if (IERC20(_pool).balanceOf(address(this)) > _lpBefore) {
      IERC20(_pool).safeTransfer(
        _to,
        IERC20(_pool).balanceOf(address(this)) - _lpBefore
      );
    }
  }

  function extraRewardsHook(
    address,
    address
  )
    external
    virtual
    override
    returns (address[] memory _t, uint256[] memory _a)
  {
    _t;
    _a;
  }
}

{
  "compilationTarget": {
    "contracts/dex/AerodromeDexAdapter.sol": "AerodromeDexAdapter"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}