@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-periphery-main/test/TickLens.spec.ts

@@ -0,0 +1,223 @@
+import { Fixture } from 'ethereum-waffle'
+import { BigNumber, BigNumberish, constants, Contract, ContractTransaction, Wallet } from 'ethers'
+import { ethers, waffle } from 'hardhat'
+import { MockTimeNonfungiblePositionManager, TestERC20, TickLensTest } from '../typechain'
+import completeFixture from './shared/completeFixture'
+import { FeeAmount, TICK_SPACINGS } from './shared/constants'
+import { encodePriceSqrt } from './shared/encodePriceSqrt'
+import { expect } from './shared/expect'
+import { getMaxTick, getMinTick } from './shared/ticks'
+import { computePoolAddress } from './shared/computePoolAddress'
+import snapshotGasCost from './shared/snapshotGasCost'
+
+describe('TickLens', () => {
+  let wallets: Wallet[]
+
+  const nftFixture: Fixture<{
+    factory: Contract
+    nft: MockTimeNonfungiblePositionManager
+    tokens: [TestERC20, TestERC20, TestERC20]
+  }> = async (wallets, provider) => {
+    const { factory, tokens, nft } = await completeFixture(wallets, provider)
+
+    for (const token of tokens) {
+      await token.approve(nft.address, constants.MaxUint256)
+    }
+
+    return {
+      factory,
+      nft,
+      tokens,
+    }
+  }
+
+  let factory: Contract
+  let nft: MockTimeNonfungiblePositionManager
+  let tokens: [TestERC20, TestERC20, TestERC20]
+  let poolAddress: string
+  let tickLens: TickLensTest
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    wallets = await (ethers as any).getSigners()
+    loadFixture = waffle.createFixtureLoader(wallets)
+  })
+
+  beforeEach('load fixture', async () => {
+    ;({ factory, tokens, nft } = await loadFixture(nftFixture))
+  })
+
+  describe('#getPopulatedTicksInWord', () => {
+    const fullRangeLiquidity = 1000000
+    async function createPool(tokenAddressA: string, tokenAddressB: string) {
+      if (tokenAddressA.toLowerCase() > tokenAddressB.toLowerCase())
+        [tokenAddressA, tokenAddressB] = [tokenAddressB, tokenAddressA]
+
+      await nft.createAndInitializePoolIfNecessary(
+        tokenAddressA,
+        tokenAddressB,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 1)
+      )
+
+      const liquidityParams = {
+        token0: tokenAddressA,
+        token1: tokenAddressB,
+        fee: FeeAmount.MEDIUM,
+        tickLower: getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]),
+        tickUpper: getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]),
+        recipient: wallets[0].address,
+        amount0Desired: 1000000,
+        amount1Desired: 1000000,
+        amount0Min: 0,
+        amount1Min: 0,
+        deadline: 1,
+      }
+
+      return nft.mint(liquidityParams)
+    }
+
+    async function mint(tickLower: number, tickUpper: number, amountBothDesired: BigNumberish): Promise<number> {
+      const mintParams = {
+        token0: tokens[0].address,
+        token1: tokens[1].address,
+        fee: FeeAmount.MEDIUM,
+        tickLower,
+        tickUpper,
+        amount0Desired: amountBothDesired,
+        amount1Desired: amountBothDesired,
+        amount0Min: 0,
+        amount1Min: 0,
+        recipient: wallets[0].address,
+        deadline: 1,
+      }
+
+      const { liquidity } = await nft.callStatic.mint(mintParams)
+
+      await nft.mint(mintParams)
+      return liquidity.toNumber()
+    }
+
+    beforeEach(async () => {
+      await createPool(tokens[0].address, tokens[1].address)
+      poolAddress = computePoolAddress(factory.address, [tokens[0].address, tokens[1].address], FeeAmount.MEDIUM)
+    })
+
+    beforeEach(async () => {
+      const lensFactory = await ethers.getContractFactory('TickLensTest')
+      tickLens = (await lensFactory.deploy()) as TickLensTest
+    })
+
+    function getTickBitmapIndex(tick: BigNumberish, tickSpacing: number): BigNumber {
+      const intermediate = BigNumber.from(tick).div(tickSpacing)
+      // see https://docs.soliditylang.org/en/v0.7.6/types.html#shifts
+      return intermediate.lt(0) ? intermediate.add(1).div(BigNumber.from(2).pow(8)).sub(1) : intermediate.shr(8)
+    }
+
+    it('works for min/max', async () => {
+      const [min] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]), TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      const [max] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]), TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      expect(min.tick).to.be.eq(getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]))
+      expect(min.liquidityNet).to.be.eq(fullRangeLiquidity)
+      expect(min.liquidityGross).to.be.eq(fullRangeLiquidity)
+
+      expect(max.tick).to.be.eq(getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]))
+      expect(max.liquidityNet).to.be.eq(fullRangeLiquidity * -1)
+      expect(min.liquidityGross).to.be.eq(fullRangeLiquidity)
+    })
+
+    it('works for min/max and -2/-1/0/1', async () => {
+      const minus = -TICK_SPACINGS[FeeAmount.MEDIUM]
+      const plus = -minus
+
+      const liquidity0 = await mint(minus * 2, minus, 2)
+      const liquidity1 = await mint(minus * 2, 0, 3)
+      const liquidity2 = await mint(minus * 2, plus, 5)
+      const liquidity3 = await mint(minus, 0, 7)
+      const liquidity4 = await mint(minus, plus, 11)
+      const liquidity5 = await mint(0, plus, 13)
+
+      const [min] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]), TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      const [negativeOne, negativeTwo] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(minus, TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      const [one, zero] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(plus, TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      const [max] = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]), TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+
+      expect(min.tick).to.be.eq(getMinTick(TICK_SPACINGS[FeeAmount.MEDIUM]))
+      expect(min.liquidityNet).to.be.eq(fullRangeLiquidity)
+      expect(min.liquidityGross).to.be.eq(fullRangeLiquidity)
+
+      expect(negativeTwo.tick).to.be.eq(minus * 2)
+      expect(negativeTwo.liquidityNet).to.be.eq(liquidity0 + liquidity1 + liquidity2)
+      expect(negativeTwo.liquidityGross).to.be.eq(liquidity0 + liquidity1 + liquidity2)
+
+      expect(negativeOne.tick).to.be.eq(minus)
+      expect(negativeOne.liquidityNet).to.be.eq(liquidity3 + liquidity4 - liquidity0)
+      expect(negativeOne.liquidityGross).to.be.eq(liquidity3 + liquidity4 + liquidity0)
+
+      expect(zero.tick).to.be.eq(0)
+      expect(zero.liquidityNet).to.be.eq(liquidity5 - liquidity1 - liquidity3)
+      expect(zero.liquidityGross).to.be.eq(liquidity5 + liquidity1 + liquidity3)
+
+      expect(one.tick).to.be.eq(plus)
+      expect(one.liquidityNet).to.be.eq(-liquidity2 - liquidity4 - liquidity5)
+      expect(one.liquidityGross).to.be.eq(liquidity2 + liquidity4 + liquidity5)
+
+      expect(max.tick).to.be.eq(getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]))
+      expect(max.liquidityNet).to.be.eq(fullRangeLiquidity * -1)
+      expect(max.liquidityGross).to.be.eq(fullRangeLiquidity)
+    })
+
+    it('gas for single populated tick', async () => {
+      await snapshotGasCost(
+        tickLens.getGasCostOfGetPopulatedTicksInWord(
+          poolAddress,
+          getTickBitmapIndex(getMaxTick(TICK_SPACINGS[FeeAmount.MEDIUM]), TICK_SPACINGS[FeeAmount.MEDIUM])
+        )
+      )
+    })
+
+    it('fully populated ticks', async () => {
+      // fully populate a word
+      for (let i = 0; i < 128; i++) {
+        await mint(i * TICK_SPACINGS[FeeAmount.MEDIUM], (255 - i) * TICK_SPACINGS[FeeAmount.MEDIUM], 100)
+      }
+
+      const ticks = await tickLens.getPopulatedTicksInWord(
+        poolAddress,
+        getTickBitmapIndex(0, TICK_SPACINGS[FeeAmount.MEDIUM])
+      )
+      expect(ticks.length).to.be.eq(256)
+
+      await snapshotGasCost(
+        tickLens.getGasCostOfGetPopulatedTicksInWord(
+          poolAddress,
+          getTickBitmapIndex(0, TICK_SPACINGS[FeeAmount.MEDIUM])
+        )
+      )
+    }).timeout(300_000)
+  })
+})

package/lib/v3-periphery-main/test/V3Migrator.spec.ts

@@ -0,0 +1,446 @@
+import { Fixture } from 'ethereum-waffle'
+import { constants, Contract, Wallet } from 'ethers'
+import { ethers, waffle } from 'hardhat'
+import {
+  IUniswapV2Pair,
+  IUniswapV3Factory,
+  IWETH9,
+  MockTimeNonfungiblePositionManager,
+  TestERC20,
+  V3Migrator,
+} from '../typechain'
+import completeFixture from './shared/completeFixture'
+import { v2FactoryFixture } from './shared/externalFixtures'
+
+import { abi as PAIR_V2_ABI } from '@uniswap/v2-core/build/UniswapV2Pair.json'
+import { expect } from 'chai'
+import { FeeAmount } from './shared/constants'
+import { encodePriceSqrt } from './shared/encodePriceSqrt'
+import snapshotGasCost from './shared/snapshotGasCost'
+import { sortedTokens } from './shared/tokenSort'
+import { getMaxTick, getMinTick } from './shared/ticks'
+
+describe('V3Migrator', () => {
+  let wallet: Wallet
+
+  const migratorFixture: Fixture<{
+    factoryV2: Contract
+    factoryV3: IUniswapV3Factory
+    token: TestERC20
+    weth9: IWETH9
+    nft: MockTimeNonfungiblePositionManager
+    migrator: V3Migrator
+  }> = async (wallets, provider) => {
+    const { factory, tokens, nft, weth9 } = await completeFixture(wallets, provider)
+
+    const { factory: factoryV2 } = await v2FactoryFixture(wallets, provider)
+
+    const token = tokens[0]
+    await token.approve(factoryV2.address, constants.MaxUint256)
+    await weth9.deposit({ value: 10000 })
+    await weth9.approve(nft.address, constants.MaxUint256)
+
+    // deploy the migrator
+    const migrator = (await (await ethers.getContractFactory('V3Migrator')).deploy(
+      factory.address,
+      weth9.address,
+      nft.address
+    )) as V3Migrator
+
+    return {
+      factoryV2,
+      factoryV3: factory,
+      token,
+      weth9,
+      nft,
+      migrator,
+    }
+  }
+
+  let factoryV2: Contract
+  let factoryV3: IUniswapV3Factory
+  let token: TestERC20
+  let weth9: IWETH9
+  let nft: MockTimeNonfungiblePositionManager
+  let migrator: V3Migrator
+  let pair: IUniswapV2Pair
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  const expectedLiquidity = 10000 - 1000
+
+  before('create fixture loader', async () => {
+    const wallets = await (ethers as any).getSigners()
+    wallet = wallets[0]
+
+    loadFixture = waffle.createFixtureLoader(wallets)
+  })
+
+  beforeEach('load fixture', async () => {
+    ;({ factoryV2, factoryV3, token, weth9, nft, migrator } = await loadFixture(migratorFixture))
+  })
+
+  beforeEach('add V2 liquidity', async () => {
+    await factoryV2.createPair(token.address, weth9.address)
+
+    const pairAddress = await factoryV2.getPair(token.address, weth9.address)
+
+    pair = new ethers.Contract(pairAddress, PAIR_V2_ABI, wallet) as IUniswapV2Pair
+
+    await token.transfer(pair.address, 10000)
+    await weth9.transfer(pair.address, 10000)
+
+    await pair.mint(wallet.address)
+
+    expect(await pair.balanceOf(wallet.address)).to.be.eq(expectedLiquidity)
+  })
+
+  afterEach('ensure allowances are cleared', async () => {
+    const allowanceToken = await token.allowance(migrator.address, nft.address)
+    const allowanceWETH9 = await weth9.allowance(migrator.address, nft.address)
+    expect(allowanceToken).to.be.eq(0)
+    expect(allowanceWETH9).to.be.eq(0)
+  })
+
+  afterEach('ensure balances are cleared', async () => {
+    const balanceToken = await token.balanceOf(migrator.address)
+    const balanceWETH9 = await weth9.balanceOf(migrator.address)
+    expect(balanceToken).to.be.eq(0)
+    expect(balanceWETH9).to.be.eq(0)
+  })
+
+  afterEach('ensure eth balance is cleared', async () => {
+    const balanceETH = await ethers.provider.getBalance(migrator.address)
+    expect(balanceETH).to.be.eq(0)
+  })
+
+  describe('#migrate', () => {
+    let tokenLower: boolean
+    beforeEach(() => {
+      tokenLower = token.address.toLowerCase() < weth9.address.toLowerCase()
+    })
+
+    it('fails if v3 pool is not initialized', async () => {
+      await pair.approve(migrator.address, expectedLiquidity)
+      await expect(
+        migrator.migrate({
+          pair: pair.address,
+          liquidityToMigrate: expectedLiquidity,
+          percentageToMigrate: 100,
+          token0: tokenLower ? token.address : weth9.address,
+          token1: tokenLower ? weth9.address : token.address,
+          fee: FeeAmount.MEDIUM,
+          tickLower: -1,
+          tickUpper: 1,
+          amount0Min: 9000,
+          amount1Min: 9000,
+          recipient: wallet.address,
+          deadline: 1,
+          refundAsETH: false,
+        })
+      ).to.be.reverted
+    })
+
+    it('works once v3 pool is initialized', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 1)
+      )
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await migrator.migrate({
+        pair: pair.address,
+        liquidityToMigrate: expectedLiquidity,
+        percentageToMigrate: 100,
+        token0: tokenLower ? token.address : weth9.address,
+        token1: tokenLower ? weth9.address : token.address,
+        fee: FeeAmount.MEDIUM,
+        tickLower: getMinTick(FeeAmount.MEDIUM),
+        tickUpper: getMaxTick(FeeAmount.MEDIUM),
+        amount0Min: 9000,
+        amount1Min: 9000,
+        recipient: wallet.address,
+        deadline: 1,
+        refundAsETH: false,
+      })
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(9000)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      expect(await token.balanceOf(poolAddress)).to.be.eq(9000)
+      expect(await weth9.balanceOf(poolAddress)).to.be.eq(9000)
+    })
+
+    it('works for partial', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 1)
+      )
+
+      const tokenBalanceBefore = await token.balanceOf(wallet.address)
+      const weth9BalanceBefore = await weth9.balanceOf(wallet.address)
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await migrator.migrate({
+        pair: pair.address,
+        liquidityToMigrate: expectedLiquidity,
+        percentageToMigrate: 50,
+        token0: tokenLower ? token.address : weth9.address,
+        token1: tokenLower ? weth9.address : token.address,
+        fee: FeeAmount.MEDIUM,
+        tickLower: getMinTick(FeeAmount.MEDIUM),
+        tickUpper: getMaxTick(FeeAmount.MEDIUM),
+        amount0Min: 4500,
+        amount1Min: 4500,
+        recipient: wallet.address,
+        deadline: 1,
+        refundAsETH: false,
+      })
+
+      const tokenBalanceAfter = await token.balanceOf(wallet.address)
+      const weth9BalanceAfter = await weth9.balanceOf(wallet.address)
+
+      expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(4500)
+      expect(weth9BalanceAfter.sub(weth9BalanceBefore)).to.be.eq(4500)
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(4500)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      expect(await token.balanceOf(poolAddress)).to.be.eq(4500)
+      expect(await weth9.balanceOf(poolAddress)).to.be.eq(4500)
+    })
+
+    it('double the price', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(2, 1)
+      )
+
+      const tokenBalanceBefore = await token.balanceOf(wallet.address)
+      const weth9BalanceBefore = await weth9.balanceOf(wallet.address)
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await migrator.migrate({
+        pair: pair.address,
+        liquidityToMigrate: expectedLiquidity,
+        percentageToMigrate: 100,
+        token0: tokenLower ? token.address : weth9.address,
+        token1: tokenLower ? weth9.address : token.address,
+        fee: FeeAmount.MEDIUM,
+        tickLower: getMinTick(FeeAmount.MEDIUM),
+        tickUpper: getMaxTick(FeeAmount.MEDIUM),
+        amount0Min: 4500,
+        amount1Min: 8999,
+        recipient: wallet.address,
+        deadline: 1,
+        refundAsETH: false,
+      })
+
+      const tokenBalanceAfter = await token.balanceOf(wallet.address)
+      const weth9BalanceAfter = await weth9.balanceOf(wallet.address)
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(6363)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      if (token.address.toLowerCase() < weth9.address.toLowerCase()) {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(4500)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(weth9BalanceAfter.sub(weth9BalanceBefore)).to.be.eq(1)
+      } else {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(1)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(weth9BalanceAfter.sub(weth9BalanceBefore)).to.be.eq(4500)
+      }
+    })
+
+    it('half the price', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 2)
+      )
+
+      const tokenBalanceBefore = await token.balanceOf(wallet.address)
+      const weth9BalanceBefore = await weth9.balanceOf(wallet.address)
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await migrator.migrate({
+        pair: pair.address,
+        liquidityToMigrate: expectedLiquidity,
+        percentageToMigrate: 100,
+        token0: tokenLower ? token.address : weth9.address,
+        token1: tokenLower ? weth9.address : token.address,
+        fee: FeeAmount.MEDIUM,
+        tickLower: getMinTick(FeeAmount.MEDIUM),
+        tickUpper: getMaxTick(FeeAmount.MEDIUM),
+        amount0Min: 8999,
+        amount1Min: 4500,
+        recipient: wallet.address,
+        deadline: 1,
+        refundAsETH: false,
+      })
+
+      const tokenBalanceAfter = await token.balanceOf(wallet.address)
+      const weth9BalanceAfter = await weth9.balanceOf(wallet.address)
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(6363)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      if (token.address.toLowerCase() < weth9.address.toLowerCase()) {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(1)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(weth9BalanceAfter.sub(weth9BalanceBefore)).to.be.eq(4500)
+      } else {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(4500)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(weth9BalanceAfter.sub(weth9BalanceBefore)).to.be.eq(1)
+      }
+    })
+
+    it('double the price - as ETH', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(2, 1)
+      )
+
+      const tokenBalanceBefore = await token.balanceOf(wallet.address)
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await expect(
+        migrator.migrate({
+          pair: pair.address,
+          liquidityToMigrate: expectedLiquidity,
+          percentageToMigrate: 100,
+          token0: tokenLower ? token.address : weth9.address,
+          token1: tokenLower ? weth9.address : token.address,
+          fee: FeeAmount.MEDIUM,
+          tickLower: getMinTick(FeeAmount.MEDIUM),
+          tickUpper: getMaxTick(FeeAmount.MEDIUM),
+          amount0Min: 4500,
+          amount1Min: 8999,
+          recipient: wallet.address,
+          deadline: 1,
+          refundAsETH: true,
+        })
+      )
+        .to.emit(weth9, 'Withdrawal')
+        .withArgs(migrator.address, tokenLower ? 1 : 4500)
+
+      const tokenBalanceAfter = await token.balanceOf(wallet.address)
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(6363)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      if (tokenLower) {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(4500)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(8999)
+      } else {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(1)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(4500)
+      }
+    })
+
+    it('half the price - as ETH', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 2)
+      )
+
+      const tokenBalanceBefore = await token.balanceOf(wallet.address)
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await expect(
+        migrator.migrate({
+          pair: pair.address,
+          liquidityToMigrate: expectedLiquidity,
+          percentageToMigrate: 100,
+          token0: tokenLower ? token.address : weth9.address,
+          token1: tokenLower ? weth9.address : token.address,
+          fee: FeeAmount.MEDIUM,
+          tickLower: getMinTick(FeeAmount.MEDIUM),
+          tickUpper: getMaxTick(FeeAmount.MEDIUM),
+          amount0Min: 8999,
+          amount1Min: 4500,
+          recipient: wallet.address,
+          deadline: 1,
+          refundAsETH: true,
+        })
+      )
+        .to.emit(weth9, 'Withdrawal')
+        .withArgs(migrator.address, tokenLower ? 4500 : 1)
+
+      const tokenBalanceAfter = await token.balanceOf(wallet.address)
+
+      const position = await nft.positions(1)
+      expect(position.liquidity).to.be.eq(6363)
+
+      const poolAddress = await factoryV3.getPool(token.address, weth9.address, FeeAmount.MEDIUM)
+      if (tokenLower) {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(8999)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(1)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(4500)
+      } else {
+        expect(await token.balanceOf(poolAddress)).to.be.eq(4500)
+        expect(tokenBalanceAfter.sub(tokenBalanceBefore)).to.be.eq(4500)
+        expect(await weth9.balanceOf(poolAddress)).to.be.eq(8999)
+      }
+    })
+
+    it('gas', async () => {
+      const [token0, token1] = sortedTokens(weth9, token)
+      await migrator.createAndInitializePoolIfNecessary(
+        token0.address,
+        token1.address,
+        FeeAmount.MEDIUM,
+        encodePriceSqrt(1, 1)
+      )
+
+      await pair.approve(migrator.address, expectedLiquidity)
+      await snapshotGasCost(
+        migrator.migrate({
+          pair: pair.address,
+          liquidityToMigrate: expectedLiquidity,
+          percentageToMigrate: 100,
+          token0: tokenLower ? token.address : weth9.address,
+          token1: tokenLower ? weth9.address : token.address,
+          fee: FeeAmount.MEDIUM,
+          tickLower: getMinTick(FeeAmount.MEDIUM),
+          tickUpper: getMaxTick(FeeAmount.MEDIUM),
+          amount0Min: 9000,
+          amount1Min: 9000,
+          recipient: wallet.address,
+          deadline: 1,
+          refundAsETH: false,
+        })
+      )
+    })
+  })
+})

package/lib/v3-periphery-main/test/__snapshots__/Base64.spec.ts.snap

@@ -0,0 +1,32 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Base64 #encode gas cost of encode(<some html>) 1`] = `1497`;
+
+exports[`Base64 #encode gas cost of encode(aLpHaBeT) 1`] = `1256`;
+
+exports[`Base64 #encode gas cost of encode(alphabet soup) 1`] = `1727`;
+
+exports[`Base64 #encode gas cost of encode(f) 1`] = `763`;
+
+exports[`Base64 #encode gas cost of encode(fo) 1`] = `774`;
+
+exports[`Base64 #encode gas cost of encode(foo) 1`] = `769`;
+
+exports[`Base64 #encode gas cost of encode(foob) 1`] = `1004`;
+
+exports[`Base64 #encode gas cost of encode(fooba) 1`] = `1015`;
+
+exports[`Base64 #encode gas cost of encode(foobar) 1`] = `1010`;
+
+exports[`Base64 #encode gas cost of encode(includes
+newlines) 1`] = `1979`;
+
+exports[`Base64 #encode gas cost of encode(test string) 1`] = `1497`;
+
+exports[`Base64 #encode gas cost of encode(this is a test) 1`] = `1738`;
+
+exports[`Base64 #encode gas cost of encode(this is a very long string that should cost a lot of gas to encode :)) 1`] = `6083`;
+
+exports[`Base64 #encode gas cost of encode(😀) 1`] = `1004`;
+
+exports[`Base64 #encode max size string (24kB) gas cost 1`] = `3731900`;