@diwantanushh/rapiddex-contracts 1.0.0

package/lib/v3-core-main/test/UniswapV3Pool.spec.ts

@@ -0,0 +1,2043 @@
+import { ethers, waffle } from 'hardhat'
+import { BigNumber, BigNumberish, constants, Wallet } from 'ethers'
+import { TestERC20 } from '../typechain/TestERC20'
+import { UniswapV3Factory } from '../typechain/UniswapV3Factory'
+import { MockTimeUniswapV3Pool } from '../typechain/MockTimeUniswapV3Pool'
+import { TestUniswapV3SwapPay } from '../typechain/TestUniswapV3SwapPay'
+import checkObservationEquals from './shared/checkObservationEquals'
+import { expect } from './shared/expect'
+
+import { poolFixture, TEST_POOL_START_TIME } from './shared/fixtures'
+
+import {
+  expandTo18Decimals,
+  FeeAmount,
+  getPositionKey,
+  getMaxTick,
+  getMinTick,
+  encodePriceSqrt,
+  TICK_SPACINGS,
+  createPoolFunctions,
+  SwapFunction,
+  MintFunction,
+  getMaxLiquidityPerTick,
+  FlashFunction,
+  MaxUint128,
+  MAX_SQRT_RATIO,
+  MIN_SQRT_RATIO,
+  SwapToPriceFunction,
+} from './shared/utilities'
+import { TestUniswapV3Callee } from '../typechain/TestUniswapV3Callee'
+import { TestUniswapV3ReentrantCallee } from '../typechain/TestUniswapV3ReentrantCallee'
+import { TickMathTest } from '../typechain/TickMathTest'
+import { SwapMathTest } from '../typechain/SwapMathTest'
+
+const createFixtureLoader = waffle.createFixtureLoader
+
+type ThenArg<T> = T extends PromiseLike<infer U> ? U : T
+
+describe('UniswapV3Pool', () => {
+  let wallet: Wallet, other: Wallet
+
+  let token0: TestERC20
+  let token1: TestERC20
+  let token2: TestERC20
+
+  let factory: UniswapV3Factory
+  let pool: MockTimeUniswapV3Pool
+
+  let swapTarget: TestUniswapV3Callee
+
+  let swapToLowerPrice: SwapToPriceFunction
+  let swapToHigherPrice: SwapToPriceFunction
+  let swapExact0For1: SwapFunction
+  let swap0ForExact1: SwapFunction
+  let swapExact1For0: SwapFunction
+  let swap1ForExact0: SwapFunction
+
+  let feeAmount: number
+  let tickSpacing: number
+
+  let minTick: number
+  let maxTick: number
+
+  let mint: MintFunction
+  let flash: FlashFunction
+
+  let loadFixture: ReturnType<typeof createFixtureLoader>
+  let createPool: ThenArg<ReturnType<typeof poolFixture>>['createPool']
+
+  before('create fixture loader', async () => {
+    ;[wallet, other] = await (ethers as any).getSigners()
+    loadFixture = createFixtureLoader([wallet, other])
+  })
+
+  beforeEach('deploy fixture', async () => {
+    ;({ token0, token1, token2, factory, createPool, swapTargetCallee: swapTarget } = await loadFixture(poolFixture))
+
+    const oldCreatePool = createPool
+    createPool = async (_feeAmount, _tickSpacing) => {
+      const pool = await oldCreatePool(_feeAmount, _tickSpacing)
+      ;({
+        swapToLowerPrice,
+        swapToHigherPrice,
+        swapExact0For1,
+        swap0ForExact1,
+        swapExact1For0,
+        swap1ForExact0,
+        mint,
+        flash,
+      } = createPoolFunctions({
+        token0,
+        token1,
+        swapTarget,
+        pool,
+      }))
+      minTick = getMinTick(_tickSpacing)
+      maxTick = getMaxTick(_tickSpacing)
+      feeAmount = _feeAmount
+      tickSpacing = _tickSpacing
+      return pool
+    }
+
+    // default to the 30 bips pool
+    pool = await createPool(FeeAmount.MEDIUM, TICK_SPACINGS[FeeAmount.MEDIUM])
+  })
+
+  it('constructor initializes immutables', async () => {
+    expect(await pool.factory()).to.eq(factory.address)
+    expect(await pool.token0()).to.eq(token0.address)
+    expect(await pool.token1()).to.eq(token1.address)
+    expect(await pool.maxLiquidityPerTick()).to.eq(getMaxLiquidityPerTick(tickSpacing))
+  })
+
+  describe('#initialize', () => {
+    it('fails if already initialized', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await expect(pool.initialize(encodePriceSqrt(1, 1))).to.be.reverted
+    })
+    it('fails if starting price is too low', async () => {
+      await expect(pool.initialize(1)).to.be.revertedWith('R')
+      await expect(pool.initialize(MIN_SQRT_RATIO.sub(1))).to.be.revertedWith('R')
+    })
+    it('fails if starting price is too high', async () => {
+      await expect(pool.initialize(MAX_SQRT_RATIO)).to.be.revertedWith('R')
+      await expect(pool.initialize(BigNumber.from(2).pow(160).sub(1))).to.be.revertedWith('R')
+    })
+    it('can be initialized at MIN_SQRT_RATIO', async () => {
+      await pool.initialize(MIN_SQRT_RATIO)
+      expect((await pool.slot0()).tick).to.eq(getMinTick(1))
+    })
+    it('can be initialized at MAX_SQRT_RATIO - 1', async () => {
+      await pool.initialize(MAX_SQRT_RATIO.sub(1))
+      expect((await pool.slot0()).tick).to.eq(getMaxTick(1) - 1)
+    })
+    it('sets initial variables', async () => {
+      const price = encodePriceSqrt(1, 2)
+      await pool.initialize(price)
+
+      const { sqrtPriceX96, observationIndex } = await pool.slot0()
+      expect(sqrtPriceX96).to.eq(price)
+      expect(observationIndex).to.eq(0)
+      expect((await pool.slot0()).tick).to.eq(-6932)
+    })
+    it('initializes the first observations slot', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      checkObservationEquals(await pool.observations(0), {
+        secondsPerLiquidityCumulativeX128: 0,
+        initialized: true,
+        blockTimestamp: TEST_POOL_START_TIME,
+        tickCumulative: 0,
+      })
+    })
+    it('emits a Initialized event with the input tick', async () => {
+      const sqrtPriceX96 = encodePriceSqrt(1, 2)
+      await expect(pool.initialize(sqrtPriceX96)).to.emit(pool, 'Initialize').withArgs(sqrtPriceX96, -6932)
+    })
+  })
+
+  describe('#increaseObservationCardinalityNext', () => {
+    it('can only be called after initialize', async () => {
+      await expect(pool.increaseObservationCardinalityNext(2)).to.be.revertedWith('LOK')
+    })
+    it('emits an event including both old and new', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await expect(pool.increaseObservationCardinalityNext(2))
+        .to.emit(pool, 'IncreaseObservationCardinalityNext')
+        .withArgs(1, 2)
+    })
+    it('does not emit an event for no op call', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await pool.increaseObservationCardinalityNext(3)
+      await expect(pool.increaseObservationCardinalityNext(2)).to.not.emit(pool, 'IncreaseObservationCardinalityNext')
+    })
+    it('does not change cardinality next if less than current', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await pool.increaseObservationCardinalityNext(3)
+      await pool.increaseObservationCardinalityNext(2)
+      expect((await pool.slot0()).observationCardinalityNext).to.eq(3)
+    })
+    it('increases cardinality and cardinality next first time', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await pool.increaseObservationCardinalityNext(2)
+      const { observationCardinality, observationCardinalityNext } = await pool.slot0()
+      expect(observationCardinality).to.eq(1)
+      expect(observationCardinalityNext).to.eq(2)
+    })
+  })
+
+  describe('#mint', () => {
+    it('fails if not initialized', async () => {
+      await expect(mint(wallet.address, -tickSpacing, tickSpacing, 1)).to.be.revertedWith('LOK')
+    })
+    describe('after initialization', () => {
+      beforeEach('initialize the pool at price of 10:1', async () => {
+        await pool.initialize(encodePriceSqrt(1, 10))
+        await mint(wallet.address, minTick, maxTick, 3161)
+      })
+
+      describe('failure cases', () => {
+        it('fails if tickLower greater than tickUpper', async () => {
+          // should be TLU but...hardhat
+          await expect(mint(wallet.address, 1, 0, 1)).to.be.reverted
+        })
+        it('fails if tickLower less than min tick', async () => {
+          // should be TLM but...hardhat
+          await expect(mint(wallet.address, -887273, 0, 1)).to.be.reverted
+        })
+        it('fails if tickUpper greater than max tick', async () => {
+          // should be TUM but...hardhat
+          await expect(mint(wallet.address, 0, 887273, 1)).to.be.reverted
+        })
+        it('fails if amount exceeds the max', async () => {
+          // these should fail with 'LO' but hardhat is bugged
+          const maxLiquidityGross = await pool.maxLiquidityPerTick()
+          await expect(mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, maxLiquidityGross.add(1))).to
+            .be.reverted
+          await expect(mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, maxLiquidityGross)).to.not.be
+            .reverted
+        })
+        it('fails if total amount at tick exceeds the max', async () => {
+          // these should fail with 'LO' but hardhat is bugged
+          await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 1000)
+
+          const maxLiquidityGross = await pool.maxLiquidityPerTick()
+          await expect(
+            mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, maxLiquidityGross.sub(1000).add(1))
+          ).to.be.reverted
+          await expect(
+            mint(wallet.address, minTick + tickSpacing * 2, maxTick - tickSpacing, maxLiquidityGross.sub(1000).add(1))
+          ).to.be.reverted
+          await expect(
+            mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing * 2, maxLiquidityGross.sub(1000).add(1))
+          ).to.be.reverted
+          await expect(mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, maxLiquidityGross.sub(1000)))
+            .to.not.be.reverted
+        })
+        it('fails if amount is 0', async () => {
+          await expect(mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 0)).to.be.reverted
+        })
+      })
+
+      describe('success cases', () => {
+        it('initial balances', async () => {
+          expect(await token0.balanceOf(pool.address)).to.eq(9996)
+          expect(await token1.balanceOf(pool.address)).to.eq(1000)
+        })
+
+        it('initial tick', async () => {
+          expect((await pool.slot0()).tick).to.eq(-23028)
+        })
+
+        describe('above current price', () => {
+          it('transfers token0 only', async () => {
+            await expect(mint(wallet.address, -22980, 0, 10000))
+              .to.emit(token0, 'Transfer')
+              .withArgs(wallet.address, pool.address, 21549)
+              .to.not.emit(token1, 'Transfer')
+            expect(await token0.balanceOf(pool.address)).to.eq(9996 + 21549)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000)
+          })
+
+          it('max tick with max leverage', async () => {
+            await mint(wallet.address, maxTick - tickSpacing, maxTick, BigNumber.from(2).pow(102))
+            expect(await token0.balanceOf(pool.address)).to.eq(9996 + 828011525)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000)
+          })
+
+          it('works for max tick', async () => {
+            await expect(mint(wallet.address, -22980, maxTick, 10000))
+              .to.emit(token0, 'Transfer')
+              .withArgs(wallet.address, pool.address, 31549)
+            expect(await token0.balanceOf(pool.address)).to.eq(9996 + 31549)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000)
+          })
+
+          it('removing works', async () => {
+            await mint(wallet.address, -240, 0, 10000)
+            await pool.burn(-240, 0, 10000)
+            const { amount0, amount1 } = await pool.callStatic.collect(wallet.address, -240, 0, MaxUint128, MaxUint128)
+            expect(amount0, 'amount0').to.eq(120)
+            expect(amount1, 'amount1').to.eq(0)
+          })
+
+          it('adds liquidity to liquidityGross', async () => {
+            await mint(wallet.address, -240, 0, 100)
+            expect((await pool.ticks(-240)).liquidityGross).to.eq(100)
+            expect((await pool.ticks(0)).liquidityGross).to.eq(100)
+            expect((await pool.ticks(tickSpacing)).liquidityGross).to.eq(0)
+            expect((await pool.ticks(tickSpacing * 2)).liquidityGross).to.eq(0)
+            await mint(wallet.address, -240, tickSpacing, 150)
+            expect((await pool.ticks(-240)).liquidityGross).to.eq(250)
+            expect((await pool.ticks(0)).liquidityGross).to.eq(100)
+            expect((await pool.ticks(tickSpacing)).liquidityGross).to.eq(150)
+            expect((await pool.ticks(tickSpacing * 2)).liquidityGross).to.eq(0)
+            await mint(wallet.address, 0, tickSpacing * 2, 60)
+            expect((await pool.ticks(-240)).liquidityGross).to.eq(250)
+            expect((await pool.ticks(0)).liquidityGross).to.eq(160)
+            expect((await pool.ticks(tickSpacing)).liquidityGross).to.eq(150)
+            expect((await pool.ticks(tickSpacing * 2)).liquidityGross).to.eq(60)
+          })
+
+          it('removes liquidity from liquidityGross', async () => {
+            await mint(wallet.address, -240, 0, 100)
+            await mint(wallet.address, -240, 0, 40)
+            await pool.burn(-240, 0, 90)
+            expect((await pool.ticks(-240)).liquidityGross).to.eq(50)
+            expect((await pool.ticks(0)).liquidityGross).to.eq(50)
+          })
+
+          it('clears tick lower if last position is removed', async () => {
+            await mint(wallet.address, -240, 0, 100)
+            await pool.burn(-240, 0, 100)
+            const { liquidityGross, feeGrowthOutside0X128, feeGrowthOutside1X128 } = await pool.ticks(-240)
+            expect(liquidityGross).to.eq(0)
+            expect(feeGrowthOutside0X128).to.eq(0)
+            expect(feeGrowthOutside1X128).to.eq(0)
+          })
+
+          it('clears tick upper if last position is removed', async () => {
+            await mint(wallet.address, -240, 0, 100)
+            await pool.burn(-240, 0, 100)
+            const { liquidityGross, feeGrowthOutside0X128, feeGrowthOutside1X128 } = await pool.ticks(0)
+            expect(liquidityGross).to.eq(0)
+            expect(feeGrowthOutside0X128).to.eq(0)
+            expect(feeGrowthOutside1X128).to.eq(0)
+          })
+          it('only clears the tick that is not used at all', async () => {
+            await mint(wallet.address, -240, 0, 100)
+            await mint(wallet.address, -tickSpacing, 0, 250)
+            await pool.burn(-240, 0, 100)
+
+            let { liquidityGross, feeGrowthOutside0X128, feeGrowthOutside1X128 } = await pool.ticks(-240)
+            expect(liquidityGross).to.eq(0)
+            expect(feeGrowthOutside0X128).to.eq(0)
+            expect(feeGrowthOutside1X128).to.eq(0)
+            ;({ liquidityGross, feeGrowthOutside0X128, feeGrowthOutside1X128 } = await pool.ticks(-tickSpacing))
+            expect(liquidityGross).to.eq(250)
+            expect(feeGrowthOutside0X128).to.eq(0)
+            expect(feeGrowthOutside1X128).to.eq(0)
+          })
+
+          it('does not write an observation', async () => {
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: 0,
+              blockTimestamp: TEST_POOL_START_TIME,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: 0,
+            })
+            await pool.advanceTime(1)
+            await mint(wallet.address, -240, 0, 100)
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: 0,
+              blockTimestamp: TEST_POOL_START_TIME,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: 0,
+            })
+          })
+        })
+
+        describe('including current price', () => {
+          it('price within range: transfers current price of both tokens', async () => {
+            await expect(mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 100))
+              .to.emit(token0, 'Transfer')
+              .withArgs(wallet.address, pool.address, 317)
+              .to.emit(token1, 'Transfer')
+              .withArgs(wallet.address, pool.address, 32)
+            expect(await token0.balanceOf(pool.address)).to.eq(9996 + 317)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000 + 32)
+          })
+
+          it('initializes lower tick', async () => {
+            await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 100)
+            const { liquidityGross } = await pool.ticks(minTick + tickSpacing)
+            expect(liquidityGross).to.eq(100)
+          })
+
+          it('initializes upper tick', async () => {
+            await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 100)
+            const { liquidityGross } = await pool.ticks(maxTick - tickSpacing)
+            expect(liquidityGross).to.eq(100)
+          })
+
+          it('works for min/max tick', async () => {
+            await expect(mint(wallet.address, minTick, maxTick, 10000))
+              .to.emit(token0, 'Transfer')
+              .withArgs(wallet.address, pool.address, 31623)
+              .to.emit(token1, 'Transfer')
+              .withArgs(wallet.address, pool.address, 3163)
+            expect(await token0.balanceOf(pool.address)).to.eq(9996 + 31623)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000 + 3163)
+          })
+
+          it('removing works', async () => {
+            await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 100)
+            await pool.burn(minTick + tickSpacing, maxTick - tickSpacing, 100)
+            const { amount0, amount1 } = await pool.callStatic.collect(
+              wallet.address,
+              minTick + tickSpacing,
+              maxTick - tickSpacing,
+              MaxUint128,
+              MaxUint128
+            )
+            expect(amount0, 'amount0').to.eq(316)
+            expect(amount1, 'amount1').to.eq(31)
+          })
+
+          it('writes an observation', async () => {
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: 0,
+              blockTimestamp: TEST_POOL_START_TIME,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: 0,
+            })
+            await pool.advanceTime(1)
+            await mint(wallet.address, minTick, maxTick, 100)
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: -23028,
+              blockTimestamp: TEST_POOL_START_TIME + 1,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: '107650226801941937191829992860413859',
+            })
+          })
+        })
+
+        describe('below current price', () => {
+          it('transfers token1 only', async () => {
+            await expect(mint(wallet.address, -46080, -23040, 10000))
+              .to.emit(token1, 'Transfer')
+              .withArgs(wallet.address, pool.address, 2162)
+              .to.not.emit(token0, 'Transfer')
+            expect(await token0.balanceOf(pool.address)).to.eq(9996)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000 + 2162)
+          })
+
+          it('min tick with max leverage', async () => {
+            await mint(wallet.address, minTick, minTick + tickSpacing, BigNumber.from(2).pow(102))
+            expect(await token0.balanceOf(pool.address)).to.eq(9996)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000 + 828011520)
+          })
+
+          it('works for min tick', async () => {
+            await expect(mint(wallet.address, minTick, -23040, 10000))
+              .to.emit(token1, 'Transfer')
+              .withArgs(wallet.address, pool.address, 3161)
+            expect(await token0.balanceOf(pool.address)).to.eq(9996)
+            expect(await token1.balanceOf(pool.address)).to.eq(1000 + 3161)
+          })
+
+          it('removing works', async () => {
+            await mint(wallet.address, -46080, -46020, 10000)
+            await pool.burn(-46080, -46020, 10000)
+            const { amount0, amount1 } = await pool.callStatic.collect(
+              wallet.address,
+              -46080,
+              -46020,
+              MaxUint128,
+              MaxUint128
+            )
+            expect(amount0, 'amount0').to.eq(0)
+            expect(amount1, 'amount1').to.eq(3)
+          })
+
+          it('does not write an observation', async () => {
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: 0,
+              blockTimestamp: TEST_POOL_START_TIME,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: 0,
+            })
+            await pool.advanceTime(1)
+            await mint(wallet.address, -46080, -23040, 100)
+            checkObservationEquals(await pool.observations(0), {
+              tickCumulative: 0,
+              blockTimestamp: TEST_POOL_START_TIME,
+              initialized: true,
+              secondsPerLiquidityCumulativeX128: 0,
+            })
+          })
+        })
+      })
+
+      it('protocol fees accumulate as expected during swap', async () => {
+        await pool.setFeeProtocol(6, 6)
+
+        await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, expandTo18Decimals(1))
+        await swapExact0For1(expandTo18Decimals(1).div(10), wallet.address)
+        await swapExact1For0(expandTo18Decimals(1).div(100), wallet.address)
+
+        let { token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees()
+        expect(token0ProtocolFees).to.eq('50000000000000')
+        expect(token1ProtocolFees).to.eq('5000000000000')
+      })
+
+      it('positions are protected before protocol fee is turned on', async () => {
+        await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, expandTo18Decimals(1))
+        await swapExact0For1(expandTo18Decimals(1).div(10), wallet.address)
+        await swapExact1For0(expandTo18Decimals(1).div(100), wallet.address)
+
+        let { token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees()
+        expect(token0ProtocolFees).to.eq(0)
+        expect(token1ProtocolFees).to.eq(0)
+
+        await pool.setFeeProtocol(6, 6)
+        ;({ token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees())
+        expect(token0ProtocolFees).to.eq(0)
+        expect(token1ProtocolFees).to.eq(0)
+      })
+
+      it('poke is not allowed on uninitialized position', async () => {
+        await mint(other.address, minTick + tickSpacing, maxTick - tickSpacing, expandTo18Decimals(1))
+        await swapExact0For1(expandTo18Decimals(1).div(10), wallet.address)
+        await swapExact1For0(expandTo18Decimals(1).div(100), wallet.address)
+
+        // missing revert reason due to hardhat
+        await expect(pool.burn(minTick + tickSpacing, maxTick - tickSpacing, 0)).to.be.reverted
+
+        await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, 1)
+        let {
+          liquidity,
+          feeGrowthInside0LastX128,
+          feeGrowthInside1LastX128,
+          tokensOwed1,
+          tokensOwed0,
+        } = await pool.positions(getPositionKey(wallet.address, minTick + tickSpacing, maxTick - tickSpacing))
+        expect(liquidity).to.eq(1)
+        expect(feeGrowthInside0LastX128).to.eq('102084710076281216349243831104605583')
+        expect(feeGrowthInside1LastX128).to.eq('10208471007628121634924383110460558')
+        expect(tokensOwed0, 'tokens owed 0 before').to.eq(0)
+        expect(tokensOwed1, 'tokens owed 1 before').to.eq(0)
+
+        await pool.burn(minTick + tickSpacing, maxTick - tickSpacing, 1)
+        ;({
+          liquidity,
+          feeGrowthInside0LastX128,
+          feeGrowthInside1LastX128,
+          tokensOwed1,
+          tokensOwed0,
+        } = await pool.positions(getPositionKey(wallet.address, minTick + tickSpacing, maxTick - tickSpacing)))
+        expect(liquidity).to.eq(0)
+        expect(feeGrowthInside0LastX128).to.eq('102084710076281216349243831104605583')
+        expect(feeGrowthInside1LastX128).to.eq('10208471007628121634924383110460558')
+        expect(tokensOwed0, 'tokens owed 0 after').to.eq(3)
+        expect(tokensOwed1, 'tokens owed 1 after').to.eq(0)
+      })
+    })
+  })
+
+  describe('#burn', () => {
+    beforeEach('initialize at zero tick', () => initializeAtZeroTick(pool))
+
+    async function checkTickIsClear(tick: number) {
+      const { liquidityGross, feeGrowthOutside0X128, feeGrowthOutside1X128, liquidityNet } = await pool.ticks(tick)
+      expect(liquidityGross).to.eq(0)
+      expect(feeGrowthOutside0X128).to.eq(0)
+      expect(feeGrowthOutside1X128).to.eq(0)
+      expect(liquidityNet).to.eq(0)
+    }
+
+    async function checkTickIsNotClear(tick: number) {
+      const { liquidityGross } = await pool.ticks(tick)
+      expect(liquidityGross).to.not.eq(0)
+    }
+
+    it('does not clear the position fee growth snapshot if no more liquidity', async () => {
+      // some activity that would make the ticks non-zero
+      await pool.advanceTime(10)
+      await mint(other.address, minTick, maxTick, expandTo18Decimals(1))
+      await swapExact0For1(expandTo18Decimals(1), wallet.address)
+      await swapExact1For0(expandTo18Decimals(1), wallet.address)
+      await pool.connect(other).burn(minTick, maxTick, expandTo18Decimals(1))
+      const {
+        liquidity,
+        tokensOwed0,
+        tokensOwed1,
+        feeGrowthInside0LastX128,
+        feeGrowthInside1LastX128,
+      } = await pool.positions(getPositionKey(other.address, minTick, maxTick))
+      expect(liquidity).to.eq(0)
+      expect(tokensOwed0).to.not.eq(0)
+      expect(tokensOwed1).to.not.eq(0)
+      expect(feeGrowthInside0LastX128).to.eq('340282366920938463463374607431768211')
+      expect(feeGrowthInside1LastX128).to.eq('340282366920938576890830247744589365')
+    })
+
+    it('clears the tick if its the last position using it', async () => {
+      const tickLower = minTick + tickSpacing
+      const tickUpper = maxTick - tickSpacing
+      // some activity that would make the ticks non-zero
+      await pool.advanceTime(10)
+      await mint(wallet.address, tickLower, tickUpper, 1)
+      await swapExact0For1(expandTo18Decimals(1), wallet.address)
+      await pool.burn(tickLower, tickUpper, 1)
+      await checkTickIsClear(tickLower)
+      await checkTickIsClear(tickUpper)
+    })
+
+    it('clears only the lower tick if upper is still used', async () => {
+      const tickLower = minTick + tickSpacing
+      const tickUpper = maxTick - tickSpacing
+      // some activity that would make the ticks non-zero
+      await pool.advanceTime(10)
+      await mint(wallet.address, tickLower, tickUpper, 1)
+      await mint(wallet.address, tickLower + tickSpacing, tickUpper, 1)
+      await swapExact0For1(expandTo18Decimals(1), wallet.address)
+      await pool.burn(tickLower, tickUpper, 1)
+      await checkTickIsClear(tickLower)
+      await checkTickIsNotClear(tickUpper)
+    })
+
+    it('clears only the upper tick if lower is still used', async () => {
+      const tickLower = minTick + tickSpacing
+      const tickUpper = maxTick - tickSpacing
+      // some activity that would make the ticks non-zero
+      await pool.advanceTime(10)
+      await mint(wallet.address, tickLower, tickUpper, 1)
+      await mint(wallet.address, tickLower, tickUpper - tickSpacing, 1)
+      await swapExact0For1(expandTo18Decimals(1), wallet.address)
+      await pool.burn(tickLower, tickUpper, 1)
+      await checkTickIsNotClear(tickLower)
+      await checkTickIsClear(tickUpper)
+    })
+  })
+
+  // the combined amount of liquidity that the pool is initialized with (including the 1 minimum liquidity that is burned)
+  const initializeLiquidityAmount = expandTo18Decimals(2)
+  async function initializeAtZeroTick(pool: MockTimeUniswapV3Pool): Promise<void> {
+    await pool.initialize(encodePriceSqrt(1, 1))
+    const tickSpacing = await pool.tickSpacing()
+    const [min, max] = [getMinTick(tickSpacing), getMaxTick(tickSpacing)]
+    await mint(wallet.address, min, max, initializeLiquidityAmount)
+  }
+
+  describe('#observe', () => {
+    beforeEach(() => initializeAtZeroTick(pool))
+
+    // zero tick
+    it('current tick accumulator increases by tick over time', async () => {
+      let {
+        tickCumulatives: [tickCumulative],
+      } = await pool.observe([0])
+      expect(tickCumulative).to.eq(0)
+      await pool.advanceTime(10)
+      ;({
+        tickCumulatives: [tickCumulative],
+      } = await pool.observe([0]))
+      expect(tickCumulative).to.eq(0)
+    })
+
+    it('current tick accumulator after single swap', async () => {
+      // moves to tick -1
+      await swapExact0For1(1000, wallet.address)
+      await pool.advanceTime(4)
+      let {
+        tickCumulatives: [tickCumulative],
+      } = await pool.observe([0])
+      expect(tickCumulative).to.eq(-4)
+    })
+
+    it('current tick accumulator after two swaps', async () => {
+      await swapExact0For1(expandTo18Decimals(1).div(2), wallet.address)
+      expect((await pool.slot0()).tick).to.eq(-4452)
+      await pool.advanceTime(4)
+      await swapExact1For0(expandTo18Decimals(1).div(4), wallet.address)
+      expect((await pool.slot0()).tick).to.eq(-1558)
+      await pool.advanceTime(6)
+      let {
+        tickCumulatives: [tickCumulative],
+      } = await pool.observe([0])
+      // -4452*4 + -1558*6
+      expect(tickCumulative).to.eq(-27156)
+    })
+  })
+
+  describe('miscellaneous mint tests', () => {
+    beforeEach('initialize at zero tick', async () => {
+      pool = await createPool(FeeAmount.LOW, TICK_SPACINGS[FeeAmount.LOW])
+      await initializeAtZeroTick(pool)
+    })
+
+    it('mint to the right of the current price', async () => {
+      const liquidityDelta = 1000
+      const lowerTick = tickSpacing
+      const upperTick = tickSpacing * 2
+
+      const liquidityBefore = await pool.liquidity()
+
+      const b0 = await token0.balanceOf(pool.address)
+      const b1 = await token1.balanceOf(pool.address)
+
+      await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+      const liquidityAfter = await pool.liquidity()
+      expect(liquidityAfter).to.be.gte(liquidityBefore)
+
+      expect((await token0.balanceOf(pool.address)).sub(b0)).to.eq(1)
+      expect((await token1.balanceOf(pool.address)).sub(b1)).to.eq(0)
+    })
+
+    it('mint to the left of the current price', async () => {
+      const liquidityDelta = 1000
+      const lowerTick = -tickSpacing * 2
+      const upperTick = -tickSpacing
+
+      const liquidityBefore = await pool.liquidity()
+
+      const b0 = await token0.balanceOf(pool.address)
+      const b1 = await token1.balanceOf(pool.address)
+
+      await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+      const liquidityAfter = await pool.liquidity()
+      expect(liquidityAfter).to.be.gte(liquidityBefore)
+
+      expect((await token0.balanceOf(pool.address)).sub(b0)).to.eq(0)
+      expect((await token1.balanceOf(pool.address)).sub(b1)).to.eq(1)
+    })
+
+    it('mint within the current price', async () => {
+      const liquidityDelta = 1000
+      const lowerTick = -tickSpacing
+      const upperTick = tickSpacing
+
+      const liquidityBefore = await pool.liquidity()
+
+      const b0 = await token0.balanceOf(pool.address)
+      const b1 = await token1.balanceOf(pool.address)
+
+      await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+      const liquidityAfter = await pool.liquidity()
+      expect(liquidityAfter).to.be.gte(liquidityBefore)
+
+      expect((await token0.balanceOf(pool.address)).sub(b0)).to.eq(1)
+      expect((await token1.balanceOf(pool.address)).sub(b1)).to.eq(1)
+    })
+
+    it('cannot remove more than the entire position', async () => {
+      const lowerTick = -tickSpacing
+      const upperTick = tickSpacing
+      await mint(wallet.address, lowerTick, upperTick, expandTo18Decimals(1000))
+      // should be 'LS', hardhat is bugged
+      await expect(pool.burn(lowerTick, upperTick, expandTo18Decimals(1001))).to.be.reverted
+    })
+
+    it('collect fees within the current price after swap', async () => {
+      const liquidityDelta = expandTo18Decimals(100)
+      const lowerTick = -tickSpacing * 100
+      const upperTick = tickSpacing * 100
+
+      await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+      const liquidityBefore = await pool.liquidity()
+
+      const amount0In = expandTo18Decimals(1)
+      await swapExact0For1(amount0In, wallet.address)
+
+      const liquidityAfter = await pool.liquidity()
+      expect(liquidityAfter, 'k increases').to.be.gte(liquidityBefore)
+
+      const token0BalanceBeforePool = await token0.balanceOf(pool.address)
+      const token1BalanceBeforePool = await token1.balanceOf(pool.address)
+      const token0BalanceBeforeWallet = await token0.balanceOf(wallet.address)
+      const token1BalanceBeforeWallet = await token1.balanceOf(wallet.address)
+
+      await pool.burn(lowerTick, upperTick, 0)
+      await pool.collect(wallet.address, lowerTick, upperTick, MaxUint128, MaxUint128)
+
+      await pool.burn(lowerTick, upperTick, 0)
+      const { amount0: fees0, amount1: fees1 } = await pool.callStatic.collect(
+        wallet.address,
+        lowerTick,
+        upperTick,
+        MaxUint128,
+        MaxUint128
+      )
+      expect(fees0).to.be.eq(0)
+      expect(fees1).to.be.eq(0)
+
+      const token0BalanceAfterWallet = await token0.balanceOf(wallet.address)
+      const token1BalanceAfterWallet = await token1.balanceOf(wallet.address)
+      const token0BalanceAfterPool = await token0.balanceOf(pool.address)
+      const token1BalanceAfterPool = await token1.balanceOf(pool.address)
+
+      expect(token0BalanceAfterWallet).to.be.gt(token0BalanceBeforeWallet)
+      expect(token1BalanceAfterWallet).to.be.eq(token1BalanceBeforeWallet)
+
+      expect(token0BalanceAfterPool).to.be.lt(token0BalanceBeforePool)
+      expect(token1BalanceAfterPool).to.be.eq(token1BalanceBeforePool)
+    })
+  })
+
+  describe('post-initialize at medium fee', () => {
+    describe('k (implicit)', () => {
+      it('returns 0 before initialization', async () => {
+        expect(await pool.liquidity()).to.eq(0)
+      })
+      describe('post initialized', () => {
+        beforeEach(() => initializeAtZeroTick(pool))
+
+        it('returns initial liquidity', async () => {
+          expect(await pool.liquidity()).to.eq(expandTo18Decimals(2))
+        })
+        it('returns in supply in range', async () => {
+          await mint(wallet.address, -tickSpacing, tickSpacing, expandTo18Decimals(3))
+          expect(await pool.liquidity()).to.eq(expandTo18Decimals(5))
+        })
+        it('excludes supply at tick above current tick', async () => {
+          await mint(wallet.address, tickSpacing, tickSpacing * 2, expandTo18Decimals(3))
+          expect(await pool.liquidity()).to.eq(expandTo18Decimals(2))
+        })
+        it('excludes supply at tick below current tick', async () => {
+          await mint(wallet.address, -tickSpacing * 2, -tickSpacing, expandTo18Decimals(3))
+          expect(await pool.liquidity()).to.eq(expandTo18Decimals(2))
+        })
+        it('updates correctly when exiting range', async () => {
+          const kBefore = await pool.liquidity()
+          expect(kBefore).to.be.eq(expandTo18Decimals(2))
+
+          // add liquidity at and above current tick
+          const liquidityDelta = expandTo18Decimals(1)
+          const lowerTick = 0
+          const upperTick = tickSpacing
+          await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+          // ensure virtual supply has increased appropriately
+          const kAfter = await pool.liquidity()
+          expect(kAfter).to.be.eq(expandTo18Decimals(3))
+
+          // swap toward the left (just enough for the tick transition function to trigger)
+          await swapExact0For1(1, wallet.address)
+          const { tick } = await pool.slot0()
+          expect(tick).to.be.eq(-1)
+
+          const kAfterSwap = await pool.liquidity()
+          expect(kAfterSwap).to.be.eq(expandTo18Decimals(2))
+        })
+        it('updates correctly when entering range', async () => {
+          const kBefore = await pool.liquidity()
+          expect(kBefore).to.be.eq(expandTo18Decimals(2))
+
+          // add liquidity below the current tick
+          const liquidityDelta = expandTo18Decimals(1)
+          const lowerTick = -tickSpacing
+          const upperTick = 0
+          await mint(wallet.address, lowerTick, upperTick, liquidityDelta)
+
+          // ensure virtual supply hasn't changed
+          const kAfter = await pool.liquidity()
+          expect(kAfter).to.be.eq(kBefore)
+
+          // swap toward the left (just enough for the tick transition function to trigger)
+          await swapExact0For1(1, wallet.address)
+          const { tick } = await pool.slot0()
+          expect(tick).to.be.eq(-1)
+
+          const kAfterSwap = await pool.liquidity()
+          expect(kAfterSwap).to.be.eq(expandTo18Decimals(3))
+        })
+      })
+    })
+  })
+
+  describe('limit orders', () => {
+    beforeEach('initialize at tick 0', () => initializeAtZeroTick(pool))
+
+    it('limit selling 0 for 1 at tick 0 thru 1', async () => {
+      await expect(mint(wallet.address, 0, 120, expandTo18Decimals(1)))
+        .to.emit(token0, 'Transfer')
+        .withArgs(wallet.address, pool.address, '5981737760509663')
+      // somebody takes the limit order
+      await swapExact1For0(expandTo18Decimals(2), other.address)
+      await expect(pool.burn(0, 120, expandTo18Decimals(1)))
+        .to.emit(pool, 'Burn')
+        .withArgs(wallet.address, 0, 120, expandTo18Decimals(1), 0, '6017734268818165')
+        .to.not.emit(token0, 'Transfer')
+        .to.not.emit(token1, 'Transfer')
+      await expect(pool.collect(wallet.address, 0, 120, MaxUint128, MaxUint128))
+        .to.emit(token1, 'Transfer')
+        .withArgs(pool.address, wallet.address, BigNumber.from('6017734268818165').add('18107525382602')) // roughly 0.3% despite other liquidity
+        .to.not.emit(token0, 'Transfer')
+      expect((await pool.slot0()).tick).to.be.gte(120)
+    })
+    it('limit selling 1 for 0 at tick 0 thru -1', async () => {
+      await expect(mint(wallet.address, -120, 0, expandTo18Decimals(1)))
+        .to.emit(token1, 'Transfer')
+        .withArgs(wallet.address, pool.address, '5981737760509663')
+      // somebody takes the limit order
+      await swapExact0For1(expandTo18Decimals(2), other.address)
+      await expect(pool.burn(-120, 0, expandTo18Decimals(1)))
+        .to.emit(pool, 'Burn')
+        .withArgs(wallet.address, -120, 0, expandTo18Decimals(1), '6017734268818165', 0)
+        .to.not.emit(token0, 'Transfer')
+        .to.not.emit(token1, 'Transfer')
+      await expect(pool.collect(wallet.address, -120, 0, MaxUint128, MaxUint128))
+        .to.emit(token0, 'Transfer')
+        .withArgs(pool.address, wallet.address, BigNumber.from('6017734268818165').add('18107525382602')) // roughly 0.3% despite other liquidity
+      expect((await pool.slot0()).tick).to.be.lt(-120)
+    })
+
+    describe('fee is on', () => {
+      beforeEach(() => pool.setFeeProtocol(6, 6))
+      it('limit selling 0 for 1 at tick 0 thru 1', async () => {
+        await expect(mint(wallet.address, 0, 120, expandTo18Decimals(1)))
+          .to.emit(token0, 'Transfer')
+          .withArgs(wallet.address, pool.address, '5981737760509663')
+        // somebody takes the limit order
+        await swapExact1For0(expandTo18Decimals(2), other.address)
+        await expect(pool.burn(0, 120, expandTo18Decimals(1)))
+          .to.emit(pool, 'Burn')
+          .withArgs(wallet.address, 0, 120, expandTo18Decimals(1), 0, '6017734268818165')
+          .to.not.emit(token0, 'Transfer')
+          .to.not.emit(token1, 'Transfer')
+        await expect(pool.collect(wallet.address, 0, 120, MaxUint128, MaxUint128))
+          .to.emit(token1, 'Transfer')
+          .withArgs(pool.address, wallet.address, BigNumber.from('6017734268818165').add('15089604485501')) // roughly 0.25% despite other liquidity
+          .to.not.emit(token0, 'Transfer')
+        expect((await pool.slot0()).tick).to.be.gte(120)
+      })
+      it('limit selling 1 for 0 at tick 0 thru -1', async () => {
+        await expect(mint(wallet.address, -120, 0, expandTo18Decimals(1)))
+          .to.emit(token1, 'Transfer')
+          .withArgs(wallet.address, pool.address, '5981737760509663')
+        // somebody takes the limit order
+        await swapExact0For1(expandTo18Decimals(2), other.address)
+        await expect(pool.burn(-120, 0, expandTo18Decimals(1)))
+          .to.emit(pool, 'Burn')
+          .withArgs(wallet.address, -120, 0, expandTo18Decimals(1), '6017734268818165', 0)
+          .to.not.emit(token0, 'Transfer')
+          .to.not.emit(token1, 'Transfer')
+        await expect(pool.collect(wallet.address, -120, 0, MaxUint128, MaxUint128))
+          .to.emit(token0, 'Transfer')
+          .withArgs(pool.address, wallet.address, BigNumber.from('6017734268818165').add('15089604485501')) // roughly 0.25% despite other liquidity
+        expect((await pool.slot0()).tick).to.be.lt(-120)
+      })
+    })
+  })
+
+  describe('#collect', () => {
+    beforeEach(async () => {
+      pool = await createPool(FeeAmount.LOW, TICK_SPACINGS[FeeAmount.LOW])
+      await pool.initialize(encodePriceSqrt(1, 1))
+    })
+
+    it('works with multiple LPs', async () => {
+      await mint(wallet.address, minTick, maxTick, expandTo18Decimals(1))
+      await mint(wallet.address, minTick + tickSpacing, maxTick - tickSpacing, expandTo18Decimals(2))
+
+      await swapExact0For1(expandTo18Decimals(1), wallet.address)
+
+      // poke positions
+      await pool.burn(minTick, maxTick, 0)
+      await pool.burn(minTick + tickSpacing, maxTick - tickSpacing, 0)
+
+      const { tokensOwed0: tokensOwed0Position0 } = await pool.positions(
+        getPositionKey(wallet.address, minTick, maxTick)
+      )
+      const { tokensOwed0: tokensOwed0Position1 } = await pool.positions(
+        getPositionKey(wallet.address, minTick + tickSpacing, maxTick - tickSpacing)
+      )
+
+      expect(tokensOwed0Position0).to.be.eq('166666666666667')
+      expect(tokensOwed0Position1).to.be.eq('333333333333334')
+    })
+
+    describe('works across large increases', () => {
+      beforeEach(async () => {
+        await mint(wallet.address, minTick, maxTick, expandTo18Decimals(1))
+      })
+
+      // type(uint128).max * 2**128 / 1e18
+      // https://www.wolframalpha.com/input/?i=%282**128+-+1%29+*+2**128+%2F+1e18
+      const magicNumber = BigNumber.from('115792089237316195423570985008687907852929702298719625575994')
+
+      it('works just before the cap binds', async () => {
+        await pool.setFeeGrowthGlobal0X128(magicNumber)
+        await pool.burn(minTick, maxTick, 0)
+
+        const { tokensOwed0, tokensOwed1 } = await pool.positions(getPositionKey(wallet.address, minTick, maxTick))
+
+        expect(tokensOwed0).to.be.eq(MaxUint128.sub(1))
+        expect(tokensOwed1).to.be.eq(0)
+      })
+
+      it('works just after the cap binds', async () => {
+        await pool.setFeeGrowthGlobal0X128(magicNumber.add(1))
+        await pool.burn(minTick, maxTick, 0)
+
+        const { tokensOwed0, tokensOwed1 } = await pool.positions(getPositionKey(wallet.address, minTick, maxTick))
+
+        expect(tokensOwed0).to.be.eq(MaxUint128)
+        expect(tokensOwed1).to.be.eq(0)
+      })
+
+      it('works well after the cap binds', async () => {
+        await pool.setFeeGrowthGlobal0X128(constants.MaxUint256)
+        await pool.burn(minTick, maxTick, 0)
+
+        const { tokensOwed0, tokensOwed1 } = await pool.positions(getPositionKey(wallet.address, minTick, maxTick))
+
+        expect(tokensOwed0).to.be.eq(MaxUint128)
+        expect(tokensOwed1).to.be.eq(0)
+      })
+    })
+
+    describe('works across overflow boundaries', () => {
+      beforeEach(async () => {
+        await pool.setFeeGrowthGlobal0X128(constants.MaxUint256)
+        await pool.setFeeGrowthGlobal1X128(constants.MaxUint256)
+        await mint(wallet.address, minTick, maxTick, expandTo18Decimals(10))
+      })
+
+      it('token0', async () => {
+        await swapExact0For1(expandTo18Decimals(1), wallet.address)
+        await pool.burn(minTick, maxTick, 0)
+        const { amount0, amount1 } = await pool.callStatic.collect(
+          wallet.address,
+          minTick,
+          maxTick,
+          MaxUint128,
+          MaxUint128
+        )
+        expect(amount0).to.be.eq('499999999999999')
+        expect(amount1).to.be.eq(0)
+      })
+      it('token1', async () => {
+        await swapExact1For0(expandTo18Decimals(1), wallet.address)
+        await pool.burn(minTick, maxTick, 0)
+        const { amount0, amount1 } = await pool.callStatic.collect(
+          wallet.address,
+          minTick,
+          maxTick,
+          MaxUint128,
+          MaxUint128
+        )
+        expect(amount0).to.be.eq(0)
+        expect(amount1).to.be.eq('499999999999999')
+      })
+      it('token0 and token1', async () => {
+        await swapExact0For1(expandTo18Decimals(1), wallet.address)
+        await swapExact1For0(expandTo18Decimals(1), wallet.address)
+        await pool.burn(minTick, maxTick, 0)
+        const { amount0, amount1 } = await pool.callStatic.collect(
+          wallet.address,
+          minTick,
+          maxTick,
+          MaxUint128,
+          MaxUint128
+        )
+        expect(amount0).to.be.eq('499999999999999')
+        expect(amount1).to.be.eq('500000000000000')
+      })
+    })
+  })
+
+  describe('#feeProtocol', () => {
+    const liquidityAmount = expandTo18Decimals(1000)
+
+    beforeEach(async () => {
+      pool = await createPool(FeeAmount.LOW, TICK_SPACINGS[FeeAmount.LOW])
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, liquidityAmount)
+    })
+
+    it('is initially set to 0', async () => {
+      expect((await pool.slot0()).feeProtocol).to.eq(0)
+    })
+
+    it('can be changed by the owner', async () => {
+      await pool.setFeeProtocol(6, 6)
+      expect((await pool.slot0()).feeProtocol).to.eq(102)
+    })
+
+    it('cannot be changed out of bounds', async () => {
+      await expect(pool.setFeeProtocol(3, 3)).to.be.reverted
+      await expect(pool.setFeeProtocol(11, 11)).to.be.reverted
+    })
+
+    it('cannot be changed by addresses that are not owner', async () => {
+      await expect(pool.connect(other).setFeeProtocol(6, 6)).to.be.reverted
+    })
+
+    async function swapAndGetFeesOwed({
+      amount,
+      zeroForOne,
+      poke,
+    }: {
+      amount: BigNumberish
+      zeroForOne: boolean
+      poke: boolean
+    }) {
+      await (zeroForOne ? swapExact0For1(amount, wallet.address) : swapExact1For0(amount, wallet.address))
+
+      if (poke) await pool.burn(minTick, maxTick, 0)
+
+      const { amount0: fees0, amount1: fees1 } = await pool.callStatic.collect(
+        wallet.address,
+        minTick,
+        maxTick,
+        MaxUint128,
+        MaxUint128
+      )
+
+      expect(fees0, 'fees owed in token0 are greater than 0').to.be.gte(0)
+      expect(fees1, 'fees owed in token1 are greater than 0').to.be.gte(0)
+
+      return { token0Fees: fees0, token1Fees: fees1 }
+    }
+
+    it('position owner gets full fees when protocol fee is off', async () => {
+      const { token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+
+      // 6 bips * 1e18
+      expect(token0Fees).to.eq('499999999999999')
+      expect(token1Fees).to.eq(0)
+    })
+
+    it('swap fees accumulate as expected (0 for 1)', async () => {
+      let token0Fees
+      let token1Fees
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq('499999999999999')
+      expect(token1Fees).to.eq(0)
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq('999999999999998')
+      expect(token1Fees).to.eq(0)
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq('1499999999999997')
+      expect(token1Fees).to.eq(0)
+    })
+
+    it('swap fees accumulate as expected (1 for 0)', async () => {
+      let token0Fees
+      let token1Fees
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: false,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq(0)
+      expect(token1Fees).to.eq('499999999999999')
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: false,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq(0)
+      expect(token1Fees).to.eq('999999999999998')
+      ;({ token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: false,
+        poke: true,
+      }))
+      expect(token0Fees).to.eq(0)
+      expect(token1Fees).to.eq('1499999999999997')
+    })
+
+    it('position owner gets partial fees when protocol fee is on', async () => {
+      await pool.setFeeProtocol(6, 6)
+
+      const { token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+
+      expect(token0Fees).to.be.eq('416666666666666')
+      expect(token1Fees).to.be.eq(0)
+    })
+
+    describe('#collectProtocol', () => {
+      it('returns 0 if no fees', async () => {
+        await pool.setFeeProtocol(6, 6)
+        const { amount0, amount1 } = await pool.callStatic.collectProtocol(wallet.address, MaxUint128, MaxUint128)
+        expect(amount0).to.be.eq(0)
+        expect(amount1).to.be.eq(0)
+      })
+
+      it('can collect fees', async () => {
+        await pool.setFeeProtocol(6, 6)
+
+        await swapAndGetFeesOwed({
+          amount: expandTo18Decimals(1),
+          zeroForOne: true,
+          poke: true,
+        })
+
+        await expect(pool.collectProtocol(other.address, MaxUint128, MaxUint128))
+          .to.emit(token0, 'Transfer')
+          .withArgs(pool.address, other.address, '83333333333332')
+      })
+
+      it('fees collected can differ between token0 and token1', async () => {
+        await pool.setFeeProtocol(8, 5)
+
+        await swapAndGetFeesOwed({
+          amount: expandTo18Decimals(1),
+          zeroForOne: true,
+          poke: false,
+        })
+        await swapAndGetFeesOwed({
+          amount: expandTo18Decimals(1),
+          zeroForOne: false,
+          poke: false,
+        })
+
+        await expect(pool.collectProtocol(other.address, MaxUint128, MaxUint128))
+          .to.emit(token0, 'Transfer')
+          // more token0 fees because it's 1/5th the swap fees
+          .withArgs(pool.address, other.address, '62499999999999')
+          .to.emit(token1, 'Transfer')
+          // less token1 fees because it's 1/8th the swap fees
+          .withArgs(pool.address, other.address, '99999999999998')
+      })
+    })
+
+    it('fees collected by lp after two swaps should be double one swap', async () => {
+      await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+      const { token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+
+      // 6 bips * 2e18
+      expect(token0Fees).to.eq('999999999999998')
+      expect(token1Fees).to.eq(0)
+    })
+
+    it('fees collected after two swaps with fee turned on in middle are fees from last swap (not confiscatory)', async () => {
+      await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: false,
+      })
+
+      await pool.setFeeProtocol(6, 6)
+
+      const { token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+
+      expect(token0Fees).to.eq('916666666666666')
+      expect(token1Fees).to.eq(0)
+    })
+
+    it('fees collected by lp after two swaps with intermediate withdrawal', async () => {
+      await pool.setFeeProtocol(6, 6)
+
+      const { token0Fees, token1Fees } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: true,
+      })
+
+      expect(token0Fees).to.eq('416666666666666')
+      expect(token1Fees).to.eq(0)
+
+      // collect the fees
+      await pool.collect(wallet.address, minTick, maxTick, MaxUint128, MaxUint128)
+
+      const { token0Fees: token0FeesNext, token1Fees: token1FeesNext } = await swapAndGetFeesOwed({
+        amount: expandTo18Decimals(1),
+        zeroForOne: true,
+        poke: false,
+      })
+
+      expect(token0FeesNext).to.eq(0)
+      expect(token1FeesNext).to.eq(0)
+
+      let { token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees()
+      expect(token0ProtocolFees).to.eq('166666666666666')
+      expect(token1ProtocolFees).to.eq(0)
+
+      await pool.burn(minTick, maxTick, 0) // poke to update fees
+      await expect(pool.collect(wallet.address, minTick, maxTick, MaxUint128, MaxUint128))
+        .to.emit(token0, 'Transfer')
+        .withArgs(pool.address, wallet.address, '416666666666666')
+      ;({ token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees())
+      expect(token0ProtocolFees).to.eq('166666666666666')
+      expect(token1ProtocolFees).to.eq(0)
+    })
+  })
+
+  describe('#tickSpacing', () => {
+    describe('tickSpacing = 12', () => {
+      beforeEach('deploy pool', async () => {
+        pool = await createPool(FeeAmount.MEDIUM, 12)
+      })
+      describe('post initialize', () => {
+        beforeEach('initialize pool', async () => {
+          await pool.initialize(encodePriceSqrt(1, 1))
+        })
+        it('mint can only be called for multiples of 12', async () => {
+          await expect(mint(wallet.address, -6, 0, 1)).to.be.reverted
+          await expect(mint(wallet.address, 0, 6, 1)).to.be.reverted
+        })
+        it('mint can be called with multiples of 12', async () => {
+          await mint(wallet.address, 12, 24, 1)
+          await mint(wallet.address, -144, -120, 1)
+        })
+        it('swapping across gaps works in 1 for 0 direction', async () => {
+          const liquidityAmount = expandTo18Decimals(1).div(4)
+          await mint(wallet.address, 120000, 121200, liquidityAmount)
+          await swapExact1For0(expandTo18Decimals(1), wallet.address)
+          await expect(pool.burn(120000, 121200, liquidityAmount))
+            .to.emit(pool, 'Burn')
+            .withArgs(wallet.address, 120000, 121200, liquidityAmount, '30027458295511', '996999999999999999')
+            .to.not.emit(token0, 'Transfer')
+            .to.not.emit(token1, 'Transfer')
+          expect((await pool.slot0()).tick).to.eq(120196)
+        })
+        it('swapping across gaps works in 0 for 1 direction', async () => {
+          const liquidityAmount = expandTo18Decimals(1).div(4)
+          await mint(wallet.address, -121200, -120000, liquidityAmount)
+          await swapExact0For1(expandTo18Decimals(1), wallet.address)
+          await expect(pool.burn(-121200, -120000, liquidityAmount))
+            .to.emit(pool, 'Burn')
+            .withArgs(wallet.address, -121200, -120000, liquidityAmount, '996999999999999999', '30027458295511')
+            .to.not.emit(token0, 'Transfer')
+            .to.not.emit(token1, 'Transfer')
+          expect((await pool.slot0()).tick).to.eq(-120197)
+        })
+      })
+    })
+  })
+
+  // https://github.com/Uniswap/uniswap-v3-core/issues/214
+  it('tick transition cannot run twice if zero for one swap ends at fractional price just below tick', async () => {
+    pool = await createPool(FeeAmount.MEDIUM, 1)
+    const sqrtTickMath = (await (await ethers.getContractFactory('TickMathTest')).deploy()) as TickMathTest
+    const swapMath = (await (await ethers.getContractFactory('SwapMathTest')).deploy()) as SwapMathTest
+    const p0 = (await sqrtTickMath.getSqrtRatioAtTick(-24081)).add(1)
+    // initialize at a price of ~0.3 token1/token0
+    // meaning if you swap in 2 token0, you should end up getting 0 token1
+    await pool.initialize(p0)
+    expect(await pool.liquidity(), 'current pool liquidity is 1').to.eq(0)
+    expect((await pool.slot0()).tick, 'pool tick is -24081').to.eq(-24081)
+
+    // add a bunch of liquidity around current price
+    const liquidity = expandTo18Decimals(1000)
+    await mint(wallet.address, -24082, -24080, liquidity)
+    expect(await pool.liquidity(), 'current pool liquidity is now liquidity + 1').to.eq(liquidity)
+
+    await mint(wallet.address, -24082, -24081, liquidity)
+    expect(await pool.liquidity(), 'current pool liquidity is still liquidity + 1').to.eq(liquidity)
+
+    // check the math works out to moving the price down 1, sending no amount out, and having some amount remaining
+    {
+      const { feeAmount, amountIn, amountOut, sqrtQ } = await swapMath.computeSwapStep(
+        p0,
+        p0.sub(1),
+        liquidity,
+        3,
+        FeeAmount.MEDIUM
+      )
+      expect(sqrtQ, 'price moves').to.eq(p0.sub(1))
+      expect(feeAmount, 'fee amount is 1').to.eq(1)
+      expect(amountIn, 'amount in is 1').to.eq(1)
+      expect(amountOut, 'zero amount out').to.eq(0)
+    }
+
+    // swap 2 amount in, should get 0 amount out
+    await expect(swapExact0For1(3, wallet.address))
+      .to.emit(token0, 'Transfer')
+      .withArgs(wallet.address, pool.address, 3)
+      .to.not.emit(token1, 'Transfer')
+
+    const { tick, sqrtPriceX96 } = await pool.slot0()
+
+    expect(tick, 'pool is at the next tick').to.eq(-24082)
+    expect(sqrtPriceX96, 'pool price is still on the p0 boundary').to.eq(p0.sub(1))
+    expect(await pool.liquidity(), 'pool has run tick transition and liquidity changed').to.eq(liquidity.mul(2))
+  })
+
+  describe('#flash', () => {
+    it('fails if not initialized', async () => {
+      await expect(flash(100, 200, other.address)).to.be.reverted
+      await expect(flash(100, 0, other.address)).to.be.reverted
+      await expect(flash(0, 200, other.address)).to.be.reverted
+    })
+    it('fails if no liquidity', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await expect(flash(100, 200, other.address)).to.be.revertedWith('L')
+      await expect(flash(100, 0, other.address)).to.be.revertedWith('L')
+      await expect(flash(0, 200, other.address)).to.be.revertedWith('L')
+    })
+    describe('after liquidity added', () => {
+      let balance0: BigNumber
+      let balance1: BigNumber
+      beforeEach('add some tokens', async () => {
+        await initializeAtZeroTick(pool)
+        ;[balance0, balance1] = await Promise.all([token0.balanceOf(pool.address), token1.balanceOf(pool.address)])
+      })
+
+      describe('fee off', () => {
+        it('emits an event', async () => {
+          await expect(flash(1001, 2001, other.address))
+            .to.emit(pool, 'Flash')
+            .withArgs(swapTarget.address, other.address, 1001, 2001, 4, 7)
+        })
+
+        it('transfers the amount0 to the recipient', async () => {
+          await expect(flash(100, 200, other.address))
+            .to.emit(token0, 'Transfer')
+            .withArgs(pool.address, other.address, 100)
+        })
+        it('transfers the amount1 to the recipient', async () => {
+          await expect(flash(100, 200, other.address))
+            .to.emit(token1, 'Transfer')
+            .withArgs(pool.address, other.address, 200)
+        })
+        it('can flash only token0', async () => {
+          await expect(flash(101, 0, other.address))
+            .to.emit(token0, 'Transfer')
+            .withArgs(pool.address, other.address, 101)
+            .to.not.emit(token1, 'Transfer')
+        })
+        it('can flash only token1', async () => {
+          await expect(flash(0, 102, other.address))
+            .to.emit(token1, 'Transfer')
+            .withArgs(pool.address, other.address, 102)
+            .to.not.emit(token0, 'Transfer')
+        })
+        it('can flash entire token balance', async () => {
+          await expect(flash(balance0, balance1, other.address))
+            .to.emit(token0, 'Transfer')
+            .withArgs(pool.address, other.address, balance0)
+            .to.emit(token1, 'Transfer')
+            .withArgs(pool.address, other.address, balance1)
+        })
+        it('no-op if both amounts are 0', async () => {
+          await expect(flash(0, 0, other.address)).to.not.emit(token0, 'Transfer').to.not.emit(token1, 'Transfer')
+        })
+        it('fails if flash amount is greater than token balance', async () => {
+          await expect(flash(balance0.add(1), balance1, other.address)).to.be.reverted
+          await expect(flash(balance0, balance1.add(1), other.address)).to.be.reverted
+        })
+        it('calls the flash callback on the sender with correct fee amounts', async () => {
+          await expect(flash(1001, 2002, other.address)).to.emit(swapTarget, 'FlashCallback').withArgs(4, 7)
+        })
+        it('increases the fee growth by the expected amount', async () => {
+          await flash(1001, 2002, other.address)
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(4).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(7).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('fails if original balance not returned in either token', async () => {
+          await expect(flash(1000, 0, other.address, 999, 0)).to.be.reverted
+          await expect(flash(0, 1000, other.address, 0, 999)).to.be.reverted
+        })
+        it('fails if underpays either token', async () => {
+          await expect(flash(1000, 0, other.address, 1002, 0)).to.be.reverted
+          await expect(flash(0, 1000, other.address, 0, 1002)).to.be.reverted
+        })
+        it('allows donating token0', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 567, 0))
+            .to.emit(token0, 'Transfer')
+            .withArgs(wallet.address, pool.address, 567)
+            .to.not.emit(token1, 'Transfer')
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(567).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('allows donating token1', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 0, 678))
+            .to.emit(token1, 'Transfer')
+            .withArgs(wallet.address, pool.address, 678)
+            .to.not.emit(token0, 'Transfer')
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(678).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('allows donating token0 and token1 together', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 789, 1234))
+            .to.emit(token0, 'Transfer')
+            .withArgs(wallet.address, pool.address, 789)
+            .to.emit(token1, 'Transfer')
+            .withArgs(wallet.address, pool.address, 1234)
+
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(789).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(1234).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+      })
+
+      describe('fee on', () => {
+        beforeEach('turn protocol fee on', async () => {
+          await pool.setFeeProtocol(6, 6)
+        })
+
+        it('emits an event', async () => {
+          await expect(flash(1001, 2001, other.address))
+            .to.emit(pool, 'Flash')
+            .withArgs(swapTarget.address, other.address, 1001, 2001, 4, 7)
+        })
+
+        it('increases the fee growth by the expected amount', async () => {
+          await flash(2002, 4004, other.address)
+
+          const { token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees()
+          expect(token0ProtocolFees).to.eq(1)
+          expect(token1ProtocolFees).to.eq(2)
+
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(6).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(11).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('allows donating token0', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 567, 0))
+            .to.emit(token0, 'Transfer')
+            .withArgs(wallet.address, pool.address, 567)
+            .to.not.emit(token1, 'Transfer')
+
+          const { token0: token0ProtocolFees } = await pool.protocolFees()
+          expect(token0ProtocolFees).to.eq(94)
+
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(473).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('allows donating token1', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 0, 678))
+            .to.emit(token1, 'Transfer')
+            .withArgs(wallet.address, pool.address, 678)
+            .to.not.emit(token0, 'Transfer')
+
+          const { token1: token1ProtocolFees } = await pool.protocolFees()
+          expect(token1ProtocolFees).to.eq(113)
+
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(565).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+        it('allows donating token0 and token1 together', async () => {
+          await expect(flash(0, 0, constants.AddressZero, 789, 1234))
+            .to.emit(token0, 'Transfer')
+            .withArgs(wallet.address, pool.address, 789)
+            .to.emit(token1, 'Transfer')
+            .withArgs(wallet.address, pool.address, 1234)
+
+          const { token0: token0ProtocolFees, token1: token1ProtocolFees } = await pool.protocolFees()
+          expect(token0ProtocolFees).to.eq(131)
+          expect(token1ProtocolFees).to.eq(205)
+
+          expect(await pool.feeGrowthGlobal0X128()).to.eq(
+            BigNumber.from(658).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+          expect(await pool.feeGrowthGlobal1X128()).to.eq(
+            BigNumber.from(1029).mul(BigNumber.from(2).pow(128)).div(expandTo18Decimals(2))
+          )
+        })
+      })
+    })
+  })
+
+  describe('#increaseObservationCardinalityNext', () => {
+    it('cannot be called before initialization', async () => {
+      await expect(pool.increaseObservationCardinalityNext(2)).to.be.reverted
+    })
+    describe('after initialization', () => {
+      beforeEach('initialize the pool', () => pool.initialize(encodePriceSqrt(1, 1)))
+      it('oracle starting state after initialization', async () => {
+        const { observationCardinality, observationIndex, observationCardinalityNext } = await pool.slot0()
+        expect(observationCardinality).to.eq(1)
+        expect(observationIndex).to.eq(0)
+        expect(observationCardinalityNext).to.eq(1)
+        const {
+          secondsPerLiquidityCumulativeX128,
+          tickCumulative,
+          initialized,
+          blockTimestamp,
+        } = await pool.observations(0)
+        expect(secondsPerLiquidityCumulativeX128).to.eq(0)
+        expect(tickCumulative).to.eq(0)
+        expect(initialized).to.eq(true)
+        expect(blockTimestamp).to.eq(TEST_POOL_START_TIME)
+      })
+      it('increases observation cardinality next', async () => {
+        await pool.increaseObservationCardinalityNext(2)
+        const { observationCardinality, observationIndex, observationCardinalityNext } = await pool.slot0()
+        expect(observationCardinality).to.eq(1)
+        expect(observationIndex).to.eq(0)
+        expect(observationCardinalityNext).to.eq(2)
+      })
+      it('is no op if target is already exceeded', async () => {
+        await pool.increaseObservationCardinalityNext(5)
+        await pool.increaseObservationCardinalityNext(3)
+        const { observationCardinality, observationIndex, observationCardinalityNext } = await pool.slot0()
+        expect(observationCardinality).to.eq(1)
+        expect(observationIndex).to.eq(0)
+        expect(observationCardinalityNext).to.eq(5)
+      })
+    })
+  })
+
+  describe('#setFeeProtocol', () => {
+    beforeEach('initialize the pool', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+    })
+
+    it('can only be called by factory owner', async () => {
+      await expect(pool.connect(other).setFeeProtocol(5, 5)).to.be.reverted
+    })
+    it('fails if fee is lt 4 or gt 10', async () => {
+      await expect(pool.setFeeProtocol(3, 3)).to.be.reverted
+      await expect(pool.setFeeProtocol(6, 3)).to.be.reverted
+      await expect(pool.setFeeProtocol(3, 6)).to.be.reverted
+      await expect(pool.setFeeProtocol(11, 11)).to.be.reverted
+      await expect(pool.setFeeProtocol(6, 11)).to.be.reverted
+      await expect(pool.setFeeProtocol(11, 6)).to.be.reverted
+    })
+    it('succeeds for fee of 4', async () => {
+      await pool.setFeeProtocol(4, 4)
+    })
+    it('succeeds for fee of 10', async () => {
+      await pool.setFeeProtocol(10, 10)
+    })
+    it('sets protocol fee', async () => {
+      await pool.setFeeProtocol(7, 7)
+      expect((await pool.slot0()).feeProtocol).to.eq(119)
+    })
+    it('can change protocol fee', async () => {
+      await pool.setFeeProtocol(7, 7)
+      await pool.setFeeProtocol(5, 8)
+      expect((await pool.slot0()).feeProtocol).to.eq(133)
+    })
+    it('can turn off protocol fee', async () => {
+      await pool.setFeeProtocol(4, 4)
+      await pool.setFeeProtocol(0, 0)
+      expect((await pool.slot0()).feeProtocol).to.eq(0)
+    })
+    it('emits an event when turned on', async () => {
+      await expect(pool.setFeeProtocol(7, 7)).to.be.emit(pool, 'SetFeeProtocol').withArgs(0, 0, 7, 7)
+    })
+    it('emits an event when turned off', async () => {
+      await pool.setFeeProtocol(7, 5)
+      await expect(pool.setFeeProtocol(0, 0)).to.be.emit(pool, 'SetFeeProtocol').withArgs(7, 5, 0, 0)
+    })
+    it('emits an event when changed', async () => {
+      await pool.setFeeProtocol(4, 10)
+      await expect(pool.setFeeProtocol(6, 8)).to.be.emit(pool, 'SetFeeProtocol').withArgs(4, 10, 6, 8)
+    })
+    it('emits an event when unchanged', async () => {
+      await pool.setFeeProtocol(5, 9)
+      await expect(pool.setFeeProtocol(5, 9)).to.be.emit(pool, 'SetFeeProtocol').withArgs(5, 9, 5, 9)
+    })
+  })
+
+  describe('#lock', () => {
+    beforeEach('initialize the pool', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, expandTo18Decimals(1))
+    })
+
+    it('cannot reenter from swap callback', async () => {
+      const reentrant = (await (
+        await ethers.getContractFactory('TestUniswapV3ReentrantCallee')
+      ).deploy()) as TestUniswapV3ReentrantCallee
+
+      // the tests happen in solidity
+      await expect(reentrant.swapToReenter(pool.address)).to.be.revertedWith('Unable to reenter')
+    })
+  })
+
+  describe('#snapshotCumulativesInside', () => {
+    const tickLower = -TICK_SPACINGS[FeeAmount.MEDIUM]
+    const tickUpper = TICK_SPACINGS[FeeAmount.MEDIUM]
+    const tickSpacing = TICK_SPACINGS[FeeAmount.MEDIUM]
+    beforeEach(async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, tickLower, tickUpper, 10)
+    })
+    it('throws if ticks are in reverse order', async () => {
+      await expect(pool.snapshotCumulativesInside(tickUpper, tickLower)).to.be.reverted
+    })
+    it('throws if ticks are the same', async () => {
+      await expect(pool.snapshotCumulativesInside(tickUpper, tickUpper)).to.be.reverted
+    })
+    it('throws if tick lower is too low', async () => {
+      await expect(pool.snapshotCumulativesInside(getMinTick(tickSpacing) - 1, tickUpper)).be.reverted
+    })
+    it('throws if tick upper is too high', async () => {
+      await expect(pool.snapshotCumulativesInside(tickLower, getMaxTick(tickSpacing) + 1)).be.reverted
+    })
+    it('throws if tick lower is not initialized', async () => {
+      await expect(pool.snapshotCumulativesInside(tickLower - tickSpacing, tickUpper)).to.be.reverted
+    })
+    it('throws if tick upper is not initialized', async () => {
+      await expect(pool.snapshotCumulativesInside(tickLower, tickUpper + tickSpacing)).to.be.reverted
+    })
+    it('is zero immediately after initialize', async () => {
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(0)
+      expect(tickCumulativeInside).to.eq(0)
+      expect(secondsInside).to.eq(0)
+    })
+    it('increases by expected amount when time elapses in the range', async () => {
+      await pool.advanceTime(5)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(5).shl(128).div(10))
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(0)
+      expect(secondsInside).to.eq(5)
+    })
+    it('does not account for time increase above range', async () => {
+      await pool.advanceTime(5)
+      await swapToHigherPrice(encodePriceSqrt(2, 1), wallet.address)
+      await pool.advanceTime(7)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(5).shl(128).div(10))
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(0)
+      expect(secondsInside).to.eq(5)
+    })
+    it('does not account for time increase below range', async () => {
+      await pool.advanceTime(5)
+      await swapToLowerPrice(encodePriceSqrt(1, 2), wallet.address)
+      await pool.advanceTime(7)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(5).shl(128).div(10))
+      // tick is 0 for 5 seconds, then not in range
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(0)
+      expect(secondsInside).to.eq(5)
+    })
+    it('time increase below range is not counted', async () => {
+      await swapToLowerPrice(encodePriceSqrt(1, 2), wallet.address)
+      await pool.advanceTime(5)
+      await swapToHigherPrice(encodePriceSqrt(1, 1), wallet.address)
+      await pool.advanceTime(7)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(7).shl(128).div(10))
+      // tick is not in range then tick is 0 for 7 seconds
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(0)
+      expect(secondsInside).to.eq(7)
+    })
+    it('time increase above range is not counted', async () => {
+      await swapToHigherPrice(encodePriceSqrt(2, 1), wallet.address)
+      await pool.advanceTime(5)
+      await swapToLowerPrice(encodePriceSqrt(1, 1), wallet.address)
+      await pool.advanceTime(7)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(7).shl(128).div(10))
+      expect((await pool.slot0()).tick).to.eq(-1) // justify the -7 tick cumulative inside value
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(-7)
+      expect(secondsInside).to.eq(7)
+    })
+    it('positions minted after time spent', async () => {
+      await pool.advanceTime(5)
+      await mint(wallet.address, tickUpper, getMaxTick(tickSpacing), 15)
+      await swapToHigherPrice(encodePriceSqrt(2, 1), wallet.address)
+      await pool.advanceTime(8)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickUpper, getMaxTick(tickSpacing))
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(8).shl(128).div(15))
+      // the tick of 2/1 is 6931
+      // 8 seconds * 6931 = 55448
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(55448)
+      expect(secondsInside).to.eq(8)
+    })
+    it('overlapping liquidity is aggregated', async () => {
+      await mint(wallet.address, tickLower, getMaxTick(tickSpacing), 15)
+      await pool.advanceTime(5)
+      await swapToHigherPrice(encodePriceSqrt(2, 1), wallet.address)
+      await pool.advanceTime(8)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(tickLower, tickUpper)
+      expect(secondsPerLiquidityInsideX128).to.eq(BigNumber.from(5).shl(128).div(25))
+      expect(tickCumulativeInside, 'tickCumulativeInside').to.eq(0)
+      expect(secondsInside).to.eq(5)
+    })
+    it('relative behavior of snapshots', async () => {
+      await pool.advanceTime(5)
+      await mint(wallet.address, getMinTick(tickSpacing), tickLower, 15)
+      const {
+        secondsPerLiquidityInsideX128: secondsPerLiquidityInsideX128Start,
+        tickCumulativeInside: tickCumulativeInsideStart,
+        secondsInside: secondsInsideStart,
+      } = await pool.snapshotCumulativesInside(getMinTick(tickSpacing), tickLower)
+      await pool.advanceTime(8)
+      // 13 seconds in starting range, then 3 seconds in newly minted range
+      await swapToLowerPrice(encodePriceSqrt(1, 2), wallet.address)
+      await pool.advanceTime(3)
+      const {
+        secondsPerLiquidityInsideX128,
+        tickCumulativeInside,
+        secondsInside,
+      } = await pool.snapshotCumulativesInside(getMinTick(tickSpacing), tickLower)
+      const expectedDiffSecondsPerLiquidity = BigNumber.from(3).shl(128).div(15)
+      expect(secondsPerLiquidityInsideX128.sub(secondsPerLiquidityInsideX128Start)).to.eq(
+        expectedDiffSecondsPerLiquidity
+      )
+      expect(secondsPerLiquidityInsideX128).to.not.eq(expectedDiffSecondsPerLiquidity)
+      // the tick is the one corresponding to the price of 1/2, or log base 1.0001 of 0.5
+      // this is -6932, and 3 seconds have passed, so the cumulative computed from the diff equals 6932 * 3
+      expect(tickCumulativeInside.sub(tickCumulativeInsideStart), 'tickCumulativeInside').to.eq(-20796)
+      expect(secondsInside - secondsInsideStart).to.eq(3)
+      expect(secondsInside).to.not.eq(3)
+    })
+  })
+
+  describe('fees overflow scenarios', async () => {
+    it('up to max uint 128', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, MaxUint128, MaxUint128)
+
+      const [feeGrowthGlobal0X128, feeGrowthGlobal1X128] = await Promise.all([
+        pool.feeGrowthGlobal0X128(),
+        pool.feeGrowthGlobal1X128(),
+      ])
+      // all 1s in first 128 bits
+      expect(feeGrowthGlobal0X128).to.eq(MaxUint128.shl(128))
+      expect(feeGrowthGlobal1X128).to.eq(MaxUint128.shl(128))
+      await pool.burn(minTick, maxTick, 0)
+      const { amount0, amount1 } = await pool.callStatic.collect(
+        wallet.address,
+        minTick,
+        maxTick,
+        MaxUint128,
+        MaxUint128
+      )
+      expect(amount0).to.eq(MaxUint128)
+      expect(amount1).to.eq(MaxUint128)
+    })
+
+    it('overflow max uint 128', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, MaxUint128, MaxUint128)
+      await flash(0, 0, wallet.address, 1, 1)
+
+      const [feeGrowthGlobal0X128, feeGrowthGlobal1X128] = await Promise.all([
+        pool.feeGrowthGlobal0X128(),
+        pool.feeGrowthGlobal1X128(),
+      ])
+      // all 1s in first 128 bits
+      expect(feeGrowthGlobal0X128).to.eq(0)
+      expect(feeGrowthGlobal1X128).to.eq(0)
+      await pool.burn(minTick, maxTick, 0)
+      const { amount0, amount1 } = await pool.callStatic.collect(
+        wallet.address,
+        minTick,
+        maxTick,
+        MaxUint128,
+        MaxUint128
+      )
+      // fees burned
+      expect(amount0).to.eq(0)
+      expect(amount1).to.eq(0)
+    })
+
+    it('overflow max uint 128 after poke burns fees owed to 0', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, MaxUint128, MaxUint128)
+      await pool.burn(minTick, maxTick, 0)
+      await flash(0, 0, wallet.address, 1, 1)
+      await pool.burn(minTick, maxTick, 0)
+
+      const { amount0, amount1 } = await pool.callStatic.collect(
+        wallet.address,
+        minTick,
+        maxTick,
+        MaxUint128,
+        MaxUint128
+      )
+      // fees burned
+      expect(amount0).to.eq(0)
+      expect(amount1).to.eq(0)
+    })
+
+    it('two positions at the same snapshot', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, 1)
+      await mint(other.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, MaxUint128, 0)
+      await flash(0, 0, wallet.address, MaxUint128, 0)
+      const feeGrowthGlobal0X128 = await pool.feeGrowthGlobal0X128()
+      expect(feeGrowthGlobal0X128).to.eq(MaxUint128.shl(128))
+      await flash(0, 0, wallet.address, 2, 0)
+      await pool.burn(minTick, maxTick, 0)
+      await pool.connect(other).burn(minTick, maxTick, 0)
+      let { amount0 } = await pool.callStatic.collect(wallet.address, minTick, maxTick, MaxUint128, MaxUint128)
+      expect(amount0, 'amount0 of wallet').to.eq(0)
+      ;({ amount0 } = await pool
+        .connect(other)
+        .callStatic.collect(other.address, minTick, maxTick, MaxUint128, MaxUint128))
+      expect(amount0, 'amount0 of other').to.eq(0)
+    })
+
+    it('two positions 1 wei of fees apart overflows exactly once', async () => {
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, 1, 0)
+      await mint(other.address, minTick, maxTick, 1)
+      await flash(0, 0, wallet.address, MaxUint128, 0)
+      await flash(0, 0, wallet.address, MaxUint128, 0)
+      const feeGrowthGlobal0X128 = await pool.feeGrowthGlobal0X128()
+      expect(feeGrowthGlobal0X128).to.eq(0)
+      await flash(0, 0, wallet.address, 2, 0)
+      await pool.burn(minTick, maxTick, 0)
+      await pool.connect(other).burn(minTick, maxTick, 0)
+      let { amount0 } = await pool.callStatic.collect(wallet.address, minTick, maxTick, MaxUint128, MaxUint128)
+      expect(amount0, 'amount0 of wallet').to.eq(1)
+      ;({ amount0 } = await pool
+        .connect(other)
+        .callStatic.collect(other.address, minTick, maxTick, MaxUint128, MaxUint128))
+      expect(amount0, 'amount0 of other').to.eq(0)
+    })
+  })
+
+  describe('swap underpayment tests', () => {
+    let underpay: TestUniswapV3SwapPay
+    beforeEach('deploy swap test', async () => {
+      const underpayFactory = await ethers.getContractFactory('TestUniswapV3SwapPay')
+      underpay = (await underpayFactory.deploy()) as TestUniswapV3SwapPay
+      await token0.approve(underpay.address, constants.MaxUint256)
+      await token1.approve(underpay.address, constants.MaxUint256)
+      await pool.initialize(encodePriceSqrt(1, 1))
+      await mint(wallet.address, minTick, maxTick, expandTo18Decimals(1))
+    })
+
+    it('underpay zero for one and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), 1000, 1, 0)
+      ).to.be.revertedWith('IIA')
+    })
+    it('pay in the wrong token zero for one and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), 1000, 0, 2000)
+      ).to.be.revertedWith('IIA')
+    })
+    it('overpay zero for one and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), 1000, 2000, 0)
+      ).to.not.be.revertedWith('IIA')
+    })
+    it('underpay zero for one and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), -1000, 1, 0)
+      ).to.be.revertedWith('IIA')
+    })
+    it('pay in the wrong token zero for one and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), -1000, 0, 2000)
+      ).to.be.revertedWith('IIA')
+    })
+    it('overpay zero for one and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, true, MIN_SQRT_RATIO.add(1), -1000, 2000, 0)
+      ).to.not.be.revertedWith('IIA')
+    })
+    it('underpay one for zero and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), 1000, 0, 1)
+      ).to.be.revertedWith('IIA')
+    })
+    it('pay in the wrong token one for zero and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), 1000, 2000, 0)
+      ).to.be.revertedWith('IIA')
+    })
+    it('overpay one for zero and exact in', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), 1000, 0, 2000)
+      ).to.not.be.revertedWith('IIA')
+    })
+    it('underpay one for zero and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), -1000, 0, 1)
+      ).to.be.revertedWith('IIA')
+    })
+    it('pay in the wrong token one for zero and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), -1000, 2000, 0)
+      ).to.be.revertedWith('IIA')
+    })
+    it('overpay one for zero and exact out', async () => {
+      await expect(
+        underpay.swap(pool.address, wallet.address, false, MAX_SQRT_RATIO.sub(1), -1000, 0, 2000)
+      ).to.not.be.revertedWith('IIA')
+    })
+  })
+})