@diwantanushh/rapiddex-contracts 1.0.0

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

@@ -0,0 +1,329 @@
+import { ethers } from 'hardhat'
+import { BigNumber } from 'ethers'
+import { TickTest } from '../typechain/TickTest'
+import { expect } from './shared/expect'
+import { FeeAmount, getMaxLiquidityPerTick, TICK_SPACINGS } from './shared/utilities'
+
+const MaxUint128 = BigNumber.from(2).pow(128).sub(1)
+
+const { constants } = ethers
+
+describe('Tick', () => {
+  let tickTest: TickTest
+
+  beforeEach('deploy TickTest', async () => {
+    const tickTestFactory = await ethers.getContractFactory('TickTest')
+    tickTest = (await tickTestFactory.deploy()) as TickTest
+  })
+
+  describe('#tickSpacingToMaxLiquidityPerTick', () => {
+    it('returns the correct value for low fee', async () => {
+      const maxLiquidityPerTick = await tickTest.tickSpacingToMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.LOW])
+      expect(maxLiquidityPerTick).to.eq('1917569901783203986719870431555990') // 110.8 bits
+      expect(maxLiquidityPerTick).to.eq(getMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.LOW]))
+    })
+    it('returns the correct value for medium fee', async () => {
+      const maxLiquidityPerTick = await tickTest.tickSpacingToMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.MEDIUM])
+      expect(maxLiquidityPerTick).to.eq('11505743598341114571880798222544994') // 113.1 bits
+      expect(maxLiquidityPerTick).to.eq(getMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.MEDIUM]))
+    })
+    it('returns the correct value for high fee', async () => {
+      const maxLiquidityPerTick = await tickTest.tickSpacingToMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.HIGH])
+      expect(maxLiquidityPerTick).to.eq('38350317471085141830651933667504588') // 114.7 bits
+      expect(maxLiquidityPerTick).to.eq(getMaxLiquidityPerTick(TICK_SPACINGS[FeeAmount.HIGH]))
+    })
+    it('returns the correct value for entire range', async () => {
+      const maxLiquidityPerTick = await tickTest.tickSpacingToMaxLiquidityPerTick(887272)
+      expect(maxLiquidityPerTick).to.eq(MaxUint128.div(3)) // 126 bits
+      expect(maxLiquidityPerTick).to.eq(getMaxLiquidityPerTick(887272))
+    })
+    it('returns the correct value for 2302', async () => {
+      const maxLiquidityPerTick = await tickTest.tickSpacingToMaxLiquidityPerTick(2302)
+      expect(maxLiquidityPerTick).to.eq('441351967472034323558203122479595605') // 118 bits
+      expect(maxLiquidityPerTick).to.eq(getMaxLiquidityPerTick(2302))
+    })
+  })
+
+  describe('#getFeeGrowthInside', () => {
+    it('returns all for two uninitialized ticks if tick is inside', async () => {
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 0, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(15)
+      expect(feeGrowthInside1X128).to.eq(15)
+    })
+    it('returns 0 for two uninitialized ticks if tick is above', async () => {
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 4, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(0)
+      expect(feeGrowthInside1X128).to.eq(0)
+    })
+    it('returns 0 for two uninitialized ticks if tick is below', async () => {
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, -4, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(0)
+      expect(feeGrowthInside1X128).to.eq(0)
+    })
+
+    it('subtracts upper tick if below', async () => {
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 2,
+        feeGrowthOutside1X128: 3,
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 0, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(13)
+      expect(feeGrowthInside1X128).to.eq(12)
+    })
+
+    it('subtracts lower tick if above', async () => {
+      await tickTest.setTick(-2, {
+        feeGrowthOutside0X128: 2,
+        feeGrowthOutside1X128: 3,
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 0, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(13)
+      expect(feeGrowthInside1X128).to.eq(12)
+    })
+
+    it('subtracts upper and lower tick if inside', async () => {
+      await tickTest.setTick(-2, {
+        feeGrowthOutside0X128: 2,
+        feeGrowthOutside1X128: 3,
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 4,
+        feeGrowthOutside1X128: 1,
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 0, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(9)
+      expect(feeGrowthInside1X128).to.eq(11)
+    })
+
+    it('works correctly with overflow on inside tick', async () => {
+      await tickTest.setTick(-2, {
+        feeGrowthOutside0X128: constants.MaxUint256.sub(3),
+        feeGrowthOutside1X128: constants.MaxUint256.sub(2),
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 3,
+        feeGrowthOutside1X128: 5,
+        liquidityGross: 0,
+        liquidityNet: 0,
+        secondsPerLiquidityOutsideX128: 0,
+        tickCumulativeOutside: 0,
+        secondsOutside: 0,
+        initialized: true,
+      })
+      const { feeGrowthInside0X128, feeGrowthInside1X128 } = await tickTest.getFeeGrowthInside(-2, 2, 0, 15, 15)
+      expect(feeGrowthInside0X128).to.eq(16)
+      expect(feeGrowthInside1X128).to.eq(13)
+    })
+  })
+
+  describe('#update', async () => {
+    it('flips from zero to nonzero', async () => {
+      expect(await tickTest.callStatic.update(0, 0, 1, 0, 0, 0, 0, 0, false, 3)).to.eq(true)
+    })
+    it('does not flip from nonzero to greater nonzero', async () => {
+      await tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, false, 3)
+      expect(await tickTest.callStatic.update(0, 0, 1, 0, 0, 0, 0, 0, false, 3)).to.eq(false)
+    })
+    it('flips from nonzero to zero', async () => {
+      await tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, false, 3)
+      expect(await tickTest.callStatic.update(0, 0, -1, 0, 0, 0, 0, 0, false, 3)).to.eq(true)
+    })
+    it('does not flip from nonzero to lesser nonzero', async () => {
+      await tickTest.update(0, 0, 2, 0, 0, 0, 0, 0, false, 3)
+      expect(await tickTest.callStatic.update(0, 0, -1, 0, 0, 0, 0, 0, false, 3)).to.eq(false)
+    })
+    it('does not flip from nonzero to lesser nonzero', async () => {
+      await tickTest.update(0, 0, 2, 0, 0, 0, 0, 0, false, 3)
+      expect(await tickTest.callStatic.update(0, 0, -1, 0, 0, 0, 0, 0, false, 3)).to.eq(false)
+    })
+    it('reverts if total liquidity gross is greater than max', async () => {
+      await tickTest.update(0, 0, 2, 0, 0, 0, 0, 0, false, 3)
+      await tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, true, 3)
+      await expect(tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, false, 3)).to.be.revertedWith('LO')
+    })
+    it('nets the liquidity based on upper flag', async () => {
+      await tickTest.update(0, 0, 2, 0, 0, 0, 0, 0, false, 10)
+      await tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, true, 10)
+      await tickTest.update(0, 0, 3, 0, 0, 0, 0, 0, true, 10)
+      await tickTest.update(0, 0, 1, 0, 0, 0, 0, 0, false, 10)
+      const { liquidityGross, liquidityNet } = await tickTest.ticks(0)
+      expect(liquidityGross).to.eq(2 + 1 + 3 + 1)
+      expect(liquidityNet).to.eq(2 - 1 - 3 + 1)
+    })
+    it('reverts on overflow liquidity gross', async () => {
+      await tickTest.update(0, 0, MaxUint128.div(2).sub(1), 0, 0, 0, 0, 0, false, MaxUint128)
+      await expect(tickTest.update(0, 0, MaxUint128.div(2).sub(1), 0, 0, 0, 0, 0, false, MaxUint128)).to.be.reverted
+    })
+    it('assumes all growth happens below ticks lte current tick', async () => {
+      await tickTest.update(1, 1, 1, 1, 2, 3, 4, 5, false, MaxUint128)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        secondsPerLiquidityOutsideX128,
+        tickCumulativeOutside,
+        initialized,
+      } = await tickTest.ticks(1)
+      expect(feeGrowthOutside0X128).to.eq(1)
+      expect(feeGrowthOutside1X128).to.eq(2)
+      expect(secondsPerLiquidityOutsideX128).to.eq(3)
+      expect(tickCumulativeOutside).to.eq(4)
+      expect(secondsOutside).to.eq(5)
+      expect(initialized).to.eq(true)
+    })
+    it('does not set any growth fields if tick is already initialized', async () => {
+      await tickTest.update(1, 1, 1, 1, 2, 3, 4, 5, false, MaxUint128)
+      await tickTest.update(1, 1, 1, 6, 7, 8, 9, 10, false, MaxUint128)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        secondsPerLiquidityOutsideX128,
+        tickCumulativeOutside,
+        initialized,
+      } = await tickTest.ticks(1)
+      expect(feeGrowthOutside0X128).to.eq(1)
+      expect(feeGrowthOutside1X128).to.eq(2)
+      expect(secondsPerLiquidityOutsideX128).to.eq(3)
+      expect(tickCumulativeOutside).to.eq(4)
+      expect(secondsOutside).to.eq(5)
+      expect(initialized).to.eq(true)
+    })
+    it('does not set any growth fields for ticks gt current tick', async () => {
+      await tickTest.update(2, 1, 1, 1, 2, 3, 4, 5, false, MaxUint128)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        secondsPerLiquidityOutsideX128,
+        tickCumulativeOutside,
+        initialized,
+      } = await tickTest.ticks(2)
+      expect(feeGrowthOutside0X128).to.eq(0)
+      expect(feeGrowthOutside1X128).to.eq(0)
+      expect(secondsPerLiquidityOutsideX128).to.eq(0)
+      expect(tickCumulativeOutside).to.eq(0)
+      expect(secondsOutside).to.eq(0)
+      expect(initialized).to.eq(true)
+    })
+  })
+
+  // this is skipped because the presence of the method causes slither to fail
+  describe('#clear', async () => {
+    it('deletes all the data in the tick', async () => {
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 1,
+        feeGrowthOutside1X128: 2,
+        liquidityGross: 3,
+        liquidityNet: 4,
+        secondsPerLiquidityOutsideX128: 5,
+        tickCumulativeOutside: 6,
+        secondsOutside: 7,
+        initialized: true,
+      })
+      await tickTest.clear(2)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        secondsPerLiquidityOutsideX128,
+        liquidityGross,
+        tickCumulativeOutside,
+        liquidityNet,
+        initialized,
+      } = await tickTest.ticks(2)
+      expect(feeGrowthOutside0X128).to.eq(0)
+      expect(feeGrowthOutside1X128).to.eq(0)
+      expect(secondsOutside).to.eq(0)
+      expect(secondsPerLiquidityOutsideX128).to.eq(0)
+      expect(tickCumulativeOutside).to.eq(0)
+      expect(liquidityGross).to.eq(0)
+      expect(liquidityNet).to.eq(0)
+      expect(initialized).to.eq(false)
+    })
+  })
+
+  describe('#cross', () => {
+    it('flips the growth variables', async () => {
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 1,
+        feeGrowthOutside1X128: 2,
+        liquidityGross: 3,
+        liquidityNet: 4,
+        secondsPerLiquidityOutsideX128: 5,
+        tickCumulativeOutside: 6,
+        secondsOutside: 7,
+        initialized: true,
+      })
+      await tickTest.cross(2, 7, 9, 8, 15, 10)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        tickCumulativeOutside,
+        secondsPerLiquidityOutsideX128,
+      } = await tickTest.ticks(2)
+      expect(feeGrowthOutside0X128).to.eq(6)
+      expect(feeGrowthOutside1X128).to.eq(7)
+      expect(secondsPerLiquidityOutsideX128).to.eq(3)
+      expect(tickCumulativeOutside).to.eq(9)
+      expect(secondsOutside).to.eq(3)
+    })
+    it('two flips are no op', async () => {
+      await tickTest.setTick(2, {
+        feeGrowthOutside0X128: 1,
+        feeGrowthOutside1X128: 2,
+        liquidityGross: 3,
+        liquidityNet: 4,
+        secondsPerLiquidityOutsideX128: 5,
+        tickCumulativeOutside: 6,
+        secondsOutside: 7,
+        initialized: true,
+      })
+      await tickTest.cross(2, 7, 9, 8, 15, 10)
+      await tickTest.cross(2, 7, 9, 8, 15, 10)
+      const {
+        feeGrowthOutside0X128,
+        feeGrowthOutside1X128,
+        secondsOutside,
+        tickCumulativeOutside,
+        secondsPerLiquidityOutsideX128,
+      } = await tickTest.ticks(2)
+      expect(feeGrowthOutside0X128).to.eq(1)
+      expect(feeGrowthOutside1X128).to.eq(2)
+      expect(secondsPerLiquidityOutsideX128).to.eq(5)
+      expect(tickCumulativeOutside).to.eq(6)
+      expect(secondsOutside).to.eq(7)
+    })
+  })
+})

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

@@ -0,0 +1,227 @@
+import { ethers } from 'hardhat'
+import { TickBitmapTest } from '../typechain/TickBitmapTest'
+import { expect } from './shared/expect'
+import snapshotGasCost from './shared/snapshotGasCost'
+
+describe('TickBitmap', () => {
+  let tickBitmap: TickBitmapTest
+
+  beforeEach('deploy TickBitmapTest', async () => {
+    const tickBitmapTestFactory = await ethers.getContractFactory('TickBitmapTest')
+    tickBitmap = (await tickBitmapTestFactory.deploy()) as TickBitmapTest
+  })
+
+  async function initTicks(ticks: number[]): Promise<void> {
+    for (const tick of ticks) {
+      await tickBitmap.flipTick(tick)
+    }
+  }
+
+  describe('#isInitialized', () => {
+    it('is false at first', async () => {
+      expect(await tickBitmap.isInitialized(1)).to.eq(false)
+    })
+    it('is flipped by #flipTick', async () => {
+      await tickBitmap.flipTick(1)
+      expect(await tickBitmap.isInitialized(1)).to.eq(true)
+    })
+    it('is flipped back by #flipTick', async () => {
+      await tickBitmap.flipTick(1)
+      await tickBitmap.flipTick(1)
+      expect(await tickBitmap.isInitialized(1)).to.eq(false)
+    })
+    it('is not changed by another flip to a different tick', async () => {
+      await tickBitmap.flipTick(2)
+      expect(await tickBitmap.isInitialized(1)).to.eq(false)
+    })
+    it('is not changed by another flip to a different tick on another word', async () => {
+      await tickBitmap.flipTick(1 + 256)
+      expect(await tickBitmap.isInitialized(257)).to.eq(true)
+      expect(await tickBitmap.isInitialized(1)).to.eq(false)
+    })
+  })
+
+  describe('#flipTick', () => {
+    it('flips only the specified tick', async () => {
+      await tickBitmap.flipTick(-230)
+      expect(await tickBitmap.isInitialized(-230)).to.eq(true)
+      expect(await tickBitmap.isInitialized(-231)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-229)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-230 + 256)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-230 - 256)).to.eq(false)
+      await tickBitmap.flipTick(-230)
+      expect(await tickBitmap.isInitialized(-230)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-231)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-229)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-230 + 256)).to.eq(false)
+      expect(await tickBitmap.isInitialized(-230 - 256)).to.eq(false)
+    })
+
+    it('reverts only itself', async () => {
+      await tickBitmap.flipTick(-230)
+      await tickBitmap.flipTick(-259)
+      await tickBitmap.flipTick(-229)
+      await tickBitmap.flipTick(500)
+      await tickBitmap.flipTick(-259)
+      await tickBitmap.flipTick(-229)
+      await tickBitmap.flipTick(-259)
+
+      expect(await tickBitmap.isInitialized(-259)).to.eq(true)
+      expect(await tickBitmap.isInitialized(-229)).to.eq(false)
+    })
+
+    it('gas cost of flipping first tick in word to initialized', async () => {
+      await snapshotGasCost(await tickBitmap.getGasCostOfFlipTick(1))
+    })
+    it('gas cost of flipping second tick in word to initialized', async () => {
+      await tickBitmap.flipTick(0)
+      await snapshotGasCost(await tickBitmap.getGasCostOfFlipTick(1))
+    })
+    it('gas cost of flipping a tick that results in deleting a word', async () => {
+      await tickBitmap.flipTick(0)
+      await snapshotGasCost(await tickBitmap.getGasCostOfFlipTick(0))
+    })
+  })
+
+  describe('#nextInitializedTickWithinOneWord', () => {
+    beforeEach('set up some ticks', async () => {
+      // word boundaries are at multiples of 256
+      await initTicks([-200, -55, -4, 70, 78, 84, 139, 240, 535])
+    })
+
+    describe('lte = false', async () => {
+      it('returns tick to right if at initialized tick', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(78, false)
+        expect(next).to.eq(84)
+        expect(initialized).to.eq(true)
+      })
+      it('returns tick to right if at initialized tick', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(-55, false)
+        expect(next).to.eq(-4)
+        expect(initialized).to.eq(true)
+      })
+
+      it('returns the tick directly to the right', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(77, false)
+        expect(next).to.eq(78)
+        expect(initialized).to.eq(true)
+      })
+      it('returns the tick directly to the right', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(-56, false)
+        expect(next).to.eq(-55)
+        expect(initialized).to.eq(true)
+      })
+
+      it('returns the next words initialized tick if on the right boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(255, false)
+        expect(next).to.eq(511)
+        expect(initialized).to.eq(false)
+      })
+      it('returns the next words initialized tick if on the right boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(-257, false)
+        expect(next).to.eq(-200)
+        expect(initialized).to.eq(true)
+      })
+
+      it('returns the next initialized tick from the next word', async () => {
+        await tickBitmap.flipTick(340)
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(328, false)
+        expect(next).to.eq(340)
+        expect(initialized).to.eq(true)
+      })
+      it('does not exceed boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(508, false)
+        expect(next).to.eq(511)
+        expect(initialized).to.eq(false)
+      })
+      it('skips entire word', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(255, false)
+        expect(next).to.eq(511)
+        expect(initialized).to.eq(false)
+      })
+      it('skips half word', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(383, false)
+        expect(next).to.eq(511)
+        expect(initialized).to.eq(false)
+      })
+
+      it('gas cost on boundary', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(255, false))
+      })
+      it('gas cost just below boundary', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(254, false))
+      })
+      it('gas cost for entire word', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(768, false))
+      })
+    })
+
+    describe('lte = true', () => {
+      it('returns same tick if initialized', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(78, true)
+
+        expect(next).to.eq(78)
+        expect(initialized).to.eq(true)
+      })
+      it('returns tick directly to the left of input tick if not initialized', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(79, true)
+
+        expect(next).to.eq(78)
+        expect(initialized).to.eq(true)
+      })
+      it('will not exceed the word boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(258, true)
+
+        expect(next).to.eq(256)
+        expect(initialized).to.eq(false)
+      })
+      it('at the word boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(256, true)
+
+        expect(next).to.eq(256)
+        expect(initialized).to.eq(false)
+      })
+      it('word boundary less 1 (next initialized tick in next word)', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(72, true)
+
+        expect(next).to.eq(70)
+        expect(initialized).to.eq(true)
+      })
+      it('word boundary', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(-257, true)
+
+        expect(next).to.eq(-512)
+        expect(initialized).to.eq(false)
+      })
+      it('entire empty word', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(1023, true)
+
+        expect(next).to.eq(768)
+        expect(initialized).to.eq(false)
+      })
+      it('halfway through empty word', async () => {
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(900, true)
+
+        expect(next).to.eq(768)
+        expect(initialized).to.eq(false)
+      })
+      it('boundary is initialized', async () => {
+        await tickBitmap.flipTick(329)
+        const { next, initialized } = await tickBitmap.nextInitializedTickWithinOneWord(456, true)
+
+        expect(next).to.eq(329)
+        expect(initialized).to.eq(true)
+      })
+
+      it('gas cost on boundary', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(256, true))
+      })
+      it('gas cost just below boundary', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(255, true))
+      })
+      it('gas cost for entire word', async () => {
+        await snapshotGasCost(await tickBitmap.getGasCostOfNextInitializedTickWithinOneWord(1024, true))
+      })
+    })
+  })
+})