@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-periphery-main/contracts/base/PeripheryPaymentsWithFee.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@uniswap/v3-core/contracts/libraries/LowGasSafeMath.sol';
+
+import './PeripheryPayments.sol';
+import '../interfaces/IPeripheryPaymentsWithFee.sol';
+
+import '../interfaces/external/IWETH9.sol';
+import '../libraries/TransferHelper.sol';
+
+abstract contract PeripheryPaymentsWithFee is PeripheryPayments, IPeripheryPaymentsWithFee {
+    using LowGasSafeMath for uint256;
+
+    /// @inheritdoc IPeripheryPaymentsWithFee
+    function unwrapWETH9WithFee(
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) public payable override {
+        require(feeBips > 0 && feeBips <= 100);
+
+        uint256 balanceWETH9 = IWETH9(WETH9).balanceOf(address(this));
+        require(balanceWETH9 >= amountMinimum, 'Insufficient WETH9');
+
+        if (balanceWETH9 > 0) {
+            IWETH9(WETH9).withdraw(balanceWETH9);
+            uint256 feeAmount = balanceWETH9.mul(feeBips) / 10_000;
+            if (feeAmount > 0) TransferHelper.safeTransferETH(feeRecipient, feeAmount);
+            TransferHelper.safeTransferETH(recipient, balanceWETH9 - feeAmount);
+        }
+    }
+
+    /// @inheritdoc IPeripheryPaymentsWithFee
+    function sweepTokenWithFee(
+        address token,
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) public payable override {
+        require(feeBips > 0 && feeBips <= 100);
+
+        uint256 balanceToken = IERC20(token).balanceOf(address(this));
+        require(balanceToken >= amountMinimum, 'Insufficient token');
+
+        if (balanceToken > 0) {
+            uint256 feeAmount = balanceToken.mul(feeBips) / 10_000;
+            if (feeAmount > 0) TransferHelper.safeTransfer(token, feeRecipient, feeAmount);
+            TransferHelper.safeTransfer(token, recipient, balanceToken - feeAmount);
+        }
+    }
+}

package/lib/v3-periphery-main/contracts/base/PeripheryValidation.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import './BlockTimestamp.sol';
+
+abstract contract PeripheryValidation is BlockTimestamp {
+    modifier checkDeadline(uint256 deadline) {
+        require(_blockTimestamp() <= deadline, 'Transaction too old');
+        _;
+    }
+}

package/lib/v3-periphery-main/contracts/base/PoolInitializer.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol';
+import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
+
+import './PeripheryImmutableState.sol';
+import '../interfaces/IPoolInitializer.sol';
+
+/// @title Creates and initializes V3 Pools
+abstract contract PoolInitializer is IPoolInitializer, PeripheryImmutableState {
+    /// @inheritdoc IPoolInitializer
+    function createAndInitializePoolIfNecessary(
+        address token0,
+        address token1,
+        uint24 fee,
+        uint160 sqrtPriceX96
+    ) external payable override returns (address pool) {
+        require(token0 < token1);
+        pool = IUniswapV3Factory(factory).getPool(token0, token1, fee);
+
+        if (pool == address(0)) {
+            pool = IUniswapV3Factory(factory).createPool(token0, token1, fee);
+            IUniswapV3Pool(pool).initialize(sqrtPriceX96);
+        } else {
+            (uint160 sqrtPriceX96Existing, , , , , , ) = IUniswapV3Pool(pool).slot0();
+            if (sqrtPriceX96Existing == 0) {
+                IUniswapV3Pool(pool).initialize(sqrtPriceX96);
+            }
+        }
+    }
+}

package/lib/v3-periphery-main/contracts/base/SelfPermit.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@openzeppelin/contracts/drafts/IERC20Permit.sol';
+
+import '../interfaces/ISelfPermit.sol';
+import '../interfaces/external/IERC20PermitAllowed.sol';
+
+/// @title Self Permit
+/// @notice Functionality to call permit on any EIP-2612-compliant token for use in the route
+/// @dev These functions are expected to be embedded in multicalls to allow EOAs to approve a contract and call a function
+/// that requires an approval in a single transaction.
+abstract contract SelfPermit is ISelfPermit {
+    /// @inheritdoc ISelfPermit
+    function selfPermit(
+        address token,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public payable override {
+        IERC20Permit(token).permit(msg.sender, address(this), value, deadline, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitIfNecessary(
+        address token,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        if (IERC20(token).allowance(msg.sender, address(this)) < value) selfPermit(token, value, deadline, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitAllowed(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public payable override {
+        IERC20PermitAllowed(token).permit(msg.sender, address(this), nonce, expiry, true, v, r, s);
+    }
+
+    /// @inheritdoc ISelfPermit
+    function selfPermitAllowedIfNecessary(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable override {
+        if (IERC20(token).allowance(msg.sender, address(this)) < type(uint256).max)
+            selfPermitAllowed(token, nonce, expiry, v, r, s);
+    }
+}

package/lib/v3-periphery-main/contracts/examples/PairFlash.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol';
+import '@uniswap/v3-core/contracts/libraries/LowGasSafeMath.sol';
+
+import '../base/PeripheryPayments.sol';
+import '../base/PeripheryImmutableState.sol';
+import '../libraries/PoolAddress.sol';
+import '../libraries/CallbackValidation.sol';
+import '../libraries/TransferHelper.sol';
+import '../interfaces/ISwapRouter.sol';
+
+/// @title Flash contract implementation
+/// @notice An example contract using the Uniswap V3 flash function
+contract PairFlash is IUniswapV3FlashCallback, PeripheryPayments {
+    using LowGasSafeMath for uint256;
+    using LowGasSafeMath for int256;
+
+    ISwapRouter public immutable swapRouter;
+
+    constructor(
+        ISwapRouter _swapRouter,
+        address _factory,
+        address _WETH9
+    ) PeripheryImmutableState(_factory, _WETH9) {
+        swapRouter = _swapRouter;
+    }
+
+    // fee2 and fee3 are the two other fees associated with the two other pools of token0 and token1
+    struct FlashCallbackData {
+        uint256 amount0;
+        uint256 amount1;
+        address payer;
+        PoolAddress.PoolKey poolKey;
+        uint24 poolFee2;
+        uint24 poolFee3;
+    }
+
+    /// @param fee0 The fee from calling flash for token0
+    /// @param fee1 The fee from calling flash for token1
+    /// @param data The data needed in the callback passed as FlashCallbackData from `initFlash`
+    /// @notice implements the callback called from flash
+    /// @dev fails if the flash is not profitable, meaning the amountOut from the flash is less than the amount borrowed
+    function uniswapV3FlashCallback(
+        uint256 fee0,
+        uint256 fee1,
+        bytes calldata data
+    ) external override {
+        FlashCallbackData memory decoded = abi.decode(data, (FlashCallbackData));
+        CallbackValidation.verifyCallback(factory, decoded.poolKey);
+
+        address token0 = decoded.poolKey.token0;
+        address token1 = decoded.poolKey.token1;
+
+        // profitability parameters - we must receive at least the required payment from the arbitrage swaps
+        // exactInputSingle will fail if this amount not met
+        uint256 amount0Min = LowGasSafeMath.add(decoded.amount0, fee0);
+        uint256 amount1Min = LowGasSafeMath.add(decoded.amount1, fee1);
+
+        // call exactInputSingle for swapping token1 for token0 in pool with fee2
+        TransferHelper.safeApprove(token1, address(swapRouter), decoded.amount1);
+        uint256 amountOut0 =
+            swapRouter.exactInputSingle(
+                ISwapRouter.ExactInputSingleParams({
+                    tokenIn: token1,
+                    tokenOut: token0,
+                    fee: decoded.poolFee2,
+                    recipient: address(this),
+                    deadline: block.timestamp,
+                    amountIn: decoded.amount1,
+                    amountOutMinimum: amount0Min,
+                    sqrtPriceLimitX96: 0
+                })
+            );
+
+        // call exactInputSingle for swapping token0 for token 1 in pool with fee3
+        TransferHelper.safeApprove(token0, address(swapRouter), decoded.amount0);
+        uint256 amountOut1 =
+            swapRouter.exactInputSingle(
+                ISwapRouter.ExactInputSingleParams({
+                    tokenIn: token0,
+                    tokenOut: token1,
+                    fee: decoded.poolFee3,
+                    recipient: address(this),
+                    deadline: block.timestamp,
+                    amountIn: decoded.amount0,
+                    amountOutMinimum: amount1Min,
+                    sqrtPriceLimitX96: 0
+                })
+            );
+
+        // pay the required amounts back to the pair
+        if (amount0Min > 0) pay(token0, address(this), msg.sender, amount0Min);
+        if (amount1Min > 0) pay(token1, address(this), msg.sender, amount1Min);
+
+        // if profitable pay profits to payer
+        if (amountOut0 > amount0Min) {
+            uint256 profit0 = amountOut0 - amount0Min;
+            pay(token0, address(this), decoded.payer, profit0);
+        }
+        if (amountOut1 > amount1Min) {
+            uint256 profit1 = amountOut1 - amount1Min;
+            pay(token1, address(this), decoded.payer, profit1);
+        }
+    }
+
+    //fee1 is the fee of the pool from the initial borrow
+    //fee2 is the fee of the first pool to arb from
+    //fee3 is the fee of the second pool to arb from
+    struct FlashParams {
+        address token0;
+        address token1;
+        uint24 fee1;
+        uint256 amount0;
+        uint256 amount1;
+        uint24 fee2;
+        uint24 fee3;
+    }
+
+    /// @param params The parameters necessary for flash and the callback, passed in as FlashParams
+    /// @notice Calls the pools flash function with data needed in `uniswapV3FlashCallback`
+    function initFlash(FlashParams memory params) external {
+        PoolAddress.PoolKey memory poolKey =
+            PoolAddress.PoolKey({token0: params.token0, token1: params.token1, fee: params.fee1});
+        IUniswapV3Pool pool = IUniswapV3Pool(PoolAddress.computeAddress(factory, poolKey));
+        // recipient of borrowed amounts
+        // amount of token0 requested to borrow
+        // amount of token1 requested to borrow
+        // need amount 0 and amount1 in callback to pay back pool
+        // recipient of flash should be THIS contract
+        pool.flash(
+            address(this),
+            params.amount0,
+            params.amount1,
+            abi.encode(
+                FlashCallbackData({
+                    amount0: params.amount0,
+                    amount1: params.amount1,
+                    payer: msg.sender,
+                    poolKey: poolKey,
+                    poolFee2: params.fee2,
+                    poolFee3: params.fee3
+                })
+            )
+        );
+    }
+}

package/lib/v3-periphery-main/contracts/interfaces/IERC20Metadata.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.7.0;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+/// @title IERC20Metadata
+/// @title Interface for ERC20 Metadata
+/// @notice Extension to IERC20 that includes token metadata
+interface IERC20Metadata is IERC20 {
+    /// @return The name of the token
+    function name() external view returns (string memory);
+
+    /// @return The symbol of the token
+    function symbol() external view returns (string memory);
+
+    /// @return The number of decimal places the token has
+    function decimals() external view returns (uint8);
+}

package/lib/v3-periphery-main/contracts/interfaces/IERC721Permit.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+
+/// @title ERC721 with permit
+/// @notice Extension to ERC721 that includes a permit function for signature based approvals
+interface IERC721Permit is IERC721 {
+    /// @notice The permit typehash used in the permit signature
+    /// @return The typehash for the permit
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    /// @notice The domain separator used in the permit signature
+    /// @return The domain seperator used in encoding of permit signature
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    /// @notice Approve of a specific token ID for spending by spender via signature
+    /// @param spender The account that is being approved
+    /// @param tokenId The ID of the token that is being approved for spending
+    /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
+    /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
+    /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
+    /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
+    function permit(
+        address spender,
+        uint256 tokenId,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable;
+}

package/lib/v3-periphery-main/contracts/interfaces/IMulticall.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+pragma abicoder v2;
+
+/// @title Multicall interface
+/// @notice Enables calling multiple methods in a single call to the contract
+interface IMulticall {
+    /// @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
+    /// @dev The `msg.value` should not be trusted for any method callable from multicall.
+    /// @param data The encoded function data for each of the calls to make to this contract
+    /// @return results The results from each of the calls passed in via data
+    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
+}

package/lib/v3-periphery-main/contracts/interfaces/INonfungiblePositionManager.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+pragma abicoder v2;
+
+import '@openzeppelin/contracts/token/ERC721/IERC721Metadata.sol';
+import '@openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol';
+
+import './IPoolInitializer.sol';
+import './IERC721Permit.sol';
+import './IPeripheryPayments.sol';
+import './IPeripheryImmutableState.sol';
+
+/// @title Non-fungible token for positions
+/// @notice Wraps Uniswap V3 positions in a non-fungible token interface which allows for them to be transferred
+/// and authorized.
+interface INonfungiblePositionManager is
+    IPoolInitializer,
+    IPeripheryPayments,
+    IPeripheryImmutableState,
+    IERC721Metadata,
+    IERC721Enumerable,
+    IERC721Permit
+{
+    /// @notice Emitted when liquidity is increased for a position NFT
+    /// @dev Also emitted when a token is minted
+    /// @param tokenId The ID of the token for which liquidity was increased
+    /// @param liquidity The amount by which liquidity for the NFT position was increased
+    /// @param amount0 The amount of token0 that was paid for the increase in liquidity
+    /// @param amount1 The amount of token1 that was paid for the increase in liquidity
+    event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+    /// @notice Emitted when liquidity is decreased for a position NFT
+    /// @param tokenId The ID of the token for which liquidity was decreased
+    /// @param liquidity The amount by which liquidity for the NFT position was decreased
+    /// @param amount0 The amount of token0 that was accounted for the decrease in liquidity
+    /// @param amount1 The amount of token1 that was accounted for the decrease in liquidity
+    event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+    /// @notice Emitted when tokens are collected for a position NFT
+    /// @dev The amounts reported may not be exactly equivalent to the amounts transferred, due to rounding behavior
+    /// @param tokenId The ID of the token for which underlying tokens were collected
+    /// @param recipient The address of the account that received the collected tokens
+    /// @param amount0 The amount of token0 owed to the position that was collected
+    /// @param amount1 The amount of token1 owed to the position that was collected
+    event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);
+
+    /// @notice Returns the position information associated with a given token ID.
+    /// @dev Throws if the token ID is not valid.
+    /// @param tokenId The ID of the token that represents the position
+    /// @return nonce The nonce for permits
+    /// @return operator The address that is approved for spending
+    /// @return token0 The address of the token0 for a specific pool
+    /// @return token1 The address of the token1 for a specific pool
+    /// @return fee The fee associated with the pool
+    /// @return tickLower The lower end of the tick range for the position
+    /// @return tickUpper The higher end of the tick range for the position
+    /// @return liquidity The liquidity of the position
+    /// @return feeGrowthInside0LastX128 The fee growth of token0 as of the last action on the individual position
+    /// @return feeGrowthInside1LastX128 The fee growth of token1 as of the last action on the individual position
+    /// @return tokensOwed0 The uncollected amount of token0 owed to the position as of the last computation
+    /// @return tokensOwed1 The uncollected amount of token1 owed to the position as of the last computation
+    function positions(uint256 tokenId)
+        external
+        view
+        returns (
+            uint96 nonce,
+            address operator,
+            address token0,
+            address token1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        );
+
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    /// @notice Creates a new position wrapped in a NFT
+    /// @dev Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
+    /// a method does not exist, i.e. the pool is assumed to be initialized.
+    /// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
+    /// @return tokenId The ID of the token that represents the minted position
+    /// @return liquidity The amount of liquidity for this position
+    /// @return amount0 The amount of token0
+    /// @return amount1 The amount of token1
+    function mint(MintParams calldata params)
+        external
+        payable
+        returns (
+            uint256 tokenId,
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1
+        );
+
+    struct IncreaseLiquidityParams {
+        uint256 tokenId;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
+    /// @param params tokenId The ID of the token for which liquidity is being increased,
+    /// amount0Desired The desired amount of token0 to be spent,
+    /// amount1Desired The desired amount of token1 to be spent,
+    /// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
+    /// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
+    /// deadline The time by which the transaction must be included to effect the change
+    /// @return liquidity The new liquidity amount as a result of the increase
+    /// @return amount0 The amount of token0 to acheive resulting liquidity
+    /// @return amount1 The amount of token1 to acheive resulting liquidity
+    function increaseLiquidity(IncreaseLiquidityParams calldata params)
+        external
+        payable
+        returns (
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1
+        );
+
+    struct DecreaseLiquidityParams {
+        uint256 tokenId;
+        uint128 liquidity;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Decreases the amount of liquidity in a position and accounts it to the position
+    /// @param params tokenId The ID of the token for which liquidity is being decreased,
+    /// amount The amount by which liquidity will be decreased,
+    /// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
+    /// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
+    /// deadline The time by which the transaction must be included to effect the change
+    /// @return amount0 The amount of token0 accounted to the position's tokens owed
+    /// @return amount1 The amount of token1 accounted to the position's tokens owed
+    function decreaseLiquidity(DecreaseLiquidityParams calldata params)
+        external
+        payable
+        returns (uint256 amount0, uint256 amount1);
+
+    struct CollectParams {
+        uint256 tokenId;
+        address recipient;
+        uint128 amount0Max;
+        uint128 amount1Max;
+    }
+
+    /// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
+    /// @param params tokenId The ID of the NFT for which tokens are being collected,
+    /// recipient The account that should receive the tokens,
+    /// amount0Max The maximum amount of token0 to collect,
+    /// amount1Max The maximum amount of token1 to collect
+    /// @return amount0 The amount of fees collected in token0
+    /// @return amount1 The amount of fees collected in token1
+    function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
+
+    /// @notice Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens
+    /// must be collected first.
+    /// @param tokenId The ID of the token that is being burned
+    function burn(uint256 tokenId) external payable;
+}

package/lib/v3-periphery-main/contracts/interfaces/INonfungibleTokenPositionDescriptor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import './INonfungiblePositionManager.sol';
+
+/// @title Describes position NFT tokens via URI
+interface INonfungibleTokenPositionDescriptor {
+    /// @notice Produces the URI describing a particular token ID for a position manager
+    /// @dev Note this URI may be a data: URI with the JSON contents directly inlined
+    /// @param positionManager The position manager for which to describe the token
+    /// @param tokenId The ID of the token for which to produce a description, which may not be valid
+    /// @return The URI of the ERC721-compliant metadata
+    function tokenURI(INonfungiblePositionManager positionManager, uint256 tokenId)
+        external
+        view
+        returns (string memory);
+}

package/lib/v3-periphery-main/contracts/interfaces/IPeripheryImmutableState.sol

@@ -0,0 +1,12 @@
+// 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);
+}

package/lib/v3-periphery-main/contracts/interfaces/IPeripheryPayments.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+/// @title Periphery Payments
+/// @notice Functions to ease deposits and withdrawals of ETH
+interface IPeripheryPayments {
+    /// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH.
+    /// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
+    /// @param amountMinimum The minimum amount of WETH9 to unwrap
+    /// @param recipient The address receiving ETH
+    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;
+
+    /// @notice Refunds any ETH balance held by this contract to the `msg.sender`
+    /// @dev Useful for bundling with mint or increase liquidity that uses ether, or exact output swaps
+    /// that use ether for the input amount
+    function refundETH() external payable;
+
+    /// @notice Transfers the full amount of a token held by this contract to recipient
+    /// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
+    /// @param token The contract address of the token which will be transferred to `recipient`
+    /// @param amountMinimum The minimum amount of token required for a transfer
+    /// @param recipient The destination address of the token
+    function sweepToken(
+        address token,
+        uint256 amountMinimum,
+        address recipient
+    ) external payable;
+}

package/lib/v3-periphery-main/contracts/interfaces/IPeripheryPaymentsWithFee.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+
+import './IPeripheryPayments.sol';
+
+/// @title Periphery Payments
+/// @notice Functions to ease deposits and withdrawals of ETH
+interface IPeripheryPaymentsWithFee is IPeripheryPayments {
+    /// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH, with a percentage between
+    /// 0 (exclusive), and 1 (inclusive) going to feeRecipient
+    /// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
+    function unwrapWETH9WithFee(
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) external payable;
+
+    /// @notice Transfers the full amount of a token held by this contract to recipient, with a percentage between
+    /// 0 (exclusive) and 1 (inclusive) going to feeRecipient
+    /// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
+    function sweepTokenWithFee(
+        address token,
+        uint256 amountMinimum,
+        address recipient,
+        uint256 feeBips,
+        address feeRecipient
+    ) external payable;
+}