sushi 6.0.12 → 6.0.13

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

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest'
+import { EvmToken } from '../../../../evm/currency/token.js'
+import { SushiSwapV3FeeAmount } from '../../../config/index.js'
+import { computeSushiSwapV3PoolAddress } from './computePoolAddress.js'
+
+describe('#computePoolAddress', () => {
+  const factoryAddress = '0x1111111111111111111111111111111111111111'
+  it('should correctly compute the pool address', () => {
+    const tokenA = new EvmToken({
+      chainId: 1,
+      address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+      decimals: 18,
+      symbol: 'USDC',
+      name: 'USD Coin',
+    })
+    const tokenB = new EvmToken({
+      chainId: 1,
+      address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+      decimals: 18,
+      symbol: 'DAI',
+      name: 'Dai Stablecoin',
+    })
+    const result = computeSushiSwapV3PoolAddress({
+      factoryAddress,
+      fee: SushiSwapV3FeeAmount.LOW,
+      tokenA,
+      tokenB,
+    })
+
+    expect(result).toEqual('0x90b1b09a9715cadbfd9331b3a7652b24bfbefd32')
+  })
+
+  it('should correctly compute the pool address', () => {
+    const USDC = new EvmToken({
+      chainId: 1,
+      address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+      decimals: 18,
+      symbol: 'USDC',
+      name: 'USD Coin',
+    })
+    const DAI = new EvmToken({
+      chainId: 1,
+      address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+      decimals: 18,
+      symbol: 'DAI',
+      name: 'Dai Stablecoin',
+    })
+    let tokenA = USDC
+    let tokenB = DAI
+    const resultA = computeSushiSwapV3PoolAddress({
+      factoryAddress,
+      fee: SushiSwapV3FeeAmount.LOW,
+      tokenA,
+      tokenB,
+    })
+
+    tokenA = DAI
+
+    tokenB = USDC
+    const resultB = computeSushiSwapV3PoolAddress({
+      factoryAddress,
+      fee: SushiSwapV3FeeAmount.LOW,
+      tokenA,
+      tokenB,
+    })
+
+    expect(resultA).toEqual(resultB)
+  })
+
+  it('BLAST - should correctly compute the pool address', () => {
+    const tokenA = new EvmToken({
+      chainId: 81457,
+      address: '0x4300000000000000000000000000000000000003',
+      decimals: 18,
+      symbol: 'USDB',
+      name: 'USD Blast',
+    })
+    const tokenB = new EvmToken({
+      chainId: 81457,
+      address: '0x4300000000000000000000000000000000000004',
+      decimals: 18,
+      symbol: 'WETH',
+      name: 'Wrapped Ether',
+    })
+    const result = computeSushiSwapV3PoolAddress({
+      factoryAddress: '0x7680d4b43f3d1d54d6cfeeb2169463bfa7a6cf0d',
+      fee: SushiSwapV3FeeAmount.MEDIUM,
+      tokenA,
+      tokenB,
+    })
+
+    expect(result).toEqual('0xcd03572e7cfb94996beebaa539234ce5c23ae1d6')
+  })
+})

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

@@ -0,0 +1,86 @@
+import { encodeAbiParameters, keccak256, parseAbiParameters } from 'viem/utils'
+import type { EvmChainId } from '../../../chain/chains.js'
+import {
+  SUSHISWAP_V3_INIT_CODE_HASH,
+  type SushiSwapV3ChainId,
+  type SushiSwapV3FeeAmount,
+} from '../../../config/index.js'
+import type { EvmAddress, EvmToken } from '../../../currency/token.js'
+import { getCreate2Address } from '../../../utils/get-create-2-address.js'
+
+type ComputeSushiSwapV3PoolAddressParams = {
+  factoryAddress: EvmAddress
+  fee: SushiSwapV3FeeAmount
+  initCodeHashManualOverride?: EvmAddress | undefined
+} & (
+  | {
+      tokenA: EvmToken
+      tokenB: EvmToken
+    }
+  | {
+      tokenA: EvmAddress
+      tokenB: EvmAddress
+      chainId: EvmChainId
+    }
+)
+
+/**
+ * Computes a pool address
+ * @param factoryAddress The Uniswap V3 factory address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param fee The fee tier of the pool
+ * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
+ * @returns The pool address
+ */
+export function computeSushiSwapV3PoolAddress(
+  params: ComputeSushiSwapV3PoolAddressParams,
+): EvmAddress {
+  if (typeof params.tokenA === 'string' && typeof params.tokenB === 'string') {
+    // FIXME: We shouldn't even allow sending strings into here
+    const {
+      factoryAddress,
+      tokenA,
+      tokenB,
+      fee,
+      initCodeHashManualOverride,
+      chainId,
+    } = params
+
+    return getCreate2Address({
+      from: factoryAddress,
+      salt: keccak256(
+        encodeAbiParameters(parseAbiParameters('address, address, uint24'), [
+          tokenA,
+          tokenB,
+          fee,
+        ]),
+      ),
+      bytecodeHash:
+        initCodeHashManualOverride ??
+        SUSHISWAP_V3_INIT_CODE_HASH[chainId as SushiSwapV3ChainId],
+      chainId,
+    }).toLowerCase() as EvmAddress
+  }
+
+  const { factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride } =
+    params
+  const [token0, token1] = tokenA.sortsBefore(tokenB)
+    ? [tokenA, tokenB]
+    : [tokenB, tokenA] // does safety checks
+
+  return getCreate2Address({
+    from: factoryAddress,
+    salt: keccak256(
+      encodeAbiParameters(parseAbiParameters('address, address, uint24'), [
+        token0.address,
+        token1.address,
+        fee,
+      ]),
+    ),
+    bytecodeHash:
+      initCodeHashManualOverride ??
+      SUSHISWAP_V3_INIT_CODE_HASH[token0.chainId as SushiSwapV3ChainId],
+    chainId: token0.chainId,
+  }).toLowerCase() as EvmAddress
+}

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

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+import { Q96 } from '../internalConstants.js'
+import { encodeSqrtRatioX96 } from './encodeSqrtRatioX96.js'
+
+describe('#encodeSqrtRatioX96', () => {
+  it('1/1', () => {
+    expect(encodeSqrtRatioX96(1, 1)).toEqual(Q96)
+  })
+
+  it('100/1', () => {
+    expect(encodeSqrtRatioX96(100, 1)).toEqual(792281625142643375935439503360n)
+  })
+
+  it('1/100', () => {
+    expect(encodeSqrtRatioX96(1, 100)).toEqual(7922816251426433759354395033n)
+  })
+
+  it('111/333', () => {
+    expect(encodeSqrtRatioX96(111, 333)).toEqual(45742400955009932534161870629n)
+  })
+
+  it('333/111', () => {
+    expect(encodeSqrtRatioX96(333, 111)).toEqual(
+      137227202865029797602485611888n,
+    )
+  })
+})

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

@@ -0,0 +1,18 @@
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+
+import { type BigintIsh, sqrt } from '../../../../generic/index.js'
+
+export function encodeSqrtRatioX96(
+  amount1: BigintIsh,
+  amount0: BigintIsh,
+): bigint {
+  const numerator = BigInt(amount1.toString()) << 192n
+  const denominator = BigInt(amount0.toString())
+  const ratioX192 = numerator / denominator
+  return sqrt(ratioX192)
+}

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

@@ -0,0 +1,21 @@
+import { ONE, ZERO } from '../../../../generic/index.js'
+
+export abstract class FullMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static mulDivRoundingUp(
+    a: bigint,
+    b: bigint,
+    denominator: bigint,
+  ): bigint {
+    const product = a * b
+    let result = product / denominator
+    if (product % denominator !== ZERO) {
+      result = result + ONE
+    }
+    return result
+  }
+}

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

@@ -0,0 +1,18 @@
+export * from './calldata.js'
+export * from './computePoolAddress.js'
+export * from './encodeSqrtRatioX96.js'
+export * from './fullMath.js'
+export * from './isSorted.js'
+export * from './liquidityMath.js'
+export * from './maxLiquidityForAmounts.js'
+export * from './misc.js'
+export * from './mostSignificantBit.js'
+export * from './nearestUsableTick.js'
+export * from './position.js'
+export * from './priceTickConversions.js'
+export * from './sqrtPriceMath.js'
+export * from './swapMath.js'
+export * from './tickLibrary.js'
+export * from './tickList.js'
+export * from './tickMath.js'
+export * from './validateAndParseAddress.js'

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

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { isSorted } from './isSorted.js'
+
+describe('#isSorted', () => {
+  it('empty list', () => {
+    expect(isSorted([], (a: number, b: number) => a - b)).toEqual(true)
+  })
+  it('list with one element', () => {
+    expect(isSorted([1], (a: number, b: number) => a - b)).toEqual(true)
+  })
+  it('list with two sorted elements', () => {
+    expect(isSorted([1, 2], (a: number, b: number) => a - b)).toEqual(true)
+  })
+  it('list with two equal elements', () => {
+    expect(isSorted([2, 2], (a: number, b: number) => a - b)).toEqual(true)
+  })
+  it('list with two unsorted elements', () => {
+    expect(isSorted([2, 1], (a: number, b: number) => a - b)).toEqual(false)
+  })
+  it('list with many elements with one unsorted pair', () => {
+    expect(
+      isSorted([1, 2, 3, 4, 6, 5, 7], (a: number, b: number) => a - b),
+    ).toEqual(false)
+  })
+  it('list with many elements with one unsorted pair at the end', () => {
+    expect(
+      isSorted([1, 2, 3, 4, 5, 7, 6], (a: number, b: number) => a - b),
+    ).toEqual(false)
+  })
+  it('list with many elements with one unsorted pair at the beginning', () => {
+    expect(
+      isSorted([2, 1, 3, 4, 5, 6, 7], (a: number, b: number) => a - b),
+    ).toEqual(false)
+  })
+  it('list with many elements with duplicates', () => {
+    expect(
+      isSorted([1, 2, 2, 3, 4, 5, 6, 7], (a: number, b: number) => a - b),
+    ).toEqual(true)
+  })
+  it('list with opposite comparator', () => {
+    expect(
+      isSorted([1, 2, 2, 3, 4, 5, 6, 7], (a: number, b: number) => b - a),
+    ).toEqual(false)
+  })
+  it('reverse sorted list with opposite comparator', () => {
+    expect(
+      isSorted(
+        [1, 2, 2, 3, 4, 5, 6, 7].reverse(),
+        (a: number, b: number) => b - a,
+      ),
+    ).toEqual(true)
+  })
+})

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

@@ -0,0 +1,17 @@
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+export function isSorted<T>(
+  list: T[],
+  comparator: (a: T, b: T) => number,
+): boolean {
+  for (let i = 0; i < list.length - 1; i++) {
+    if (comparator(list[i]!, list[i + 1]!) > 0) {
+      return false
+    }
+  }
+  return true
+}

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

@@ -0,0 +1,16 @@
+import { ONE, ZERO } from '../../../../generic/index.js'
+
+export abstract class LiquidityMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static addDelta(x: bigint, y: bigint): bigint {
+    if (y < ZERO) {
+      return x - y * -ONE
+    } else {
+      return x + y
+    }
+  }
+}

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

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest'
+import { MAX_UINT256 } from '../../../../generic/math/constants.js'
+import { encodeSqrtRatioX96 } from './encodeSqrtRatioX96.js'
+import { maxLiquidityForAmounts } from './maxLiquidityForAmounts.js'
+
+describe('#maxLiquidityForAmounts', () => {
+  describe('imprecise', () => {
+    describe('price inside', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            false,
+          ),
+        ).toEqual(2148n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            false,
+          ),
+        ).toEqual(2148n)
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            false,
+          ),
+        ).toEqual(4297n)
+      })
+    })
+
+    describe('price below', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            false,
+          ),
+        ).toEqual(1048n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            false,
+          ),
+        ).toEqual(1048n)
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            false,
+          ),
+        ).toEqual(
+          1214437677402050006470401421068302637228917309992228326090730924516431320489727n,
+        )
+      })
+    })
+
+    describe('price above', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            false,
+          ),
+        ).toEqual(2097n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            false,
+          ),
+        ).toEqual(
+          1214437677402050006470401421098959354205873606971497132040612572422243086574654n,
+        )
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            false,
+          ),
+        ).toEqual(2097n)
+      })
+    })
+  })
+
+  describe('precise', () => {
+    describe('price inside', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            true,
+          ),
+        ).toEqual(2148n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            true,
+          ),
+        ).toEqual(2148n)
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(1, 1),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            true,
+          ),
+        ).toEqual(4297n)
+      })
+    })
+
+    describe('price below', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            true,
+          ),
+        ).toEqual(1048n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            true,
+          ),
+        ).toEqual(1048n)
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(99, 110),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            true,
+          ),
+        ).toEqual(
+          1214437677402050006470401421082903520362793114274352355276488318240158678126184n,
+        )
+      })
+    })
+
+    describe('price above', () => {
+      it('100 token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            '200',
+            true,
+          ),
+        ).toEqual(2097n)
+      })
+
+      it('100 token0, max token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            '100',
+            MAX_UINT256,
+            true,
+          ),
+        ).toEqual(
+          1214437677402050006470401421098959354205873606971497132040612572422243086574654n,
+        )
+      })
+
+      it('max token0, 200 token1', () => {
+        expect(
+          maxLiquidityForAmounts(
+            encodeSqrtRatioX96(111, 100),
+            encodeSqrtRatioX96(100, 110),
+            encodeSqrtRatioX96(110, 100),
+            MAX_UINT256,
+            '200',
+            true,
+          ),
+        ).toEqual(2097n)
+      })
+    })
+  })
+})