Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import { VelodromeRouterConnector } from
    "contracts/connectors/velodrome/VelodromeRouterConnector.sol";

contract SwapxRouterConnector is VelodromeRouterConnector { }

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

import { IRouter } from "contracts/interfaces/external/aerodrome/IRouter.sol";
import { IPool } from "contracts/interfaces/external/aerodrome/IPool.sol";

import {
    ILiquidityConnector,
    AddLiquidityParams,
    RemoveLiquidityParams,
    SwapParams,
    GetAmountOutParams
} from "contracts/interfaces/ILiquidityConnector.sol";

struct VelodromeLiquidityExtraData {
    bool isStablePool;
}

struct VelodromeSwapExtraData {
    IRouter.Route[] routes;
}

contract VelodromeRouterConnector is ILiquidityConnector {
    function addLiquidity(
        AddLiquidityParams memory addLiquidityParams
    ) external payable override {
        VelodromeLiquidityExtraData memory _extraData = abi.decode(
            addLiquidityParams.extraData, (VelodromeLiquidityExtraData)
        );
        IRouter(addLiquidityParams.router).addLiquidity(
            addLiquidityParams.tokens[0],
            addLiquidityParams.tokens[1],
            _extraData.isStablePool,
            addLiquidityParams.desiredAmounts[0],
            addLiquidityParams.desiredAmounts[1],
            addLiquidityParams.minAmounts[0],
            addLiquidityParams.minAmounts[1],
            address(this),
            block.timestamp
        );
    }

    function removeLiquidity(
        RemoveLiquidityParams memory removeLiquidityParams
    ) external override {
        VelodromeLiquidityExtraData memory _extraData = abi.decode(
            removeLiquidityParams.extraData, (VelodromeLiquidityExtraData)
        );
        IRouter(removeLiquidityParams.router).removeLiquidity(
            removeLiquidityParams.tokens[0],
            removeLiquidityParams.tokens[1],
            _extraData.isStablePool,
            removeLiquidityParams.lpAmountIn,
            removeLiquidityParams.minAmountsOut[0],
            removeLiquidityParams.minAmountsOut[1],
            address(this),
            block.timestamp
        );
    }

    function swapExactTokensForTokens(
        SwapParams memory swap
    ) external payable override {
        VelodromeSwapExtraData memory _extraData =
            abi.decode(swap.extraData, (VelodromeSwapExtraData));
        IRouter(swap.router).swapExactTokensForTokens(
            swap.amountIn,
            swap.minAmountOut,
            _extraData.routes,
            address(this),
            block.timestamp
        );
    }

    function getAmountOut(
        GetAmountOutParams memory getAmountOutParams
    ) external view override returns (uint256) {
        return IPool(getAmountOutParams.lpToken).getAmountOut(
            getAmountOutParams.amountIn, getAmountOutParams.tokenIn
        );
    }
}

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

import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";

interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint256) external;
}

interface IRouter {
    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);
}

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

interface IPool {
    error DepositsNotEqual();
    error BelowMinimumK();
    error FactoryAlreadySet();
    error InsufficientLiquidity();
    error InsufficientLiquidityMinted();
    error InsufficientLiquidityBurned();
    error InsufficientOutputAmount();
    error InsufficientInputAmount();
    error IsPaused();
    error InvalidTo();
    error K();
    error NotEmergencyCouncil();

    event Fees(address indexed sender, uint256 amount0, uint256 amount1);
    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        address indexed to,
        uint256 amount0,
        uint256 amount1
    );
    event Swap(
        address indexed sender,
        address indexed to,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out
    );
    event Sync(uint256 reserve0, uint256 reserve1);
    event Claim(
        address indexed sender,
        address indexed recipient,
        uint256 amount0,
        uint256 amount1
    );

    // Struct to capture time period obervations every 30 minutes, used for
    // local oracles
    struct Observation {
        uint256 timestamp;
        uint256 reserve0Cumulative;
        uint256 reserve1Cumulative;
    }

    /// @notice The 0th storage slot in the pool stores many values, and is
    /// exposed as a single method to save gas
    /// when accessed externally.
    /// @return sqrtPriceX96 The current price of the pool as a
    /// sqrt(token1/token0) Q64.96 value
    /// @return tick The current tick of the pool, i.e. according to the last
    /// tick transition that was run.
    /// This value may not always be equal to
    /// SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
    /// boundary.
    /// @return observationIndex The index of the last oracle observation that
    /// was written,
    /// @return observationCardinality The current maximum number of
    /// observations stored in the pool,
    /// @return observationCardinalityNext The next maximum number of
    /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted
    /// 4 bits and the protocol fee of token0
    /// is the lower 4 bits. Used as the denominator of a fraction of the swap
    /// fee, e.g. 4 means 1/4th of the swap fee.
    /// unlocked Whether the pool is currently locked to reentrancy
    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            bool unlocked
        );

    /// @notice Returns the decimal (dec), reserves (r), stable (st), and tokens
    /// (t) of token0 and token1
    function metadata()
        external
        view
        returns (
            uint256 dec0,
            uint256 dec1,
            uint256 r0,
            uint256 r1,
            bool st,
            address t0,
            address t1
        );

    /// @notice Claim accumulated but unclaimed fees (claimable0 and claimable1)
    function claimFees() external returns (uint256, uint256);

    /// @notice Returns [token0, token1]
    function tokens() external view returns (address, address);

    /// @notice Address of token in the pool with the lower address value
    function token0() external view returns (address);

    /// @notice Address of token in the poool with the higher address value
    function token1() external view returns (address);

    /// @notice Address of linked PoolFees.sol
    function poolFees() external view returns (address);

    /// @notice Address of PoolFactory that created this contract
    function factory() external view returns (address);

    /// @notice Capture oracle reading every 30 minutes (1800 seconds)
    function periodSize() external view returns (uint256);

    /// @notice Amount of token0 in pool
    function reserve0() external view returns (uint256);

    /// @notice Amount of token1 in pool
    function reserve1() external view returns (uint256);

    /// @notice Timestamp of last update to pool
    function blockTimestampLast() external view returns (uint256);

    /// @notice Cumulative of reserve0 factoring in time elapsed
    function reserve0CumulativeLast() external view returns (uint256);

    /// @notice Cumulative of reserve1 factoring in time elapsed
    function reserve1CumulativeLast() external view returns (uint256);

    /// @notice Accumulated fees of token0 (global)
    function index0() external view returns (uint256);

    /// @notice Accumulated fees of token1 (global)
    function index1() external view returns (uint256);

    /// @notice Get an LP's relative index0 to index0
    function supplyIndex0(
        address
    ) external view returns (uint256);

    /// @notice Get an LP's relative index1 to index1
    function supplyIndex1(
        address
    ) external view returns (uint256);

    /// @notice Amount of unclaimed, but claimable tokens from fees of token0
    /// for an LP
    function claimable0(
        address
    ) external view returns (uint256);

    /// @notice Amount of unclaimed, but claimable tokens from fees of token1
    /// for an LP
    function claimable1(
        address
    ) external view returns (uint256);

    /// @notice Returns the value of K in the Pool, based on its reserves.
    function getK() external returns (uint256);

    /// @notice Set pool name
    ///         Only callable by Voter.emergencyCouncil()
    /// @param __name String of new name
    function setName(
        string calldata __name
    ) external;

    /// @notice Set pool symbol
    ///         Only callable by Voter.emergencyCouncil()
    /// @param __symbol String of new symbol
    function setSymbol(
        string calldata __symbol
    ) external;

    /// @notice Get the number of observations recorded
    function observationLength() external view returns (uint256);

    /// @notice Get the value of the most recent observation
    function lastObservation() external view returns (Observation memory);

    /// @notice True if pool is stable, false if volatile
    function stable() external view returns (bool);

    /// @notice Produces the cumulative price using counterfactuals to save gas
    /// and avoid a call to sync.
    function currentCumulativePrices()
        external
        view
        returns (
            uint256 reserve0Cumulative,
            uint256 reserve1Cumulative,
            uint256 blockTimestamp
        );

    /// @notice Provides twap price with user configured granularity, up to the
    /// full window size
    /// @param tokenIn .
    /// @param amountIn .
    /// @param granularity .
    /// @return amountOut .
    function quote(
        address tokenIn,
        uint256 amountIn,
        uint256 granularity
    ) external view returns (uint256 amountOut);

    /// @notice Returns a memory set of TWAP prices
    ///         Same as calling sample(tokenIn, amountIn, points, 1)
    /// @param tokenIn .
    /// @param amountIn .
    /// @param points Number of points to return
    /// @return Array of TWAP prices
    function prices(
        address tokenIn,
        uint256 amountIn,
        uint256 points
    ) external view returns (uint256[] memory);

    /// @notice Same as prices with with an additional window argument.
    ///         Window = 2 means 2 * 30min (or 1 hr) between observations
    /// @param tokenIn .
    /// @param amountIn .
    /// @param points .
    /// @param window .
    /// @return Array of TWAP prices
    function sample(
        address tokenIn,
        uint256 amountIn,
        uint256 points,
        uint256 window
    ) external view returns (uint256[] memory);

    /// @notice This low-level function should be called from a contract which
    /// performs important safety checks
    /// @param amount0Out   Amount of token0 to send to `to`
    /// @param amount1Out   Amount of token1 to send to `to`
    /// @param to           Address to recieve the swapped output
    /// @param data         Additional calldata for flashloans
    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    /// @notice This low-level function should be called from a contract which
    /// performs important safety checks
    ///         standard uniswap v2 implementation
    /// @param to Address to receive token0 and token1 from burning the pool
    /// token
    /// @return amount0 Amount of token0 returned
    /// @return amount1 Amount of token1 returned
    function burn(
        address to
    ) external returns (uint256 amount0, uint256 amount1);

    /// @notice This low-level function should be called by addLiquidity
    /// functions in Router.sol, which performs important safety checks
    ///         standard uniswap v2 implementation
    /// @param to           Address to receive the minted LP token
    /// @return liquidity   Amount of LP token minted
    function mint(
        address to
    ) external returns (uint256 liquidity);

    /// @notice Update reserves and, on the first call per block, price
    /// accumulators
    /// @return _reserve0 .
    /// @return _reserve1 .
    /// @return _blockTimestampLast .
    function getReserves()
        external
        view
        returns (
            uint256 _reserve0,
            uint256 _reserve1,
            uint256 _blockTimestampLast
        );

    /// @notice Get the amount of tokenOut given the amount of tokenIn
    /// @param amountIn Amount of token in
    /// @param tokenIn  Address of token
    /// @return Amount out
    function getAmountOut(
        uint256 amountIn,
        address tokenIn
    ) external view returns (uint256);

    /// @notice Force balances to match reserves
    /// @param to Address to receive any skimmed rewards
    function skim(
        address to
    ) external;

    /// @notice Force reserves to match balances
    function sync() external;

    /// @notice Called on pool creation by PoolFactory
    /// @param _token0 Address of token0
    /// @param _token1 Address of token1
    /// @param _stable True if stable, false if volatile
    function initialize(
        address _token0,
        address _token1,
        bool _stable
    ) external;
}

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

import {
    AddLiquidityParams,
    RemoveLiquidityParams,
    SwapParams,
    GetAmountOutParams
} from "contracts/structs/LiquidityStructs.sol";

interface ILiquidityConnector {
    function addLiquidity(
        AddLiquidityParams memory addLiquidityParams
    ) external payable;

    function removeLiquidity(
        RemoveLiquidityParams memory removeLiquidityParams
    ) external;

    function swapExactTokensForTokens(
        SwapParams memory swap
    ) external payable;

    function getAmountOut(
        GetAmountOutParams memory getAmountOutParams
    ) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;

import "../token/ERC20/IERC20.sol";

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

struct AddLiquidityParams {
    address router;
    address lpToken;
    address[] tokens;
    uint256[] desiredAmounts;
    uint256[] minAmounts;
    bytes extraData;
}

struct RemoveLiquidityParams {
    address router;
    address lpToken;
    address[] tokens;
    uint256 lpAmountIn;
    uint256[] minAmountsOut;
    bytes extraData;
}

struct SwapParams {
    address router;
    uint256 amountIn;
    uint256 minAmountOut;
    address tokenIn;
    bytes extraData;
}

struct GetAmountOutParams {
    address router;
    address lpToken;
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.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);
}

{
  "remappings": [
    "solmate/=lib/solmate/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "@uniswap/v3-periphery/=lib/v3-periphery/",
    "@uniswap/v3-core/=lib/v3-core/",
    "@morpho-blue/=lib/morpho-blue/src/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "morpho-blue/=lib/morpho-blue/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"lpToken","type":"address"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"desiredAmounts","type":"uint256[]"},{"internalType":"uint256[]","name":"minAmounts","type":"uint256[]"},{"internalType":"bytes","name":"extraData","type":"bytes"}],"internalType":"struct AddLiquidityParams","name":"addLiquidityParams","type":"tuple"}],"name":"addLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"lpToken","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"internalType":"struct GetAmountOutParams","name":"getAmountOutParams","type":"tuple"}],"name":"getAmountOut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"lpToken","type":"address"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256","name":"lpAmountIn","type":"uint256"},{"internalType":"uint256[]","name":"minAmountsOut","type":"uint256[]"},{"internalType":"bytes","name":"extraData","type":"bytes"}],"internalType":"struct RemoveLiquidityParams","name":"removeLiquidityParams","type":"tuple"}],"name":"removeLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"bytes","name":"extraData","type":"bytes"}],"internalType":"struct SwapParams","name":"swap","type":"tuple"}],"name":"swapExactTokensForTokens","outputs":[],"stateMutability":"payable","type":"function"}]

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