@uniswap/universal-router/test/integration-tests/UniswapV4.test.ts

Smart contracts for Universal Router

import type { Contract } from '@ethersproject/contracts'
import { BigNumber } from 'ethers'
import { expect } from './shared/expect'
import { IPermit2, PoolManager, PositionManager, UniversalRouter } from '../../typechain'
import { abi as TOKEN_ABI } from '../../artifacts/solmate/src/tokens/ERC20.sol/ERC20.json'
import { resetFork, WETH, DAI, USDC, PERMIT2 } from './shared/mainnetForkHelpers'
import {
  ALICE_ADDRESS,
  DEADLINE,
  ETH_ADDRESS,
  MAX_UINT,
  MAX_UINT160,
  MSG_SENDER,
  ONE_PERCENT_BIPS,
  OPEN_DELTA,
} from './shared/constants'
import { expandTo18DecimalsBN, expandTo6DecimalsBN } from './shared/helpers'
import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
import deployUniversalRouter from './shared/deployUniversalRouter'
import { CommandType, RoutePlanner } from './shared/planner'
import hre from 'hardhat'
import {
  addLiquidityToV4Pool,
  DAI_USDC,
  deployV4PoolManager,
  encodeMultihopExactInPath,
  encodeMultihopExactOutPath,
  ETH_USDC,
  initializeV4Pool,
  USDC_WETH,
} from './shared/v4Helpers'
import { Actions, V4Planner } from './shared/v4Planner'
import { executeRouter } from './shared/executeRouter'
const { ethers } = hre

describe('Uniswap V4 Tests:', () => {
  let alice: SignerWithAddress
  let bob: SignerWithAddress
  let router: UniversalRouter
  let permit2: IPermit2
  let daiContract: Contract
  let wethContract: Contract
  let usdcContract: Contract
  let planner: RoutePlanner
  let v4Planner: V4Planner
  let v4PoolManager: PoolManager
  let v4PositionManager: PositionManager

  // current market ETH price at block
  const USD_ETH_PRICE = 3820

  // USD-pegged -> (W)NATIVE trades
  // exact in trade
  const amountIn = 1000
  const amountInUSDC: BigNumber = expandTo6DecimalsBN(amountIn)
  const amountInDAI: BigNumber = expandTo18DecimalsBN(amountIn)
  const minAmountOutNative: BigNumber = expandTo18DecimalsBN(amountIn / Math.floor(USD_ETH_PRICE * 1.01))

  // exact out trade
  const amountOut = 0.26
  const amountOutNative = expandTo18DecimalsBN(amountOut)
  const maxAmountInUSDC = expandTo6DecimalsBN(amountOut * Math.floor(USD_ETH_PRICE * 1.01))
  const maxAmountInDAI = expandTo18DecimalsBN(amountOut * Math.floor(USD_ETH_PRICE * 1.01))

  // (W)NATIVE -> USD-pegged trades
  // exact in trade
  const amountInNative: BigNumber = expandTo18DecimalsBN(1.23)
  const minAmountOutUSD = Math.floor(USD_ETH_PRICE * 0.99 * 1.23)
  const minAmountOutUSDC: BigNumber = expandTo6DecimalsBN(minAmountOutUSD)
  const minAmountOutDAI: BigNumber = expandTo18DecimalsBN(minAmountOutUSD)

  // exact out trade
  const amountOutUSD = 2345
  const amountOutUSDC: BigNumber = expandTo6DecimalsBN(amountOutUSD)
  const amountOutDAI: BigNumber = expandTo18DecimalsBN(amountOutUSD)
  const maxAmountInNative: BigNumber = expandTo18DecimalsBN(amountOutUSD / Math.floor(USD_ETH_PRICE * 0.99))

  beforeEach(async () => {
    await resetFork()
    await hre.network.provider.request({
      method: 'hardhat_impersonateAccount',
      params: [ALICE_ADDRESS],
    })
    alice = await ethers.getSigner(ALICE_ADDRESS)
    bob = (await ethers.getSigners())[1]
    daiContract = new ethers.Contract(DAI.address, TOKEN_ABI, bob)
    wethContract = new ethers.Contract(WETH.address, TOKEN_ABI, bob)
    usdcContract = new ethers.Contract(USDC.address, TOKEN_ABI, bob)
    permit2 = PERMIT2.connect(bob) as IPermit2
    v4PoolManager = (await deployV4PoolManager(bob.address)).connect(bob) as PoolManager
    router = (await deployUniversalRouter(undefined, v4PoolManager.address)).connect(bob) as UniversalRouter
    v4PositionManager = (await ethers.getContractAt('PositionManager', await router.V4_POSITION_MANAGER())).connect(
      bob
    ) as PositionManager

    planner = new RoutePlanner()
    v4Planner = new V4Planner()

    // alice gives bob some tokens
    await daiContract.connect(alice).transfer(bob.address, expandTo18DecimalsBN(1000000))
    await wethContract.connect(alice).transfer(bob.address, expandTo18DecimalsBN(1000))
    await usdcContract.connect(alice).transfer(bob.address, expandTo6DecimalsBN(50000000))

    // Bob max-approves the permit2 contract to access his DAI and WETH
    await daiContract.connect(bob).approve(permit2.address, MAX_UINT)
    await wethContract.connect(bob).approve(permit2.address, MAX_UINT)
    await usdcContract.connect(bob).approve(permit2.address, MAX_UINT)

    // for these tests Bob gives the router max approval on permit2
    await permit2.approve(DAI.address, router.address, MAX_UINT160, DEADLINE)
    await permit2.approve(WETH.address, router.address, MAX_UINT160, DEADLINE)
    await permit2.approve(USDC.address, router.address, MAX_UINT160, DEADLINE)

    // for setting up pools, bob gives position manager approval on permit2
    await permit2.approve(DAI.address, v4PositionManager.address, MAX_UINT160, DEADLINE)
    await permit2.approve(WETH.address, v4PositionManager.address, MAX_UINT160, DEADLINE)
    await permit2.approve(USDC.address, v4PositionManager.address, MAX_UINT160, DEADLINE)
    // bob initializes 3 v4 pools
    await initializeV4Pool(v4PoolManager, USDC_WETH.poolKey, USDC_WETH.price)
    await initializeV4Pool(v4PoolManager, DAI_USDC.poolKey, DAI_USDC.price)
    await initializeV4Pool(v4PoolManager, ETH_USDC.poolKey, ETH_USDC.price)

    // bob adds liquidity to the pools
    await addLiquidityToV4Pool(v4PositionManager, USDC_WETH, expandTo18DecimalsBN(2).toString(), bob)
    await addLiquidityToV4Pool(v4PositionManager, DAI_USDC, expandTo18DecimalsBN(400).toString(), bob)
    await addLiquidityToV4Pool(v4PositionManager, ETH_USDC, expandTo18DecimalsBN(0.1).toString(), bob)
  })

  describe('ERC20 --> ERC20', () => {
    it('completes a v4 exactInSingle swap', async () => {
      v4Planner.addAction(Actions.SWAP_EXACT_IN_SINGLE, [
        {
          poolKey: USDC_WETH.poolKey,
          zeroForOne: true,
          amountIn: amountInUSDC,
          amountOutMinimum: minAmountOutNative,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])
      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.gte(minAmountOutNative)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.eq(amountInUSDC)
    })

    it('completes a v4 exactIn 1 hop swap', async () => {
      // USDC -> WETH
      let currencyIn = usdcContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([USDC_WETH.poolKey], currencyIn),
          amountIn: amountInUSDC,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.gte(minAmountOutNative)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.eq(amountInUSDC)
    })

    it('completes a v4 exactIn 2 hop swap', async () => {
      // DAI -> USDC -> WETH
      let currencyIn = daiContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([DAI_USDC.poolKey, USDC_WETH.poolKey], currencyIn),
          amountIn: amountInDAI,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { daiBalanceBefore, daiBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.gte(minAmountOutNative)
      expect(daiBalanceBefore.sub(daiBalanceAfter)).to.be.eq(amountInDAI)
    })

    it('completes a v4 exactIn 2 hop swap, with take portion on output', async () => {
      // DAI -> USDC -> WETH
      let currencyIn = daiContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([DAI_USDC.poolKey, USDC_WETH.poolKey], currencyIn),
          amountIn: amountInDAI,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      // take 1% of the output to alice, then settle and take the rest to the caller
      v4Planner.addAction(Actions.TAKE_PORTION, [WETH.address, alice.address, ONE_PERCENT_BIPS])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const wethBalanceBeforeAlice = await wethContract.balanceOf(alice.address)

      const { wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      const wethBalanceAfterAlice = await wethContract.balanceOf(alice.address)

      const aliceFee = wethBalanceAfterAlice.sub(wethBalanceBeforeAlice)
      const bobEarnings = wethBalanceAfter.sub(wethBalanceBefore)
      const totalOut = aliceFee.add(bobEarnings)

      expect(totalOut).to.be.gte(minAmountOutNative)
      expect(totalOut.mul(ONE_PERCENT_BIPS).div(10_000)).to.eq(aliceFee)
    })

    it('completes a v4 exactIn 2 hop swap, with take portion on input', async () => {
      // DAI -> USDC -> WETH
      let currencyIn = daiContract.address
      // trade is 1% less than previously, so adjust expected output
      let minOut = minAmountOutNative.mul(99).div(100)

      // settle the input tokens to the pool manager
      v4Planner.addAction(Actions.SETTLE, [currencyIn, amountInDAI, true])
      // take 1% of the input tokens
      v4Planner.addAction(Actions.TAKE_PORTION, [currencyIn, alice.address, ONE_PERCENT_BIPS])
      // swap using the OPEN_DELTA as input amount
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([DAI_USDC.poolKey, USDC_WETH.poolKey], currencyIn),
          amountIn: OPEN_DELTA,
          amountOutMinimum: minOut,
        },
      ])
      // take the output weth
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, minOut])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const daiBalanceBeforeAlice = await daiContract.balanceOf(alice.address)

      const { daiBalanceBefore, daiBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      const daiBalanceAfterAlice = await daiContract.balanceOf(alice.address)

      const aliceFee = daiBalanceAfterAlice.sub(daiBalanceBeforeAlice)
      const bobSpent = daiBalanceBefore.sub(daiBalanceAfter)

      expect(bobSpent.mul(ONE_PERCENT_BIPS).div(10_000)).to.eq(aliceFee)
    })

    it('completes a v4 exactIn 2 hop swap, with take portion native', async () => {
      // DAI -> USDC -> ETH
      let currencyIn = daiContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([DAI_USDC.poolKey, ETH_USDC.poolKey], currencyIn),
          amountIn: amountInDAI,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      // take 1% of the output to alice, then settle and take the rest to the caller
      v4Planner.addAction(Actions.TAKE_PORTION, [ETH_ADDRESS, alice.address, ONE_PERCENT_BIPS])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [ETH_ADDRESS, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const ethBalanceBeforeAlice: BigNumber = await ethers.provider.getBalance(alice.address)

      const { ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      const ethBalanceAfterAlice: BigNumber = await ethers.provider.getBalance(alice.address)

      const aliceFee = ethBalanceAfterAlice.sub(ethBalanceBeforeAlice)
      const bobEarnings = ethBalanceAfter.add(gasSpent).sub(ethBalanceBefore)
      const totalOut = aliceFee.add(bobEarnings)

      expect(totalOut).to.be.gte(minAmountOutNative)
      expect(totalOut.mul(ONE_PERCENT_BIPS).div(10_000)).to.eq(aliceFee)
    })

    it('completes a v4 exactOutSingle swap', async () => {
      v4Planner.addAction(Actions.SWAP_EXACT_OUT_SINGLE, [
        {
          poolKey: USDC_WETH.poolKey,
          zeroForOne: true,
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInUSDC,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.eq(amountOutNative)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.lte(maxAmountInUSDC)
    })

    it('completes a v4 exactOut 1 hop swap', async () => {
      // USDC -> WETH
      let currencyOut = wethContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([USDC_WETH.poolKey], currencyOut),
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInUSDC,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.eq(amountOutNative)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.lte(maxAmountInUSDC)
    })

    it('completes a v4 exactOut 2 hop swap', async () => {
      // DAI -> USDC -> WETH
      let currencyOut = wethContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([DAI_USDC.poolKey, USDC_WETH.poolKey], currencyOut),
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInDAI,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [daiContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [wethContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { daiBalanceBefore, daiBalanceAfter, wethBalanceBefore, wethBalanceAfter } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(wethBalanceAfter.sub(wethBalanceBefore)).to.be.eq(amountOutNative)
      expect(daiBalanceBefore.sub(daiBalanceAfter)).to.be.lte(maxAmountInDAI)
    })
  })

  describe('ETH --> ERC20', () => {
    it('completes a v4 exactInSingle swap', async () => {
      v4Planner.addAction(Actions.SWAP_EXACT_IN_SINGLE, [
        {
          poolKey: ETH_USDC.poolKey,
          zeroForOne: true,
          amountIn: amountInNative,
          amountOutMinimum: minAmountOutUSDC,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [ETH_ADDRESS, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [usdcContract.address, 0])
      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        amountInNative // pass in the ETH to the call
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.eq(amountInNative.add(gasSpent))
      expect(usdcBalanceAfter.sub(usdcBalanceBefore)).to.be.gte(minAmountOutUSDC)
    })

    it('completes a v4 exactIn 1 hop swap', async () => {
      // ETH -> USDC
      let currencyIn = ETH_ADDRESS
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([ETH_USDC.poolKey], currencyIn),
          amountIn: amountInNative,
          amountOutMinimum: minAmountOutUSDC,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [usdcContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        amountInNative // pass in the ETH to the call
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.eq(amountInNative.add(gasSpent))
      expect(usdcBalanceAfter.sub(usdcBalanceBefore)).to.be.gte(minAmountOutUSDC)
    })

    it('completes a v4 exactIn 2 hop swap', async () => {
      // ETH -> USDC -> DAI
      let currencyIn = ETH_ADDRESS
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([ETH_USDC.poolKey, DAI_USDC.poolKey], currencyIn),
          amountIn: amountInNative,
          amountOutMinimum: minAmountOutDAI,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [daiContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { daiBalanceBefore, daiBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        amountInNative // pass in the ETH to the call
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(daiBalanceAfter.sub(daiBalanceBefore)).to.be.gte(minAmountOutDAI)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.eq(amountInNative.add(gasSpent))
    })

    it('completes a v4 exactOutSingle swap', async () => {
      // ETH -> USDC
      v4Planner.addAction(Actions.SWAP_EXACT_OUT_SINGLE, [
        {
          poolKey: ETH_USDC.poolKey,
          zeroForOne: true,
          amountOut: amountOutUSDC,
          amountInMaximum: maxAmountInNative,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [ETH_ADDRESS, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [usdcContract.address, 0])
      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])
      // sweep excess ETH leftover back to the caller!
      planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, MSG_SENDER, 0])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        maxAmountInNative // send in the max amount of ETH
      )

      // no eth left in the router
      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.lte(maxAmountInNative.add(gasSpent))
      expect(usdcBalanceAfter.sub(usdcBalanceBefore)).to.be.eq(amountOutUSDC)
    })

    it('completes a v4 exactOut 1 hop swap', async () => {
      // ETH -> USDC
      let currencyOut = usdcContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([ETH_USDC.poolKey], currencyOut),
          amountOut: amountOutUSDC,
          amountInMaximum: maxAmountInNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [ETH_ADDRESS, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [currencyOut, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])
      // sweep excess ETH leftover back to the caller!
      planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, MSG_SENDER, 0])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        maxAmountInNative // send in the max amount of ETH
      )

      // no eth left in the router
      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.lte(maxAmountInNative.add(gasSpent))
      expect(usdcBalanceAfter.sub(usdcBalanceBefore)).to.be.eq(amountOutUSDC)
    })

    it('completes a v4 exactOut 2 hop swap', async () => {
      // ETH -> USDC -> DAI
      let currencyOut = daiContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([ETH_USDC.poolKey, DAI_USDC.poolKey], currencyOut),
          amountOut: amountOutDAI,
          amountInMaximum: maxAmountInNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [ETH_ADDRESS, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [daiContract.address, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])
      // sweep excess ETH leftover back to the caller!
      planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, MSG_SENDER, 0])

      const { daiBalanceBefore, daiBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract,
        maxAmountInNative // send in the max amount of ETH
      )

      // no eth left in the router
      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceBefore.sub(ethBalanceAfter)).to.be.lte(maxAmountInNative.add(gasSpent))
      expect(daiBalanceAfter.sub(daiBalanceBefore)).to.be.eq(amountOutDAI)
    })
  })

  describe('ERC20 --> ETH', () => {
    it('completes a v4 exactInSingle swap', async () => {
      // USDC -> ETH
      v4Planner.addAction(Actions.SWAP_EXACT_IN_SINGLE, [
        {
          poolKey: ETH_USDC.poolKey,
          zeroForOne: false,
          amountIn: amountInUSDC,
          amountOutMinimum: minAmountOutNative,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [ETH_ADDRESS, 0])
      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.eq(amountInUSDC)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.gte(minAmountOutNative.sub(gasSpent))
    })

    it('completes a v4 exactIn 1 hop swap', async () => {
      // USDC -> ETH
      let currencyIn = usdcContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([ETH_USDC.poolKey], currencyIn),
          amountIn: amountInUSDC,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [ETH_ADDRESS, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.eq(amountInUSDC)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.gte(minAmountOutNative.sub(gasSpent))
    })

    it('completes a v4 exactIn 2 hop swap', async () => {
      // DAI -> USDC -> ETH
      let currencyIn = daiContract.address
      v4Planner.addAction(Actions.SWAP_EXACT_IN, [
        {
          currencyIn,
          path: encodeMultihopExactInPath([DAI_USDC.poolKey, ETH_USDC.poolKey], currencyIn),
          amountIn: amountInDAI,
          amountOutMinimum: minAmountOutNative,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [currencyIn, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [ETH_ADDRESS, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { daiBalanceBefore, daiBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(daiBalanceBefore.sub(daiBalanceAfter)).to.be.eq(amountInDAI)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.gte(minAmountOutNative.sub(gasSpent))
    })

    it('completes a v4 exactOutSingle swap', async () => {
      // USDC -> ETH
      v4Planner.addAction(Actions.SWAP_EXACT_OUT_SINGLE, [
        {
          poolKey: ETH_USDC.poolKey,
          zeroForOne: false,
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInUSDC,
          hookData: '0x',
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [ETH_ADDRESS, 0])
      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.lte(maxAmountInUSDC)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.eq(amountOutNative.sub(gasSpent))
    })

    it('completes a v4 exactOut 1 hop swap', async () => {
      // USDC -> ETH
      let currencyOut = ETH_ADDRESS
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([ETH_USDC.poolKey], currencyOut),
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInUSDC,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [usdcContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [currencyOut, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { usdcBalanceBefore, usdcBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(usdcBalanceBefore.sub(usdcBalanceAfter)).to.be.lte(maxAmountInUSDC)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.eq(amountOutNative.sub(gasSpent))
    })

    it('completes a v4 exactOut 2 hop swap', async () => {
      // DAI -> USDC -> ETH
      let currencyOut = ETH_ADDRESS
      v4Planner.addAction(Actions.SWAP_EXACT_OUT, [
        {
          currencyOut,
          path: encodeMultihopExactOutPath([DAI_USDC.poolKey, ETH_USDC.poolKey], currencyOut),
          amountOut: amountOutNative,
          amountInMaximum: maxAmountInDAI,
        },
      ])
      v4Planner.addAction(Actions.SETTLE_ALL, [daiContract.address, MAX_UINT])
      v4Planner.addAction(Actions.TAKE_ALL, [currencyOut, 0])

      planner.addCommand(CommandType.V4_SWAP, [v4Planner.actions, v4Planner.params])

      const { daiBalanceBefore, daiBalanceAfter, ethBalanceBefore, ethBalanceAfter, gasSpent } = await executeRouter(
        planner,
        bob,
        router,
        wethContract,
        daiContract,
        usdcContract
      )

      expect(await ethers.provider.getBalance(router.address)).to.be.eq(0)
      expect(ethBalanceAfter.sub(ethBalanceBefore)).to.be.eq(amountOutNative.sub(gasSpent))
      expect(daiBalanceBefore.sub(daiBalanceAfter)).to.be.lte(maxAmountInDAI)
    })
  })
})