@diwantanushh/rapiddex-contracts 1.0.0

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

@@ -0,0 +1,373 @@
+import Decimal from 'decimal.js'
+import { BigNumber, BigNumberish, Wallet } from 'ethers'
+import { ethers, waffle } from 'hardhat'
+import { MockTimeUniswapV3Pool } from '../typechain/MockTimeUniswapV3Pool'
+import { TickMathTest } from '../typechain/TickMathTest'
+import { UniswapV3PoolSwapTest } from '../typechain/UniswapV3PoolSwapTest'
+import { expect } from './shared/expect'
+
+import { poolFixture } from './shared/fixtures'
+import { formatPrice, formatTokenAmount } from './shared/format'
+
+import {
+  createPoolFunctions,
+  encodePriceSqrt,
+  expandTo18Decimals,
+  FeeAmount,
+  getMaxLiquidityPerTick,
+  getMaxTick,
+  getMinTick,
+  MAX_SQRT_RATIO,
+  MaxUint128,
+  MIN_SQRT_RATIO,
+  MintFunction,
+  SwapFunction,
+  TICK_SPACINGS,
+} from './shared/utilities'
+
+const {
+  constants: { MaxUint256 },
+} = ethers
+
+const createFixtureLoader = waffle.createFixtureLoader
+
+Decimal.config({ toExpNeg: -500, toExpPos: 500 })
+
+function applySqrtRatioBipsHundredthsDelta(sqrtRatio: BigNumber, bipsHundredths: number): BigNumber {
+  return BigNumber.from(
+    new Decimal(
+      sqrtRatio
+        .mul(sqrtRatio)
+        .mul(1e6 + bipsHundredths)
+        .div(1e6)
+        .toString()
+    )
+      .sqrt()
+      .floor()
+      .toString()
+  )
+}
+
+describe('UniswapV3Pool arbitrage tests', () => {
+  let wallet: Wallet, arbitrageur: Wallet
+
+  let loadFixture: ReturnType<typeof createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    ;[wallet, arbitrageur] = await (ethers as any).getSigners()
+    loadFixture = createFixtureLoader([wallet, arbitrageur])
+  })
+
+  for (const feeProtocol of [0, 6]) {
+    describe(`protocol fee = ${feeProtocol};`, () => {
+      const startingPrice = encodePriceSqrt(1, 1)
+      const startingTick = 0
+      const feeAmount = FeeAmount.MEDIUM
+      const tickSpacing = TICK_SPACINGS[feeAmount]
+      const minTick = getMinTick(tickSpacing)
+      const maxTick = getMaxTick(tickSpacing)
+
+      for (const passiveLiquidity of [
+        expandTo18Decimals(1).div(100),
+        expandTo18Decimals(1),
+        expandTo18Decimals(10),
+        expandTo18Decimals(100),
+      ]) {
+        describe(`passive liquidity of ${formatTokenAmount(passiveLiquidity)}`, () => {
+          const arbTestFixture = async ([wallet, arbitrageur]: Wallet[]) => {
+            const fix = await poolFixture([wallet], waffle.provider)
+
+            const pool = await fix.createPool(feeAmount, tickSpacing)
+
+            await fix.token0.transfer(arbitrageur.address, BigNumber.from(2).pow(254))
+            await fix.token1.transfer(arbitrageur.address, BigNumber.from(2).pow(254))
+
+            const {
+              swapExact0For1,
+              swapToHigherPrice,
+              swapToLowerPrice,
+              swapExact1For0,
+              mint,
+            } = await createPoolFunctions({
+              swapTarget: fix.swapTargetCallee,
+              token0: fix.token0,
+              token1: fix.token1,
+              pool,
+            })
+
+            const testerFactory = await ethers.getContractFactory('UniswapV3PoolSwapTest')
+            const tester = (await testerFactory.deploy()) as UniswapV3PoolSwapTest
+
+            const tickMathFactory = await ethers.getContractFactory('TickMathTest')
+            const tickMath = (await tickMathFactory.deploy()) as TickMathTest
+
+            await fix.token0.approve(tester.address, MaxUint256)
+            await fix.token1.approve(tester.address, MaxUint256)
+
+            await pool.initialize(startingPrice)
+            if (feeProtocol != 0) await pool.setFeeProtocol(feeProtocol, feeProtocol)
+            await mint(wallet.address, minTick, maxTick, passiveLiquidity)
+
+            expect((await pool.slot0()).tick).to.eq(startingTick)
+            expect((await pool.slot0()).sqrtPriceX96).to.eq(startingPrice)
+
+            return { pool, swapExact0For1, mint, swapToHigherPrice, swapToLowerPrice, swapExact1For0, tester, tickMath }
+          }
+
+          let swapExact0For1: SwapFunction
+          let swapToHigherPrice: SwapFunction
+          let swapToLowerPrice: SwapFunction
+          let swapExact1For0: SwapFunction
+          let pool: MockTimeUniswapV3Pool
+          let mint: MintFunction
+          let tester: UniswapV3PoolSwapTest
+          let tickMath: TickMathTest
+
+          beforeEach('load the fixture', async () => {
+            ;({
+              swapExact0For1,
+              pool,
+              mint,
+              swapToHigherPrice,
+              swapToLowerPrice,
+              swapExact1For0,
+              tester,
+              tickMath,
+            } = await loadFixture(arbTestFixture))
+          })
+
+          async function simulateSwap(
+            zeroForOne: boolean,
+            amountSpecified: BigNumberish,
+            sqrtPriceLimitX96?: BigNumber
+          ): Promise<{
+            executionPrice: BigNumber
+            nextSqrtRatio: BigNumber
+            amount0Delta: BigNumber
+            amount1Delta: BigNumber
+          }> {
+            const { amount0Delta, amount1Delta, nextSqrtRatio } = await tester.callStatic.getSwapResult(
+              pool.address,
+              zeroForOne,
+              amountSpecified,
+              sqrtPriceLimitX96 ?? (zeroForOne ? MIN_SQRT_RATIO.add(1) : MAX_SQRT_RATIO.sub(1))
+            )
+
+            const executionPrice = zeroForOne
+              ? encodePriceSqrt(amount1Delta, amount0Delta.mul(-1))
+              : encodePriceSqrt(amount1Delta.mul(-1), amount0Delta)
+
+            return { executionPrice, nextSqrtRatio, amount0Delta, amount1Delta }
+          }
+
+          for (const { zeroForOne, assumedTruePriceAfterSwap, inputAmount, description } of [
+            {
+              description: 'exact input of 10e18 token0 with starting price of 1.0 and true price of 0.98',
+              zeroForOne: true,
+              inputAmount: expandTo18Decimals(10),
+              assumedTruePriceAfterSwap: encodePriceSqrt(98, 100),
+            },
+            {
+              description: 'exact input of 10e18 token0 with starting price of 1.0 and true price of 1.01',
+              zeroForOne: true,
+              inputAmount: expandTo18Decimals(10),
+              assumedTruePriceAfterSwap: encodePriceSqrt(101, 100),
+            },
+          ]) {
+            describe(description, () => {
+              function valueToken1(arbBalance0: BigNumber, arbBalance1: BigNumber) {
+                return assumedTruePriceAfterSwap
+                  .mul(assumedTruePriceAfterSwap)
+                  .mul(arbBalance0)
+                  .div(BigNumber.from(2).pow(192))
+                  .add(arbBalance1)
+              }
+
+              it('not sandwiched', async () => {
+                const { executionPrice, amount1Delta, amount0Delta } = await simulateSwap(zeroForOne, inputAmount)
+                zeroForOne
+                  ? await swapExact0For1(inputAmount, wallet.address)
+                  : await swapExact1For0(inputAmount, wallet.address)
+
+                expect({
+                  executionPrice: formatPrice(executionPrice),
+                  amount0Delta: formatTokenAmount(amount0Delta),
+                  amount1Delta: formatTokenAmount(amount1Delta),
+                  priceAfter: formatPrice((await pool.slot0()).sqrtPriceX96),
+                }).to.matchSnapshot()
+              })
+
+              it('sandwiched with swap to execution price then mint max liquidity/target/burn max liquidity', async () => {
+                const { executionPrice } = await simulateSwap(zeroForOne, inputAmount)
+
+                const firstTickAboveMarginalPrice = zeroForOne
+                  ? Math.ceil(
+                      (await tickMath.getTickAtSqrtRatio(
+                        applySqrtRatioBipsHundredthsDelta(executionPrice, feeAmount)
+                      )) / tickSpacing
+                    ) * tickSpacing
+                  : Math.floor(
+                      (await tickMath.getTickAtSqrtRatio(
+                        applySqrtRatioBipsHundredthsDelta(executionPrice, -feeAmount)
+                      )) / tickSpacing
+                    ) * tickSpacing
+                const tickAfterFirstTickAboveMarginPrice = zeroForOne
+                  ? firstTickAboveMarginalPrice - tickSpacing
+                  : firstTickAboveMarginalPrice + tickSpacing
+
+                const priceSwapStart = await tickMath.getSqrtRatioAtTick(firstTickAboveMarginalPrice)
+
+                let arbBalance0 = BigNumber.from(0)
+                let arbBalance1 = BigNumber.from(0)
+
+                // first frontrun to the first tick before the execution price
+                const {
+                  amount0Delta: frontrunDelta0,
+                  amount1Delta: frontrunDelta1,
+                  executionPrice: frontrunExecutionPrice,
+                } = await simulateSwap(zeroForOne, MaxUint256.div(2), priceSwapStart)
+                arbBalance0 = arbBalance0.sub(frontrunDelta0)
+                arbBalance1 = arbBalance1.sub(frontrunDelta1)
+                zeroForOne
+                  ? await swapToLowerPrice(priceSwapStart, arbitrageur.address)
+                  : await swapToHigherPrice(priceSwapStart, arbitrageur.address)
+
+                const profitToken1AfterFrontRun = valueToken1(arbBalance0, arbBalance1)
+
+                const tickLower = zeroForOne ? tickAfterFirstTickAboveMarginPrice : firstTickAboveMarginalPrice
+                const tickUpper = zeroForOne ? firstTickAboveMarginalPrice : tickAfterFirstTickAboveMarginPrice
+
+                // deposit max liquidity at the tick
+                const mintReceipt = await (
+                  await mint(wallet.address, tickLower, tickUpper, getMaxLiquidityPerTick(tickSpacing))
+                ).wait()
+                // sub the mint costs
+                const { amount0: amount0Mint, amount1: amount1Mint } = pool.interface.decodeEventLog(
+                  pool.interface.events['Mint(address,address,int24,int24,uint128,uint256,uint256)'],
+                  mintReceipt.events?.[2].data!
+                )
+                arbBalance0 = arbBalance0.sub(amount0Mint)
+                arbBalance1 = arbBalance1.sub(amount1Mint)
+
+                // execute the user's swap
+                const { executionPrice: executionPriceAfterFrontrun } = await simulateSwap(zeroForOne, inputAmount)
+                zeroForOne
+                  ? await swapExact0For1(inputAmount, wallet.address)
+                  : await swapExact1For0(inputAmount, wallet.address)
+
+                // burn the arb's liquidity
+                const { amount0: amount0Burn, amount1: amount1Burn } = await pool.callStatic.burn(
+                  tickLower,
+                  tickUpper,
+                  getMaxLiquidityPerTick(tickSpacing)
+                )
+                await pool.burn(tickLower, tickUpper, getMaxLiquidityPerTick(tickSpacing))
+                arbBalance0 = arbBalance0.add(amount0Burn)
+                arbBalance1 = arbBalance1.add(amount1Burn)
+
+                // add the fees as well
+                const {
+                  amount0: amount0CollectAndBurn,
+                  amount1: amount1CollectAndBurn,
+                } = await pool.callStatic.collect(arbitrageur.address, tickLower, tickUpper, MaxUint128, MaxUint128)
+                const [amount0Collect, amount1Collect] = [
+                  amount0CollectAndBurn.sub(amount0Burn),
+                  amount1CollectAndBurn.sub(amount1Burn),
+                ]
+                arbBalance0 = arbBalance0.add(amount0Collect)
+                arbBalance1 = arbBalance1.add(amount1Collect)
+
+                const profitToken1AfterSandwich = valueToken1(arbBalance0, arbBalance1)
+
+                // backrun the swap to true price, i.e. swap to the marginal price = true price
+                const priceToSwapTo = zeroForOne
+                  ? applySqrtRatioBipsHundredthsDelta(assumedTruePriceAfterSwap, -feeAmount)
+                  : applySqrtRatioBipsHundredthsDelta(assumedTruePriceAfterSwap, feeAmount)
+                const {
+                  amount0Delta: backrunDelta0,
+                  amount1Delta: backrunDelta1,
+                  executionPrice: backrunExecutionPrice,
+                } = await simulateSwap(!zeroForOne, MaxUint256.div(2), priceToSwapTo)
+                await swapToHigherPrice(priceToSwapTo, wallet.address)
+                arbBalance0 = arbBalance0.sub(backrunDelta0)
+                arbBalance1 = arbBalance1.sub(backrunDelta1)
+
+                expect({
+                  sandwichedPrice: formatPrice(executionPriceAfterFrontrun),
+                  arbBalanceDelta0: formatTokenAmount(arbBalance0),
+                  arbBalanceDelta1: formatTokenAmount(arbBalance1),
+                  profit: {
+                    final: formatTokenAmount(valueToken1(arbBalance0, arbBalance1)),
+                    afterFrontrun: formatTokenAmount(profitToken1AfterFrontRun),
+                    afterSandwich: formatTokenAmount(profitToken1AfterSandwich),
+                  },
+                  backrun: {
+                    executionPrice: formatPrice(backrunExecutionPrice),
+                    delta0: formatTokenAmount(backrunDelta0),
+                    delta1: formatTokenAmount(backrunDelta1),
+                  },
+                  frontrun: {
+                    executionPrice: formatPrice(frontrunExecutionPrice),
+                    delta0: formatTokenAmount(frontrunDelta0),
+                    delta1: formatTokenAmount(frontrunDelta1),
+                  },
+                  collect: {
+                    amount0: formatTokenAmount(amount0Collect),
+                    amount1: formatTokenAmount(amount1Collect),
+                  },
+                  burn: {
+                    amount0: formatTokenAmount(amount0Burn),
+                    amount1: formatTokenAmount(amount1Burn),
+                  },
+                  mint: {
+                    amount0: formatTokenAmount(amount0Mint),
+                    amount1: formatTokenAmount(amount1Mint),
+                  },
+                  finalPrice: formatPrice((await pool.slot0()).sqrtPriceX96),
+                }).to.matchSnapshot()
+              })
+
+              it('backrun to true price after swap only', async () => {
+                let arbBalance0 = BigNumber.from(0)
+                let arbBalance1 = BigNumber.from(0)
+
+                zeroForOne
+                  ? await swapExact0For1(inputAmount, wallet.address)
+                  : await swapExact1For0(inputAmount, wallet.address)
+
+                // swap to the marginal price = true price
+                const priceToSwapTo = zeroForOne
+                  ? applySqrtRatioBipsHundredthsDelta(assumedTruePriceAfterSwap, -feeAmount)
+                  : applySqrtRatioBipsHundredthsDelta(assumedTruePriceAfterSwap, feeAmount)
+                const {
+                  amount0Delta: backrunDelta0,
+                  amount1Delta: backrunDelta1,
+                  executionPrice: backrunExecutionPrice,
+                } = await simulateSwap(!zeroForOne, MaxUint256.div(2), priceToSwapTo)
+                zeroForOne
+                  ? await swapToHigherPrice(priceToSwapTo, wallet.address)
+                  : await swapToLowerPrice(priceToSwapTo, wallet.address)
+                arbBalance0 = arbBalance0.sub(backrunDelta0)
+                arbBalance1 = arbBalance1.sub(backrunDelta1)
+
+                expect({
+                  arbBalanceDelta0: formatTokenAmount(arbBalance0),
+                  arbBalanceDelta1: formatTokenAmount(arbBalance1),
+                  profit: {
+                    final: formatTokenAmount(valueToken1(arbBalance0, arbBalance1)),
+                  },
+                  backrun: {
+                    executionPrice: formatPrice(backrunExecutionPrice),
+                    delta0: formatTokenAmount(backrunDelta0),
+                    delta1: formatTokenAmount(backrunDelta1),
+                  },
+                  finalPrice: formatPrice((await pool.slot0()).sqrtPriceX96),
+                }).to.matchSnapshot()
+              })
+            })
+          }
+        })
+      }
+    })
+  }
+})

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

@@ -0,0 +1,315 @@
+import { ethers, waffle } from 'hardhat'
+import { Wallet } from 'ethers'
+import { MockTimeUniswapV3Pool } from '../typechain/MockTimeUniswapV3Pool'
+import { expect } from './shared/expect'
+
+import { poolFixture } from './shared/fixtures'
+import snapshotGasCost from './shared/snapshotGasCost'
+
+import {
+  expandTo18Decimals,
+  FeeAmount,
+  getMinTick,
+  encodePriceSqrt,
+  TICK_SPACINGS,
+  createPoolFunctions,
+  SwapFunction,
+  MintFunction,
+  getMaxTick,
+  MaxUint128,
+  SwapToPriceFunction,
+  MAX_SQRT_RATIO,
+  MIN_SQRT_RATIO,
+} from './shared/utilities'
+
+const createFixtureLoader = waffle.createFixtureLoader
+
+describe('UniswapV3Pool gas tests', () => {
+  let wallet: Wallet, other: Wallet
+
+  let loadFixture: ReturnType<typeof createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    ;[wallet, other] = await (ethers as any).getSigners()
+    loadFixture = createFixtureLoader([wallet, other])
+  })
+
+  for (const feeProtocol of [0, 6]) {
+    describe(feeProtocol > 0 ? 'fee is on' : 'fee is off', () => {
+      const startingPrice = encodePriceSqrt(100001, 100000)
+      const startingTick = 0
+      const feeAmount = FeeAmount.MEDIUM
+      const tickSpacing = TICK_SPACINGS[feeAmount]
+      const minTick = getMinTick(tickSpacing)
+      const maxTick = getMaxTick(tickSpacing)
+
+      const gasTestFixture = async ([wallet]: Wallet[]) => {
+        const fix = await poolFixture([wallet], waffle.provider)
+
+        const pool = await fix.createPool(feeAmount, tickSpacing)
+
+        const { swapExact0For1, swapToHigherPrice, mint, swapToLowerPrice } = await createPoolFunctions({
+          swapTarget: fix.swapTargetCallee,
+          token0: fix.token0,
+          token1: fix.token1,
+          pool,
+        })
+
+        await pool.initialize(encodePriceSqrt(1, 1))
+        await pool.setFeeProtocol(feeProtocol, feeProtocol)
+        await pool.increaseObservationCardinalityNext(4)
+        await pool.advanceTime(1)
+        await mint(wallet.address, minTick, maxTick, expandTo18Decimals(2))
+
+        await swapExact0For1(expandTo18Decimals(1), wallet.address)
+        await pool.advanceTime(1)
+        await swapToHigherPrice(startingPrice, wallet.address)
+        await pool.advanceTime(1)
+        expect((await pool.slot0()).tick).to.eq(startingTick)
+        expect((await pool.slot0()).sqrtPriceX96).to.eq(startingPrice)
+
+        return { pool, swapExact0For1, mint, swapToHigherPrice, swapToLowerPrice }
+      }
+
+      let swapExact0For1: SwapFunction
+      let swapToHigherPrice: SwapToPriceFunction
+      let swapToLowerPrice: SwapToPriceFunction
+      let pool: MockTimeUniswapV3Pool
+      let mint: MintFunction
+
+      beforeEach('load the fixture', async () => {
+        ;({ swapExact0For1, pool, mint, swapToHigherPrice, swapToLowerPrice } = await loadFixture(gasTestFixture))
+      })
+
+      describe('#swapExact0For1', () => {
+        it('first swap in block with no tick movement', async () => {
+          await snapshotGasCost(swapExact0For1(2000, wallet.address))
+          expect((await pool.slot0()).sqrtPriceX96).to.not.eq(startingPrice)
+          expect((await pool.slot0()).tick).to.eq(startingTick)
+        })
+
+        it('first swap in block moves tick, no initialized crossings', async () => {
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1).div(10000), wallet.address))
+          expect((await pool.slot0()).tick).to.eq(startingTick - 1)
+        })
+
+        it('second swap in block with no tick movement', async () => {
+          await swapExact0For1(expandTo18Decimals(1).div(10000), wallet.address)
+          expect((await pool.slot0()).tick).to.eq(startingTick - 1)
+          await snapshotGasCost(swapExact0For1(2000, wallet.address))
+          expect((await pool.slot0()).tick).to.eq(startingTick - 1)
+        })
+
+        it('second swap in block moves tick, no initialized crossings', async () => {
+          await swapExact0For1(1000, wallet.address)
+          expect((await pool.slot0()).tick).to.eq(startingTick)
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1).div(10000), wallet.address))
+          expect((await pool.slot0()).tick).to.eq(startingTick - 1)
+        })
+
+        it('first swap in block, large swap, no initialized crossings', async () => {
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(10), wallet.address))
+          expect((await pool.slot0()).tick).to.eq(-35787)
+        })
+
+        it('first swap in block, large swap crossing several initialized ticks', async () => {
+          await mint(wallet.address, startingTick - 3 * tickSpacing, startingTick - tickSpacing, expandTo18Decimals(1))
+          await mint(
+            wallet.address,
+            startingTick - 4 * tickSpacing,
+            startingTick - 2 * tickSpacing,
+            expandTo18Decimals(1)
+          )
+          expect((await pool.slot0()).tick).to.eq(startingTick)
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(startingTick - 4 * tickSpacing) // we crossed the last tick
+        })
+
+        it('first swap in block, large swap crossing a single initialized tick', async () => {
+          await mint(wallet.address, minTick, startingTick - 2 * tickSpacing, expandTo18Decimals(1))
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(startingTick - 2 * tickSpacing) // we crossed the last tick
+        })
+
+        it('second swap in block, large swap crossing several initialized ticks', async () => {
+          await mint(wallet.address, startingTick - 3 * tickSpacing, startingTick - tickSpacing, expandTo18Decimals(1))
+          await mint(
+            wallet.address,
+            startingTick - 4 * tickSpacing,
+            startingTick - 2 * tickSpacing,
+            expandTo18Decimals(1)
+          )
+          await swapExact0For1(expandTo18Decimals(1).div(10000), wallet.address)
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(startingTick - 4 * tickSpacing)
+        })
+
+        it('second swap in block, large swap crossing a single initialized tick', async () => {
+          await mint(wallet.address, minTick, startingTick - 2 * tickSpacing, expandTo18Decimals(1))
+          await swapExact0For1(expandTo18Decimals(1).div(10000), wallet.address)
+          expect((await pool.slot0()).tick).to.be.gt(startingTick - 2 * tickSpacing) // we didn't cross the initialized tick
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(startingTick - 2 * tickSpacing) // we crossed the last tick
+        })
+
+        it('large swap crossing several initialized ticks after some time passes', async () => {
+          await mint(wallet.address, startingTick - 3 * tickSpacing, startingTick - tickSpacing, expandTo18Decimals(1))
+          await mint(
+            wallet.address,
+            startingTick - 4 * tickSpacing,
+            startingTick - 2 * tickSpacing,
+            expandTo18Decimals(1)
+          )
+          await swapExact0For1(2, wallet.address)
+          await pool.advanceTime(1)
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(startingTick - 4 * tickSpacing)
+        })
+
+        it('large swap crossing several initialized ticks second time after some time passes', async () => {
+          await mint(wallet.address, startingTick - 3 * tickSpacing, startingTick - tickSpacing, expandTo18Decimals(1))
+          await mint(
+            wallet.address,
+            startingTick - 4 * tickSpacing,
+            startingTick - 2 * tickSpacing,
+            expandTo18Decimals(1)
+          )
+          await swapExact0For1(expandTo18Decimals(1), wallet.address)
+          await swapToHigherPrice(startingPrice, wallet.address)
+          await pool.advanceTime(1)
+          await snapshotGasCost(swapExact0For1(expandTo18Decimals(1), wallet.address))
+          expect((await pool.slot0()).tick).to.be.lt(tickSpacing * -4)
+        })
+      })
+
+      describe('#mint', () => {
+        for (const { description, tickLower, tickUpper } of [
+          {
+            description: 'around current price',
+            tickLower: startingTick - tickSpacing,
+            tickUpper: startingTick + tickSpacing,
+          },
+          {
+            description: 'below current price',
+            tickLower: startingTick - 2 * tickSpacing,
+            tickUpper: startingTick - tickSpacing,
+          },
+          {
+            description: 'above current price',
+            tickLower: startingTick + tickSpacing,
+            tickUpper: startingTick + 2 * tickSpacing,
+          },
+        ]) {
+          describe(description, () => {
+            it('new position mint first in range', async () => {
+              await snapshotGasCost(mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+            it('add to position existing', async () => {
+              await mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1))
+              await snapshotGasCost(mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+            it('second position in same range', async () => {
+              await mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1))
+              await snapshotGasCost(mint(other.address, tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+            it('add to position after some time passes', async () => {
+              await mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1))
+              await pool.advanceTime(1)
+              await snapshotGasCost(mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+          })
+        }
+      })
+
+      describe('#burn', () => {
+        for (const { description, tickLower, tickUpper } of [
+          {
+            description: 'around current price',
+            tickLower: startingTick - tickSpacing,
+            tickUpper: startingTick + tickSpacing,
+          },
+          {
+            description: 'below current price',
+            tickLower: startingTick - 2 * tickSpacing,
+            tickUpper: startingTick - tickSpacing,
+          },
+          {
+            description: 'above current price',
+            tickLower: startingTick + tickSpacing,
+            tickUpper: startingTick + 2 * tickSpacing,
+          },
+        ]) {
+          describe(description, () => {
+            const liquidityAmount = expandTo18Decimals(1)
+            beforeEach('mint a position', async () => {
+              await mint(wallet.address, tickLower, tickUpper, liquidityAmount)
+            })
+
+            it('burn when only position using ticks', async () => {
+              await snapshotGasCost(pool.burn(tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+            it('partial position burn', async () => {
+              await snapshotGasCost(pool.burn(tickLower, tickUpper, expandTo18Decimals(1).div(2)))
+            })
+            it('entire position burn but other positions are using the ticks', async () => {
+              await mint(other.address, tickLower, tickUpper, expandTo18Decimals(1))
+              await snapshotGasCost(pool.burn(tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+            it('burn entire position after some time passes', async () => {
+              await pool.advanceTime(1)
+              await snapshotGasCost(pool.burn(tickLower, tickUpper, expandTo18Decimals(1)))
+            })
+          })
+        }
+      })
+
+      describe('#poke', () => {
+        const tickLower = startingTick - tickSpacing
+        const tickUpper = startingTick + tickSpacing
+
+        it('best case', async () => {
+          await mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1))
+          await swapExact0For1(expandTo18Decimals(1).div(100), wallet.address)
+          await pool.burn(tickLower, tickUpper, 0)
+          await swapExact0For1(expandTo18Decimals(1).div(100), wallet.address)
+          await snapshotGasCost(pool.burn(tickLower, tickUpper, 0))
+        })
+      })
+
+      describe('#collect', () => {
+        const tickLower = startingTick - tickSpacing
+        const tickUpper = startingTick + tickSpacing
+
+        it('close to worst case', async () => {
+          await mint(wallet.address, tickLower, tickUpper, expandTo18Decimals(1))
+          await swapExact0For1(expandTo18Decimals(1).div(100), wallet.address)
+          await pool.burn(tickLower, tickUpper, 0) // poke to accumulate fees
+          await snapshotGasCost(pool.collect(wallet.address, tickLower, tickUpper, MaxUint128, MaxUint128))
+        })
+      })
+
+      describe('#increaseObservationCardinalityNext', () => {
+        it('grow by 1 slot', async () => {
+          await snapshotGasCost(pool.increaseObservationCardinalityNext(5))
+        })
+        it('no op', async () => {
+          await snapshotGasCost(pool.increaseObservationCardinalityNext(3))
+        })
+      })
+
+      describe('#snapshotCumulativesInside', () => {
+        it('tick inside', async () => {
+          await snapshotGasCost(pool.estimateGas.snapshotCumulativesInside(minTick, maxTick))
+        })
+        it('tick above', async () => {
+          await swapToHigherPrice(MAX_SQRT_RATIO.sub(1), wallet.address)
+          await snapshotGasCost(pool.estimateGas.snapshotCumulativesInside(minTick, maxTick))
+        })
+        it('tick below', async () => {
+          await swapToLowerPrice(MIN_SQRT_RATIO.add(1), wallet.address)
+          await snapshotGasCost(pool.estimateGas.snapshotCumulativesInside(minTick, maxTick))
+        })
+      })
+    })
+  }
+})