sushi 6.0.12 → 6.0.14

package/evm/pool/sushiswap-v3/utils/maxLiquidityForAmounts.ts

@@ -0,0 +1,116 @@
+import type { BigintIsh } from '../../../../generic/index.js'
+
+import { Q96 } from '../internalConstants.js'
+
+/**
+ * Returns an imprecise maximum amount of liquidity received for a given amount of token 0.
+ * This function is available to accommodate LiquidityAmounts#getLiquidityForAmount0 in the v3 periphery,
+ * which could be more precise by at least 32 bits by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits. This imprecise calculation will likely be replaced in a future
+ * v3 router contract.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, imprecise
+ */
+function maxLiquidityForAmount0Imprecise(
+  sqrtRatioAX96: bigint,
+  sqrtRatioBX96: bigint,
+  amount0: BigintIsh,
+): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+  }
+  const intermediate = (sqrtRatioAX96 * sqrtRatioBX96) / Q96
+  return (
+    (BigInt(amount0.toString()) * intermediate) /
+    (sqrtRatioBX96 - sqrtRatioAX96)
+  )
+}
+
+/**
+ * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, precise
+ */
+function maxLiquidityForAmount0Precise(
+  sqrtRatioAX96: bigint,
+  sqrtRatioBX96: bigint,
+  amount0: BigintIsh,
+): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+  }
+
+  const numerator = BigInt(amount0.toString()) * sqrtRatioAX96 * sqrtRatioBX96
+  const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96)
+
+  return numerator / denominator
+}
+
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token1
+ * @param sqrtRatioAX96 The price at the lower tick boundary
+ * @param sqrtRatioBX96 The price at the upper tick boundary
+ * @param amount1 The token1 amount
+ * @returns liquidity for amount1
+ */
+function maxLiquidityForAmount1(
+  sqrtRatioAX96: bigint,
+  sqrtRatioBX96: bigint,
+  amount1: BigintIsh,
+): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+  }
+  return (BigInt(amount1.toString()) * Q96) / (sqrtRatioBX96 - sqrtRatioAX96)
+}
+
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @param amount0 token0 amount
+ * @param amount1 token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+export function maxLiquidityForAmounts(
+  sqrtRatioCurrentX96: bigint,
+  sqrtRatioAX96: bigint,
+  sqrtRatioBX96: bigint,
+  amount0: BigintIsh,
+  amount1: BigintIsh,
+  useFullPrecision: boolean,
+): bigint {
+  if (sqrtRatioAX96 > sqrtRatioBX96) {
+    ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+  }
+
+  const maxLiquidityForAmount0 = useFullPrecision
+    ? maxLiquidityForAmount0Precise
+    : maxLiquidityForAmount0Imprecise
+
+  if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
+    return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0)
+  } else if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
+    const liquidity0 = maxLiquidityForAmount0(
+      sqrtRatioCurrentX96,
+      sqrtRatioBX96,
+      amount0,
+    )
+    const liquidity1 = maxLiquidityForAmount1(
+      sqrtRatioAX96,
+      sqrtRatioCurrentX96,
+      amount1,
+    )
+    return liquidity0 < liquidity1 ? liquidity0 : liquidity1
+  } else {
+    return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1)
+  }
+}

package/evm/pool/sushiswap-v3/utils/misc.ts

@@ -0,0 +1,143 @@
+import type { Price } from '../../../../generic/currency/price.js'
+import type { EvmCurrency } from '../../../currency/currency.js'
+
+/**
+ * Calculate captial efficiency of the given price range
+ * @param priceCurrent Current price
+ * @param priceLower Lower price boundary
+ * @param priceUpper Upper price boundary
+ * @returns Capitial efficiency, i.e., using the same amount of cash, the amount of liquidity obtained by a position
+ * with the given price range v.s. that obtained by a full-range position.
+ */
+export function getCapitalEfficiency(
+  priceCurrent: Price<EvmCurrency, EvmCurrency>,
+  priceLower: Price<EvmCurrency, EvmCurrency>,
+  priceUpper: Price<EvmCurrency, EvmCurrency>,
+): number {
+  const priceBounded = priceCurrent.gt(priceUpper)
+    ? priceUpper
+    : priceCurrent.lt(priceLower)
+      ? priceLower
+      : priceCurrent
+  const sqrtPBounded = Math.sqrt(priceBounded.toNumber())
+  const sqrtPLower = Math.sqrt(priceLower.toNumber())
+  const sqrtPUpper = Math.sqrt(priceUpper.toNumber())
+
+  const priceNow = priceCurrent.toNumber()
+  const denom =
+    priceNow * (1 / sqrtPBounded - 1 / sqrtPUpper) + (sqrtPBounded - sqrtPLower)
+  const num = 2 * Math.sqrt(priceNow)
+  return num / denom
+}
+
+/**
+ * Calculate the weights of the two tokens in a position with the given price range in terms of cash value
+ * @param priceCurrent Current price
+ * @param priceLower Lower price boundary
+ * @param priceUpper Upper price boundary
+ * @returns [token0's weight, token1's weight] in terms of cash value.
+ */
+export function getTokenRatio(
+  priceCurrent: Price<EvmCurrency, EvmCurrency>,
+  priceLower: Price<EvmCurrency, EvmCurrency>,
+  priceUpper: Price<EvmCurrency, EvmCurrency>,
+): [number, number] {
+  if (priceCurrent.gt(priceUpper) || priceCurrent.eq(priceUpper)) return [0, 1]
+  if (priceCurrent.lt(priceLower) || priceCurrent.eq(priceLower)) return [1, 0]
+
+  const a = priceLower.asFraction.mul(priceUpper).toNumber()
+  const b = priceCurrent.asFraction.mul(priceUpper).toNumber()
+  const p = priceCurrent.asFraction.toNumber()
+
+  const w0 = 1 / ((Math.sqrt(a) - Math.sqrt(b)) / (p - Math.sqrt(b)) + 1)
+  const w1 = 1 - w0
+  return [w0, w1]
+}
+
+const MIN_SQRT_PRICE_APPROX = 2 ** -56
+const MAX_SQRT_PRICE_APPROX = 2 ** 56
+
+const getPriceLowerWithTokenRatio = (
+  priceCurrent: number,
+  priceUpper: number,
+  weight0: number,
+): number => {
+  if (priceCurrent >= priceUpper) throw new Error('invalid inputs')
+
+  const z = (1 / weight0 - 1) * priceCurrent
+  const sqrtP = Math.sqrt(priceCurrent)
+  const sqrtPLower = sqrtP - z * (1 / sqrtP - 1 / Math.sqrt(priceUpper))
+  return Math.max(sqrtPLower, MIN_SQRT_PRICE_APPROX) ** 2
+}
+
+const getPriceUpperWithTokenRatio = (
+  priceCurrent: number,
+  priceLower: number,
+  weight0: number,
+): number => {
+  if (priceLower >= priceCurrent) throw new Error('invalid inputs')
+
+  const z = (1 / weight0 - 1) * priceCurrent
+  const sqrtP = Math.sqrt(priceCurrent)
+  const denom = z - (sqrtP - Math.sqrt(priceLower)) * sqrtP
+  if (denom <= 0) return MAX_SQRT_PRICE_APPROX ** 2
+  const sqrtUpper = (z * sqrtP) / denom
+  return Math.min(sqrtUpper, MAX_SQRT_PRICE_APPROX) ** 2
+}
+
+/**
+ * Given a price range, we alter the range to fit a desired token weight.
+ * Note that the resulted price range has not been snapped to fit tick-spacing.
+ */
+export const getPriceRangeWithTokenRatio = (
+  priceCurrent: number,
+  priceLower: number,
+  priceUpper: number,
+  independentBound: 'LOWER' | 'UPPER',
+  weight0: number,
+): [number, number] => {
+  if (weight0 === 1) {
+    return [
+      Math.max(priceLower, priceCurrent),
+      Math.max(priceUpper, priceCurrent),
+    ]
+  }
+  if (weight0 === 0) {
+    return [
+      Math.min(priceLower, priceCurrent),
+      Math.min(priceUpper, priceCurrent),
+    ]
+  }
+
+  // flipped
+  if (
+    weight0 < 1 &&
+    priceLower > priceCurrent &&
+    independentBound === 'LOWER'
+  ) {
+    independentBound = 'UPPER'
+    priceUpper = priceLower
+    priceLower = Number.NaN
+  }
+  if (
+    weight0 > 0 &&
+    priceUpper < priceCurrent &&
+    independentBound === 'UPPER'
+  ) {
+    independentBound = 'LOWER'
+    priceLower = priceUpper
+    priceUpper = Number.NaN
+  }
+
+  if (independentBound === 'LOWER') {
+    return [
+      priceLower,
+      getPriceUpperWithTokenRatio(priceCurrent, priceLower, weight0),
+    ]
+  } else {
+    return [
+      getPriceLowerWithTokenRatio(priceCurrent, priceUpper, weight0),
+      priceUpper,
+    ]
+  }
+}

package/evm/pool/sushiswap-v3/utils/mostSignificantBit.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import { MAX_UINT256 } from '../../../../generic/math/constants.js'
+import { mostSignificantBit } from './mostSignificantBit.js'
+
+describe('mostSignificantBit', () => {
+  it('throws for zero', () => {
+    expect(() => mostSignificantBit(0n)).toThrow('ZERO')
+  })
+  it('correct value for every power of 2', () => {
+    for (let i = 1; i < 256; i++) {
+      const x = 2n ** BigInt(i)
+      expect(mostSignificantBit(x)).toEqual(i)
+    }
+  })
+  it('correct value for every power of 2 - 1', () => {
+    for (let i = 2; i < 256; i++) {
+      const x = 2n ** BigInt(i) - 1n
+      expect(mostSignificantBit(x)).toEqual(i - 1)
+    }
+  })
+
+  it('succeeds for MaxUint256', () => {
+    expect(mostSignificantBit(MAX_UINT256)).toEqual(255)
+  })
+
+  it('throws for MaxUint256 + 1', () => {
+    expect(() => mostSignificantBit(MAX_UINT256 + 1n)).toThrow('MAX')
+  })
+})

package/evm/pool/sushiswap-v3/utils/mostSignificantBit.ts

@@ -0,0 +1,20 @@
+import invariant from 'tiny-invariant'
+import { MAX_UINT256 } from '../../../../generic/math/constants.js'
+
+const POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map(
+  (pow: number): [number, bigint] => [pow, 2n ** BigInt(pow)],
+)
+
+export function mostSignificantBit(x: bigint): number {
+  invariant(x > 0n, 'ZERO')
+  invariant(x <= MAX_UINT256, 'MAX')
+
+  let msb = 0
+  for (const [power, min] of POWERS_OF_2) {
+    if (x >= min) {
+      x = x >> BigInt(power)
+      msb += power
+    }
+  }
+  return msb
+}

package/evm/pool/sushiswap-v3/utils/nearestUsableTick.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { nearestUsableTick } from './nearestUsableTick.js'
+import { TickMath } from './tickMath.js'
+
+describe('#nearestUsableTick', () => {
+  it('throws if tickSpacing is 0', () => {
+    expect(() => nearestUsableTick(1, 0)).toThrow('TICK_SPACING')
+  })
+
+  it('throws if tickSpacing is negative', () => {
+    expect(() => nearestUsableTick(1, -5)).toThrow('TICK_SPACING')
+  })
+
+  it('throws if either is non-integer', () => {
+    expect(() => nearestUsableTick(1.5, 1)).toThrow('INTEGERS')
+    expect(() => nearestUsableTick(1, 1.5)).toThrow('INTEGERS')
+  })
+
+  it('throws if tick is greater than TickMath.MAX_TICK', () => {
+    expect(() => nearestUsableTick(TickMath.MAX_TICK + 1, 1)).toThrow(
+      'TICK_BOUND',
+    )
+    expect(() => nearestUsableTick(TickMath.MIN_TICK - 1, 1)).toThrow(
+      'TICK_BOUND',
+    )
+  })
+
+  it('rounds at positive half', () => {
+    expect(nearestUsableTick(5, 10)).toEqual(10)
+  })
+
+  it('rounds down below positive half', () => {
+    expect(nearestUsableTick(4, 10)).toEqual(0)
+  })
+
+  it('rounds up for negative half', () => {
+    expect(nearestUsableTick(-5, 10)).toEqual(-0)
+  })
+
+  it('rounds up for negative half', () => {
+    expect(nearestUsableTick(-6, 10)).toEqual(-10)
+  })
+
+  it('cannot round past MIN_TICK', () => {
+    expect(
+      nearestUsableTick(TickMath.MIN_TICK, TickMath.MAX_TICK / 2 + 100),
+    ).toEqual(-(TickMath.MAX_TICK / 2 + 100))
+  })
+
+  it('cannot round past MAX_TICK', () => {
+    expect(
+      nearestUsableTick(TickMath.MAX_TICK, TickMath.MAX_TICK / 2 + 100),
+    ).toEqual(TickMath.MAX_TICK / 2 + 100)
+  })
+})

package/evm/pool/sushiswap-v3/utils/nearestUsableTick.ts

@@ -0,0 +1,20 @@
+import invariant from 'tiny-invariant'
+import { TickMath } from './tickMath.js'
+
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
+ */
+export function nearestUsableTick(tick: number, tickSpacing: number) {
+  invariant(Number.isInteger(tick) && Number.isInteger(tickSpacing), 'INTEGERS')
+  invariant(tickSpacing > 0, 'TICK_SPACING')
+  invariant(
+    tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK,
+    'TICK_BOUND',
+  )
+  const rounded = Math.round(tick / tickSpacing) * tickSpacing
+  if (rounded < TickMath.MIN_TICK) return rounded + tickSpacing
+  else if (rounded > TickMath.MAX_TICK) return rounded - tickSpacing
+  else return rounded
+}

package/evm/pool/sushiswap-v3/utils/position.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { PositionLibrary } from './position.js'
+
+describe('PositionLibrary', () => {
+  describe('#getTokensOwed', () => {
+    it('0', () => {
+      const [tokensOwed0, tokensOwed1] = PositionLibrary.getTokensOwed(
+        0n,
+        0n,
+        0n,
+        0n,
+        0n,
+      )
+      expect(tokensOwed0).toEqual(0n)
+      expect(tokensOwed1).toEqual(0n)
+    })
+
+    it('non-0', () => {
+      const [tokensOwed0, tokensOwed1] = PositionLibrary.getTokensOwed(
+        0n,
+        0n,
+        1n,
+        2n ** 128n,
+        2n ** 128n,
+      )
+      expect(tokensOwed0).toEqual(1n)
+      expect(tokensOwed1).toEqual(1n)
+    })
+  })
+})

package/evm/pool/sushiswap-v3/utils/position.ts

@@ -0,0 +1,29 @@
+import { subIn256 } from './tickLibrary.js'
+
+const Q128 = 2n ** 128n
+
+export abstract class PositionLibrary {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  // replicates the portions of Position#update required to compute unaccounted fees
+  public static getTokensOwed(
+    feeGrowthInside0LastX128: bigint,
+    feeGrowthInside1LastX128: bigint,
+    liquidity: bigint,
+    feeGrowthInside0X128: bigint,
+    feeGrowthInside1X128: bigint,
+  ) {
+    const tokensOwed0 =
+      (subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128) * liquidity) /
+      Q128
+
+    const tokensOwed1 =
+      (subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128) * liquidity) /
+      Q128
+
+    return [tokensOwed0, tokensOwed1]
+  }
+}

package/evm/pool/sushiswap-v3/utils/priceTickConversions.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, it } from 'vitest'
+import { EvmToken } from '../../../../evm/currency/token.js'
+import { Price } from '../../../../generic/currency/price.js'
+import type { EvmChainId } from '../../../chain/index.js'
+import { priceToClosestTick, tickToPrice } from './priceTickConversions.js'
+
+describe('priceTickConversions', () => {
+  /**
+   * Creates an example token with a specific sort order
+   */
+  function token({
+    sortOrder,
+    decimals = 18,
+    chainId = 1,
+  }: {
+    sortOrder: number
+    decimals?: number
+    chainId?: EvmChainId
+  }): EvmToken {
+    if (sortOrder > 9 || sortOrder % 1 !== 0)
+      throw new Error('invalid sort order')
+    return new EvmToken({
+      chainId,
+      address: `0x${new Array<string>(40).fill(`${sortOrder}`).join('')}`,
+      decimals,
+      symbol: `T${sortOrder}`,
+      name: `token${sortOrder}`,
+    })
+  }
+
+  const token0 = token({ sortOrder: 0 })
+  const token1 = token({ sortOrder: 1 })
+  const token2_6decimals = token({ sortOrder: 2, decimals: 6 })
+
+  describe('#tickToPrice', () => {
+    it('1800 t0/1 t1', () => {
+      expect(tickToPrice(token1, token0, -74959).toSignificant(5)).toEqual(
+        '1800',
+      )
+    })
+
+    it('1 t1/1800 t0', () => {
+      expect(tickToPrice(token0, token1, -74959).toSignificant(5)).toEqual(
+        '0.00055556',
+      )
+    })
+
+    it('1800 t1/1 t0', () => {
+      expect(tickToPrice(token0, token1, 74959).toSignificant(5)).toEqual(
+        '1800',
+      )
+    })
+
+    it('1 t0/1800 t1', () => {
+      expect(tickToPrice(token1, token0, 74959).toSignificant(5)).toEqual(
+        '0.00055556',
+      )
+    })
+
+    describe('12 decimal difference', () => {
+      it('1.01 t2/1 t0', () => {
+        expect(
+          tickToPrice(token0, token2_6decimals, -276225).toSignificant(5),
+        ).toEqual('1.01')
+      })
+
+      it('1 t0/1.01 t2', () => {
+        expect(
+          tickToPrice(token2_6decimals, token0, -276225).toSignificant(5),
+        ).toEqual('0.99015')
+      })
+
+      it('1 t2/1.01 t0', () => {
+        expect(
+          tickToPrice(token0, token2_6decimals, -276423).toSignificant(5),
+        ).toEqual('0.99015')
+      })
+
+      it('1.01 t0/1 t2', () => {
+        expect(
+          tickToPrice(token2_6decimals, token0, -276423).toSignificant(5),
+        ).toEqual('1.0099')
+      })
+
+      it('1.01 t2/1 t0', () => {
+        expect(
+          tickToPrice(token0, token2_6decimals, -276225).toSignificant(5),
+        ).toEqual('1.01')
+      })
+
+      it('1 t0/1.01 t2', () => {
+        expect(
+          tickToPrice(token2_6decimals, token0, -276225).toSignificant(5),
+        ).toEqual('0.99015')
+      })
+    })
+  })
+
+  describe('#priceToClosestTick', () => {
+    it('1800 t0/1 t1', () => {
+      expect(
+        priceToClosestTick(
+          new Price({
+            base: token1,
+            quote: token0,
+            denominator: 1,
+            numerator: 1800,
+          }),
+        ),
+      ).toEqual(-74960)
+    })
+
+    it('1 t1/1800 t0', () => {
+      expect(
+        priceToClosestTick(
+          new Price({
+            base: token0,
+            quote: token1,
+            denominator: 1800,
+            numerator: 1,
+          }),
+        ),
+      ).toEqual(-74960)
+    })
+
+    it('1.01 t2/1 t0', () => {
+      expect(
+        priceToClosestTick(
+          new Price({
+            base: token0,
+            quote: token2_6decimals,
+            denominator: 100e18,
+            numerator: 101e6,
+          }),
+        ),
+      ).toEqual(-276225)
+    })
+
+    it('1 t0/1.01 t2', () => {
+      expect(
+        priceToClosestTick(
+          new Price({
+            base: token2_6decimals,
+            quote: token0,
+            denominator: 101e6,
+            numerator: 100e18,
+          }),
+        ),
+      ).toEqual(-276225)
+    })
+
+    describe('reciprocal with tickToPrice', () => {
+      it('1800 t0/1 t1', () => {
+        expect(priceToClosestTick(tickToPrice(token1, token0, -74960))).toEqual(
+          -74960,
+        )
+      })
+
+      it('1 t0/1800 t1', () => {
+        expect(priceToClosestTick(tickToPrice(token1, token0, 74960))).toEqual(
+          74960,
+        )
+      })
+
+      it('1 t1/1800 t0', () => {
+        expect(priceToClosestTick(tickToPrice(token0, token1, -74960))).toEqual(
+          -74960,
+        )
+      })
+
+      it('1800 t1/1 t0', () => {
+        expect(priceToClosestTick(tickToPrice(token0, token1, 74960))).toEqual(
+          74960,
+        )
+      })
+
+      it('1.01 t2/1 t0', () => {
+        expect(
+          priceToClosestTick(tickToPrice(token0, token2_6decimals, -276225)),
+        ).toEqual(-276225)
+      })
+
+      it('1 t0/1.01 t2', () => {
+        expect(
+          priceToClosestTick(tickToPrice(token2_6decimals, token0, -276225)),
+        ).toEqual(-276225)
+      })
+    })
+  })
+})

package/evm/pool/sushiswap-v3/utils/priceTickConversions.ts

@@ -0,0 +1,62 @@
+import { Price } from '../../../../generic/currency/price.js'
+import type { EvmToken } from '../../../currency/token.js'
+import { Q192 } from '../internalConstants.js'
+import { encodeSqrtRatioX96 } from './encodeSqrtRatioX96.js'
+import { TickMath } from './tickMath.js'
+
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
+ */
+export function tickToPrice(
+  baseToken: EvmToken,
+  quoteToken: EvmToken,
+  tick: number,
+): Price<EvmToken, EvmToken> {
+  const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick)
+
+  const ratioX192 = sqrtRatioX96 * sqrtRatioX96
+
+  return baseToken.sortsBefore(quoteToken)
+    ? new Price({
+        base: baseToken,
+        quote: quoteToken,
+        denominator: Q192,
+        numerator: ratioX192,
+      })
+    : new Price({
+        base: baseToken,
+        quote: quoteToken,
+        denominator: ratioX192,
+        numerator: Q192,
+      })
+}
+
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+export function priceToClosestTick(price: Price<EvmToken, EvmToken>): number {
+  const sorted = price.base.sortsBefore(price.quote)
+
+  const sqrtRatioX96 = sorted
+    ? encodeSqrtRatioX96(price.numerator, price.denominator)
+    : encodeSqrtRatioX96(price.denominator, price.numerator)
+
+  let tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96)
+  const nextTickPrice = tickToPrice(price.base, price.quote, tick + 1)
+  if (sorted) {
+    if (!price.lt(nextTickPrice)) {
+      tick++
+    }
+  } else {
+    if (!price.gt(nextTickPrice)) {
+      tick++
+    }
+  }
+  return tick
+}