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 { IRamsesRouter } from
    "contracts/interfaces/external/ramses/IRamsesRouter.sol";
import { IPool } from "contracts/interfaces/external/aerodrome/IPool.sol";

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

struct NuriLiquidityExtraData {
    bool isStablePool;
}

struct NuriSwapExtraData {
    IRamsesRouter.Route[] routes;
}

contract NuriRouterConnector is ILiquidityConnector {
    function addLiquidity(
        AddLiquidityParams memory addLiquidityParams
    ) external payable override {
        NuriLiquidityExtraData memory _extraData =
            abi.decode(addLiquidityParams.extraData, (NuriLiquidityExtraData));
        IRamsesRouter(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 {
        NuriLiquidityExtraData memory _extraData = abi.decode(
            removeLiquidityParams.extraData, (NuriLiquidityExtraData)
        );
        IRamsesRouter(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 {
        NuriSwapExtraData memory _extraData =
            abi.decode(swap.extraData, (NuriSwapExtraData));
        IRamsesRouter(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 { IEqualizerRouter } from
    "contracts/interfaces/external/equalizer/IEqualizerRouter.sol";

interface IRamsesRouter is IEqualizerRouter {
    function getAmountOut(
        uint256 amountIn,
        address tokenIn,
        address tokenOut
    ) external view returns (uint256 amountOut, bool stable);
}

// 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 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
pragma solidity ^0.8.0;

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

interface IEqualizerRouter {
    struct Route {
        address from;
        address to;
        bool stable;
    }

    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 (address);

    /// @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 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,
        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;

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 v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;

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

// 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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