@diwantanushh/rapiddex-contracts 1.0.0

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

@@ -0,0 +1,168 @@
+import { ethers, waffle } from 'hardhat'
+import { BigNumber, constants, Contract, ContractTransaction } from 'ethers'
+import {
+  IWETH9,
+  MockTimeNonfungiblePositionManager,
+  MockTimeSwapRouter,
+  PairFlash,
+  IUniswapV3Pool,
+  TestERC20,
+  TestERC20Metadata,
+  IUniswapV3Factory,
+  NFTDescriptor,
+  Quoter,
+  SwapRouter,
+} from '../typechain'
+import completeFixture from './shared/completeFixture'
+import { FeeAmount, MaxUint128, TICK_SPACINGS } from './shared/constants'
+import { encodePriceSqrt } from './shared/encodePriceSqrt'
+import snapshotGasCost from './shared/snapshotGasCost'
+
+import { expect } from './shared/expect'
+import { getMaxTick, getMinTick } from './shared/ticks'
+import { computePoolAddress } from './shared/computePoolAddress'
+
+describe('PairFlash test', () => {
+  const provider = waffle.provider
+  const wallets = waffle.provider.getWallets()
+  const wallet = wallets[0]
+
+  let flash: PairFlash
+  let nft: MockTimeNonfungiblePositionManager
+  let token0: TestERC20
+  let token1: TestERC20
+  let factory: IUniswapV3Factory
+  let quoter: Quoter
+
+  async function createPool(tokenAddressA: string, tokenAddressB: string, fee: FeeAmount, price: BigNumber) {
+    if (tokenAddressA.toLowerCase() > tokenAddressB.toLowerCase())
+      [tokenAddressA, tokenAddressB] = [tokenAddressB, tokenAddressA]
+
+    await nft.createAndInitializePoolIfNecessary(tokenAddressA, tokenAddressB, fee, price)
+
+    const liquidityParams = {
+      token0: tokenAddressA,
+      token1: tokenAddressB,
+      fee: fee,
+      tickLower: getMinTick(TICK_SPACINGS[fee]),
+      tickUpper: getMaxTick(TICK_SPACINGS[fee]),
+      recipient: wallet.address,
+      amount0Desired: 1000000,
+      amount1Desired: 1000000,
+      amount0Min: 0,
+      amount1Min: 0,
+      deadline: 1,
+    }
+
+    return nft.mint(liquidityParams)
+  }
+
+  const flashFixture = async () => {
+    const { router, tokens, factory, weth9, nft } = await completeFixture(wallets, provider)
+    const token0 = tokens[0]
+    const token1 = tokens[1]
+
+    const flashContractFactory = await ethers.getContractFactory('PairFlash')
+    const flash = (await flashContractFactory.deploy(router.address, factory.address, weth9.address)) as PairFlash
+
+    const quoterFactory = await ethers.getContractFactory('Quoter')
+    const quoter = (await quoterFactory.deploy(factory.address, weth9.address)) as Quoter
+
+    return {
+      token0,
+      token1,
+      flash,
+      factory,
+      weth9,
+      nft,
+      quoter,
+      router,
+    }
+  }
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    loadFixture = waffle.createFixtureLoader(wallets)
+  })
+
+  beforeEach('load fixture', async () => {
+    ;({ factory, token0, token1, flash, nft, quoter } = await loadFixture(flashFixture))
+
+    await token0.approve(nft.address, MaxUint128)
+    await token1.approve(nft.address, MaxUint128)
+    await createPool(token0.address, token1.address, FeeAmount.LOW, encodePriceSqrt(5, 10))
+    await createPool(token0.address, token1.address, FeeAmount.MEDIUM, encodePriceSqrt(1, 1))
+    await createPool(token0.address, token1.address, FeeAmount.HIGH, encodePriceSqrt(20, 10))
+  })
+
+  describe('flash', () => {
+    it('test correct transfer events', async () => {
+      //choose amountIn to test
+      const amount0In = 1000
+      const amount1In = 1000
+
+      const fee0 = Math.ceil((amount0In * FeeAmount.MEDIUM) / 1000000)
+      const fee1 = Math.ceil((amount1In * FeeAmount.MEDIUM) / 1000000)
+
+      const flashParams = {
+        token0: token0.address,
+        token1: token1.address,
+        fee1: FeeAmount.MEDIUM,
+        amount0: amount0In,
+        amount1: amount1In,
+        fee2: FeeAmount.LOW,
+        fee3: FeeAmount.HIGH,
+      }
+      // pool1 is the borrow pool
+      const pool1 = computePoolAddress(factory.address, [token0.address, token1.address], FeeAmount.MEDIUM)
+      const pool2 = computePoolAddress(factory.address, [token0.address, token1.address], FeeAmount.LOW)
+      const pool3 = computePoolAddress(factory.address, [token0.address, token1.address], FeeAmount.HIGH)
+
+      const expectedAmountOut0 = await quoter.callStatic.quoteExactInputSingle(
+        token1.address,
+        token0.address,
+        FeeAmount.LOW,
+        amount1In,
+        encodePriceSqrt(20, 10)
+      )
+      const expectedAmountOut1 = await quoter.callStatic.quoteExactInputSingle(
+        token0.address,
+        token1.address,
+        FeeAmount.HIGH,
+        amount0In,
+        encodePriceSqrt(5, 10)
+      )
+
+      await expect(flash.initFlash(flashParams))
+        .to.emit(token0, 'Transfer')
+        .withArgs(pool1, flash.address, amount0In)
+        .to.emit(token1, 'Transfer')
+        .withArgs(pool1, flash.address, amount1In)
+        .to.emit(token0, 'Transfer')
+        .withArgs(pool2, flash.address, expectedAmountOut0)
+        .to.emit(token1, 'Transfer')
+        .withArgs(pool3, flash.address, expectedAmountOut1)
+        .to.emit(token0, 'Transfer')
+        .withArgs(flash.address, wallet.address, expectedAmountOut0.toNumber() - amount0In - fee0)
+        .to.emit(token1, 'Transfer')
+        .withArgs(flash.address, wallet.address, expectedAmountOut1.toNumber() - amount1In - fee1)
+    })
+
+    it('gas', async () => {
+      const amount0In = 1000
+      const amount1In = 1000
+
+      const flashParams = {
+        token0: token0.address,
+        token1: token1.address,
+        fee1: FeeAmount.MEDIUM,
+        amount0: amount0In,
+        amount1: amount1In,
+        fee2: FeeAmount.LOW,
+        fee3: FeeAmount.HIGH,
+      }
+      await snapshotGasCost(flash.initFlash(flashParams))
+    })
+  })
+})

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

@@ -0,0 +1,90 @@
+import { waffle, ethers } from 'hardhat'
+import { FeeAmount } from './shared/constants'
+
+import { expect } from './shared/expect'
+
+import { PathTest } from '../typechain'
+import { decodePath, encodePath } from './shared/path'
+
+import snapshotGasCost from './shared/snapshotGasCost'
+
+describe('Path', () => {
+  let path: PathTest
+
+  let tokenAddresses = [
+    '0x5FC8d32690cc91D4c39d9d3abcBD16989F875707',
+    '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
+    '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9',
+  ]
+  let fees = [FeeAmount.MEDIUM, FeeAmount.MEDIUM]
+
+  const pathTestFixture = async () => {
+    const pathTestFactory = await ethers.getContractFactory('PathTest')
+    return (await pathTestFactory.deploy()) as PathTest
+  }
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    loadFixture = waffle.createFixtureLoader(await (ethers as any).getSigners())
+  })
+
+  beforeEach('deploy PathTest', async () => {
+    path = await loadFixture(pathTestFixture)
+  })
+
+  it('js encoding works as expected', async () => {
+    let expectedPath =
+      '0x' +
+      tokenAddresses
+        .slice(0, 2)
+        .map((tokenAddress) => tokenAddress.slice(2).toLowerCase())
+        .join('000bb8')
+    expect(encodePath(tokenAddresses.slice(0, 2), fees.slice(0, 1))).to.eq(expectedPath)
+
+    expectedPath = '0x' + tokenAddresses.map((tokenAddress) => tokenAddress.slice(2).toLowerCase()).join('000bb8')
+    expect(encodePath(tokenAddresses, fees)).to.eq(expectedPath)
+  })
+
+  it('js decoding works as expected', async () => {
+    const encodedPath = encodePath(tokenAddresses, fees)
+    const [decodedTokens, decodedFees] = decodePath(encodedPath)
+    expect(decodedTokens).to.deep.eq(tokenAddresses)
+    expect(decodedFees).to.deep.eq(fees)
+  })
+
+  describe('#hasMultiplePools / #decodeFirstPool / #skipToken / #getFirstPool', () => {
+    const encodedPath = encodePath(tokenAddresses, fees)
+
+    it('works on first pool', async () => {
+      expect(await path.hasMultiplePools(encodedPath)).to.be.true
+
+      const firstPool = await path.decodeFirstPool(encodedPath)
+      expect(firstPool.tokenA).to.be.eq(tokenAddresses[0])
+      expect(firstPool.tokenB).to.be.eq(tokenAddresses[1])
+      expect(firstPool.fee).to.be.eq(FeeAmount.MEDIUM)
+
+      expect(await path.decodeFirstPool(await path.getFirstPool(encodedPath))).to.deep.eq(firstPool)
+    })
+
+    const offset = 20 + 3
+
+    it('skips 1 item', async () => {
+      const skipped = await path.skipToken(encodedPath)
+      expect(skipped).to.be.eq('0x' + encodedPath.slice(2 + offset * 2))
+
+      expect(await path.hasMultiplePools(skipped)).to.be.false
+
+      const { tokenA, tokenB, fee: decodedFee } = await path.decodeFirstPool(skipped)
+      expect(tokenA).to.be.eq(tokenAddresses[1])
+      expect(tokenB).to.be.eq(tokenAddresses[2])
+      expect(decodedFee).to.be.eq(FeeAmount.MEDIUM)
+    })
+  })
+
+  it('gas cost', async () => {
+    await snapshotGasCost(
+      path.getGasCostOfDecodeFirstPool(encodePath([tokenAddresses[0], tokenAddresses[1]], [FeeAmount.MEDIUM]))
+    )
+  })
+})

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

@@ -0,0 +1,56 @@
+import { Contract } from 'ethers'
+import { waffle, ethers } from 'hardhat'
+
+import { Fixture } from 'ethereum-waffle'
+import { PeripheryImmutableStateTest, IWETH9 } from '../typechain'
+import { expect } from './shared/expect'
+import { v3RouterFixture } from './shared/externalFixtures'
+
+describe('PeripheryImmutableState', () => {
+  const nonfungiblePositionManagerFixture: Fixture<{
+    weth9: IWETH9
+    factory: Contract
+    state: PeripheryImmutableStateTest
+  }> = async (wallets, provider) => {
+    const { weth9, factory } = await v3RouterFixture(wallets, provider)
+
+    const stateFactory = await ethers.getContractFactory('PeripheryImmutableStateTest')
+    const state = (await stateFactory.deploy(factory.address, weth9.address)) as PeripheryImmutableStateTest
+
+    return {
+      weth9,
+      factory,
+      state,
+    }
+  }
+
+  let factory: Contract
+  let weth9: IWETH9
+  let state: PeripheryImmutableStateTest
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    loadFixture = waffle.createFixtureLoader(await (ethers as any).getSigners())
+  })
+
+  beforeEach('load fixture', async () => {
+    ;({ state, weth9, factory } = await loadFixture(nonfungiblePositionManagerFixture))
+  })
+
+  it('bytecode size', async () => {
+    expect(((await state.provider.getCode(state.address)).length - 2) / 2).to.matchSnapshot()
+  })
+
+  describe('#WETH9', () => {
+    it('points to WETH9', async () => {
+      expect(await state.WETH9()).to.eq(weth9.address)
+    })
+  })
+
+  describe('#factory', () => {
+    it('points to v3 core factory', async () => {
+      expect(await state.factory()).to.eq(factory.address)
+    })
+  })
+})

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

@@ -0,0 +1,72 @@
+import { constants } from 'ethers'
+import { waffle, ethers } from 'hardhat'
+
+import { PoolAddressTest } from '../typechain'
+import { POOL_BYTECODE_HASH } from './shared/computePoolAddress'
+import { expect } from './shared/expect'
+import snapshotGasCost from './shared/snapshotGasCost'
+
+describe('PoolAddress', () => {
+  let poolAddress: PoolAddressTest
+
+  const poolAddressTestFixture = async () => {
+    const poolAddressTestFactory = await ethers.getContractFactory('PoolAddressTest')
+    return (await poolAddressTestFactory.deploy()) as PoolAddressTest
+  }
+
+  let loadFixture: ReturnType<typeof waffle.createFixtureLoader>
+
+  before('create fixture loader', async () => {
+    loadFixture = waffle.createFixtureLoader(await (ethers as any).getSigners())
+  })
+
+  beforeEach('deploy PoolAddressTest', async () => {
+    poolAddress = await loadFixture(poolAddressTestFixture)
+  })
+
+  describe('#POOL_INIT_CODE_HASH', () => {
+    it('equals the hash of the pool bytecode', async () => {
+      expect(await poolAddress.POOL_INIT_CODE_HASH()).to.eq(POOL_BYTECODE_HASH)
+    })
+  })
+
+  describe('#computeAddress', () => {
+    it('all arguments equal zero', async () => {
+      await expect(poolAddress.computeAddress(constants.AddressZero, constants.AddressZero, constants.AddressZero, 0))
+        .to.be.reverted
+    })
+
+    it('matches example from core repo', async () => {
+      expect(
+        await poolAddress.computeAddress(
+          '0x5FbDB2315678afecb367f032d93F642f64180aa3',
+          '0x1000000000000000000000000000000000000000',
+          '0x2000000000000000000000000000000000000000',
+          250
+        )
+      ).to.matchSnapshot()
+    })
+
+    it('token argument order cannot be in reverse', async () => {
+      await expect(
+        poolAddress.computeAddress(
+          '0x5FbDB2315678afecb367f032d93F642f64180aa3',
+          '0x2000000000000000000000000000000000000000',
+          '0x1000000000000000000000000000000000000000',
+          3000
+        )
+      ).to.be.reverted
+    })
+
+    it('gas cost', async () => {
+      await snapshotGasCost(
+        poolAddress.getGasCostOfComputeAddress(
+          '0x5FbDB2315678afecb367f032d93F642f64180aa3',
+          '0x1000000000000000000000000000000000000000',
+          '0x2000000000000000000000000000000000000000',
+          3000
+        )
+      )
+    })
+  })
+})

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

@@ -0,0 +1,280 @@
+import { waffle, ethers, artifacts } from 'hardhat'
+
+import { expect } from './shared/expect'
+
+import { PoolTicksCounterTest } from '../typechain'
+import { deployMockContract, Fixture, MockContract } from 'ethereum-waffle'
+import { Artifact } from 'hardhat/types'
+
+describe('PoolTicksCounter', () => {
+  const TICK_SPACINGS = [200, 60, 10]
+
+  TICK_SPACINGS.forEach((TICK_SPACING) => {
+    let PoolTicksCounter: PoolTicksCounterTest
+    let pool: MockContract
+    let PoolAbi: Artifact
+
+    // Bit index to tick
+    const bitIdxToTick = (idx: number, page = 0) => {
+      return idx * TICK_SPACING + page * 256 * TICK_SPACING
+    }
+
+    before(async () => {
+      const wallets = await (ethers as any).getSigners()
+      PoolAbi = await artifacts.readArtifact('IUniswapV3Pool')
+      const poolTicksHelperFactory = await ethers.getContractFactory('PoolTicksCounterTest')
+      PoolTicksCounter = (await poolTicksHelperFactory.deploy()) as PoolTicksCounterTest
+      pool = await deployMockContract(wallets[0], PoolAbi.abi)
+      await pool.mock.tickSpacing.returns(TICK_SPACING)
+    })
+
+    describe(`[Tick Spacing: ${TICK_SPACING}]: tick after is bigger`, async () => {
+      it('same tick initialized', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100) // 1100
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(2)
+        )
+        expect(result).to.be.eq(1)
+      })
+
+      it('same tick not-initialized', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100) // 1100
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(1),
+          bitIdxToTick(1)
+        )
+        expect(result).to.be.eq(0)
+      })
+
+      it('same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100) // 1100
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(0),
+          bitIdxToTick(255)
+        )
+        expect(result).to.be.eq(2)
+      })
+
+      it('multiple pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100) // 1100
+        await pool.mock.tickBitmap.withArgs(1).returns(0b1101) // 1101
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(0),
+          bitIdxToTick(255, 1)
+        )
+        expect(result).to.be.eq(5)
+      })
+
+      it('counts all ticks in a page except ending tick', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(ethers.constants.MaxUint256)
+        await pool.mock.tickBitmap.withArgs(1).returns(0x0)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(0),
+          bitIdxToTick(255, 1)
+        )
+        expect(result).to.be.eq(255)
+      })
+
+      it('counts ticks to left of start and right of end on same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1111000100001111)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(8),
+          bitIdxToTick(255)
+        )
+        expect(result).to.be.eq(4)
+      })
+
+      it('counts ticks to left of start and right of end across on multiple pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1111000100001111)
+        await pool.mock.tickBitmap.withArgs(1).returns(0b1111000100001111)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(8),
+          bitIdxToTick(8, 1)
+        )
+        expect(result).to.be.eq(9)
+      })
+
+      it('counts ticks when before and after are initialized on same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        const startingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(255)
+        )
+        expect(startingTickInit).to.be.eq(5)
+        const endingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(0),
+          bitIdxToTick(3)
+        )
+        expect(endingTickInit).to.be.eq(2)
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(5)
+        )
+        expect(bothInit).to.be.eq(3)
+      })
+
+      it('counts ticks when before and after are initialized on multiple page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        await pool.mock.tickBitmap.withArgs(1).returns(0b11111100)
+        const startingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(255)
+        )
+        expect(startingTickInit).to.be.eq(5)
+        const endingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(0),
+          bitIdxToTick(3, 1)
+        )
+        expect(endingTickInit).to.be.eq(8)
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(5, 1)
+        )
+        expect(bothInit).to.be.eq(9)
+      })
+
+      it('counts ticks with lots of pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        await pool.mock.tickBitmap.withArgs(1).returns(0b11111111)
+        await pool.mock.tickBitmap.withArgs(2).returns(0x0)
+        await pool.mock.tickBitmap.withArgs(3).returns(0x0)
+        await pool.mock.tickBitmap.withArgs(4).returns(0b11111100)
+
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(4),
+          bitIdxToTick(5, 4)
+        )
+        expect(bothInit).to.be.eq(15)
+      })
+    })
+
+    describe(`[Tick Spacing: ${TICK_SPACING}]: tick after is smaller`, async () => {
+      it('same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(255),
+          bitIdxToTick(0)
+        )
+        expect(result).to.be.eq(2)
+      })
+
+      it('multiple pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1100)
+        await pool.mock.tickBitmap.withArgs(-1).returns(0b1100)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(255),
+          bitIdxToTick(0, -1)
+        )
+        expect(result).to.be.eq(4)
+      })
+
+      it('counts all ticks in a page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(ethers.constants.MaxUint256)
+        await pool.mock.tickBitmap.withArgs(-1).returns(0x0)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(255),
+          bitIdxToTick(0, -1)
+        )
+        expect(result).to.be.eq(256)
+      })
+
+      it('counts ticks to right of start and left of end on same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1111000100001111)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(15),
+          bitIdxToTick(2)
+        )
+        expect(result).to.be.eq(6)
+      })
+
+      it('counts ticks to right of start and left of end on multiple pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b1111000100001111)
+        await pool.mock.tickBitmap.withArgs(-1).returns(0b1111000100001111)
+        const result = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(8),
+          bitIdxToTick(8, -1)
+        )
+        expect(result).to.be.eq(9)
+      })
+
+      it('counts ticks when before and after are initialized on same page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        const startingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(3),
+          bitIdxToTick(0)
+        )
+        expect(startingTickInit).to.be.eq(2)
+        const endingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(255),
+          bitIdxToTick(2)
+        )
+        expect(endingTickInit).to.be.eq(5)
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(5),
+          bitIdxToTick(2)
+        )
+        expect(bothInit).to.be.eq(3)
+      })
+
+      it('counts ticks when before and after are initialized on multiple page', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        await pool.mock.tickBitmap.withArgs(-1).returns(0b11111100)
+        const startingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(3, -1)
+        )
+        expect(startingTickInit).to.be.eq(5)
+        const endingTickInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(5),
+          bitIdxToTick(255, -1)
+        )
+        expect(endingTickInit).to.be.eq(4)
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(2),
+          bitIdxToTick(5, -1)
+        )
+        expect(bothInit).to.be.eq(3)
+      })
+
+      it('counts ticks with lots of pages', async () => {
+        await pool.mock.tickBitmap.withArgs(0).returns(0b11111100)
+        await pool.mock.tickBitmap.withArgs(-1).returns(0xff)
+        await pool.mock.tickBitmap.withArgs(-2).returns(0x0)
+        await pool.mock.tickBitmap.withArgs(-3).returns(0x0)
+        await pool.mock.tickBitmap.withArgs(-4).returns(0b11111100)
+        const bothInit = await PoolTicksCounter.countInitializedTicksCrossed(
+          pool.address,
+          bitIdxToTick(3),
+          bitIdxToTick(6, -4)
+        )
+        expect(bothInit).to.be.eq(11)
+      })
+    })
+  })
+})