sushi 6.0.11 → 6.0.13

package/evm/pool/sushiswap-v3/entities/Position.ts

@@ -0,0 +1,440 @@
+import invariant from 'tiny-invariant'
+import { Amount } from '../../../../generic/currency/amount.js'
+import type { Price } from '../../../../generic/currency/price.js'
+import { MAX_UINT256 } from '../../../../generic/math/constants.js'
+import { Percent } from '../../../../generic/math/percent.js'
+import type { BigintIsh } from '../../../../generic/types/bigintish.js'
+import type { EvmToken } from '../../../currency/token.js'
+import { encodeSqrtRatioX96 } from '../utils/encodeSqrtRatioX96.js'
+import { maxLiquidityForAmounts } from '../utils/maxLiquidityForAmounts.js'
+import { tickToPrice } from '../utils/priceTickConversions.js'
+import { SqrtPriceMath } from '../utils/sqrtPriceMath.js'
+import { TickMath } from '../utils/tickMath.js'
+import { SushiSwapV3Pool } from './SushiSwapV3Pool.js'
+
+interface PositionConstructorArgs {
+  pool: SushiSwapV3Pool
+  tickLower: number
+  tickUpper: number
+  liquidity: BigintIsh
+}
+
+/**
+ * Represents a position on a Uniswap V3 Pool
+ */
+export class Position {
+  public readonly pool: SushiSwapV3Pool
+  public readonly tickLower: number
+  public readonly tickUpper: number
+  public readonly liquidity: bigint
+
+  // cached resuts for the getters
+  private _token0Amount: Amount<EvmToken> | null = null
+  private _token1Amount: Amount<EvmToken> | null = null
+  private _mintAmounts: Readonly<{ amount0: bigint; amount1: bigint }> | null =
+    null
+
+  /**
+   * Constructs a position for a given pool with the given liquidity
+   * @param pool For which pool the liquidity is assigned
+   * @param liquidity The amount of liquidity that is in the position
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
+   */
+  public constructor({
+    pool,
+    liquidity,
+    tickLower,
+    tickUpper,
+  }: PositionConstructorArgs) {
+    invariant(tickLower < tickUpper, 'TICK_ORDER')
+    invariant(
+      tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0,
+      'TICK_LOWER',
+    )
+    invariant(
+      tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0,
+      'TICK_UPPER',
+    )
+
+    this.pool = pool
+    this.tickLower = tickLower
+    this.tickUpper = tickUpper
+    this.liquidity = BigInt(liquidity.toString())
+  }
+
+  /**
+   * Returns the price of token0 at the lower tick
+   */
+  public get token0PriceLower(): Price<EvmToken, EvmToken> {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower)
+  }
+
+  /**
+   * Returns the price of token0 at the upper tick
+   */
+  public get token0PriceUpper(): Price<EvmToken, EvmToken> {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper)
+  }
+
+  /**
+   * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+   */
+  public get amount0(): Amount<EvmToken> {
+    if (this._token0Amount === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        this._token0Amount = new Amount(
+          this.pool.token0,
+          SqrtPriceMath.getAmount0Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false,
+          ),
+        )
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        this._token0Amount = new Amount(
+          this.pool.token0,
+          SqrtPriceMath.getAmount0Delta(
+            this.pool.sqrtRatioX96,
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false,
+          ),
+        )
+      } else {
+        this._token0Amount = new Amount(this.pool.token0, 0n)
+      }
+    }
+    return this._token0Amount
+  }
+
+  /**
+   * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+   */
+  public get amount1(): Amount<EvmToken> {
+    if (this._token1Amount === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        this._token1Amount = new Amount(this.pool.token1, 0n)
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        this._token1Amount = new Amount(
+          this.pool.token1,
+          SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            this.pool.sqrtRatioX96,
+            this.liquidity,
+            false,
+          ),
+        )
+      } else {
+        this._token1Amount = new Amount(
+          this.pool.token1,
+          SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false,
+          ),
+        )
+      }
+    }
+    return this._token1Amount
+  }
+
+  /**
+   * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+   * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+   * @returns The sqrt ratios after slippage
+   */
+  private ratiosAfterSlippage(slippageTolerance: Percent): {
+    sqrtRatioX96Lower: bigint
+    sqrtRatioX96Upper: bigint
+  } {
+    const priceLower = this.pool.token0Price.asFraction.mul(
+      new Percent(1).sub(slippageTolerance),
+    )
+    const priceUpper = this.pool.token0Price.asFraction.mul(
+      slippageTolerance.add(1),
+    )
+    let sqrtRatioX96Lower = encodeSqrtRatioX96(
+      priceLower.numerator,
+      priceLower.denominator,
+    )
+    if (sqrtRatioX96Lower <= TickMath.MIN_SQRT_RATIO) {
+      sqrtRatioX96Lower = TickMath.MIN_SQRT_RATIO + 1n
+    }
+    let sqrtRatioX96Upper = encodeSqrtRatioX96(
+      priceUpper.numerator,
+      priceUpper.denominator,
+    )
+    if (sqrtRatioX96Upper >= TickMath.MAX_SQRT_RATIO) {
+      sqrtRatioX96Upper = TickMath.MAX_SQRT_RATIO - 1n
+    }
+    return {
+      sqrtRatioX96Lower,
+      sqrtRatioX96Upper,
+    }
+  }
+
+  /**
+   * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+   * with the given slippage tolerance
+   * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
+   */
+  public mintAmountsWithSlippage(
+    slippageTolerance: Percent,
+  ): Readonly<{ amount0: bigint; amount1: bigint }> {
+    // get lower/upper prices
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } =
+      this.ratiosAfterSlippage(slippageTolerance)
+
+    // construct counterfactual pools
+    const poolLower = new SushiSwapV3Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Lower,
+      0 /* liquidity doesn't matter */,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower),
+    )
+    const poolUpper = new SushiSwapV3Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Upper,
+      0 /* liquidity doesn't matter */,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper),
+    )
+
+    // because the router is imprecise, we need to calculate the position that will be created (assuming no slippage)
+    const positionThatWillBeCreated = Position.fromAmounts({
+      pool: this.pool,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+      ...this.mintAmounts, // the mint amounts are what will be passed as calldata
+      useFullPrecision: false,
+    })
+
+    // we want the smaller amounts...
+    // ...which occurs at the upper price for amount0...
+    const { amount0 } = new Position({
+      pool: poolUpper,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+    }).mintAmounts
+    // ...and the lower for amount1
+    const { amount1 } = new Position({
+      pool: poolLower,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+    }).mintAmounts
+
+    return { amount0, amount1 }
+  }
+
+  /**
+   * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+   * position with the given slippage tolerance
+   * @param slippageTolerance tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
+   */
+  public burnAmountsWithSlippage(
+    slippageTolerance: Percent,
+  ): Readonly<{ amount0: bigint; amount1: bigint }> {
+    // get lower/upper prices
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } =
+      this.ratiosAfterSlippage(slippageTolerance)
+
+    // construct counterfactual pools
+    const poolLower = new SushiSwapV3Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Lower,
+      0 /* liquidity doesn't matter */,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower),
+    )
+    const poolUpper = new SushiSwapV3Pool(
+      this.pool.token0,
+      this.pool.token1,
+      this.pool.fee,
+      sqrtRatioX96Upper,
+      0 /* liquidity doesn't matter */,
+      TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper),
+    )
+
+    // we want the smaller amounts...
+    // ...which occurs at the upper price for amount0...
+    const amount0 = new Position({
+      pool: poolUpper,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+    }).amount0
+    // ...and the lower for amount1
+    const amount1 = new Position({
+      pool: poolLower,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+    }).amount1
+
+    return { amount0: amount0.amount, amount1: amount1.amount }
+  }
+
+  /**
+   * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+   * the current price for the pool
+   */
+  public get mintAmounts(): Readonly<{ amount0: bigint; amount1: bigint }> {
+    if (this._mintAmounts === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true,
+          ),
+          amount1: 0n,
+        }
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            this.pool.sqrtRatioX96,
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true,
+          ),
+          amount1: SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            this.pool.sqrtRatioX96,
+            this.liquidity,
+            true,
+          ),
+        }
+      } else {
+        return {
+          amount0: 0n,
+          amount1: SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true,
+          ),
+        }
+      }
+    }
+    return this._mintAmounts
+  }
+
+  /**
+   * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+   * and the prices at the tick boundaries.
+   * @param pool The pool for which the position should be created
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
+   * @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
+   * @returns The amount of liquidity for the position
+   */
+  public static fromAmounts({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    useFullPrecision,
+  }: {
+    pool: SushiSwapV3Pool
+    tickLower: number
+    tickUpper: number
+    amount0: BigintIsh
+    amount1: BigintIsh
+    useFullPrecision: boolean
+  }) {
+    const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower)
+    const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper)
+    return new Position({
+      pool,
+      tickLower,
+      tickUpper,
+      liquidity: maxLiquidityForAmounts(
+        pool.sqrtRatioX96,
+        sqrtRatioAX96,
+        sqrtRatioBX96,
+        amount0,
+        amount1,
+        useFullPrecision,
+      ),
+    })
+  }
+
+  /**
+   * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount0 The desired amount of token0
+   * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+   * not what core can theoretically support
+   * @returns The position
+   */
+  public static fromAmount0({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    useFullPrecision,
+  }: {
+    pool: SushiSwapV3Pool
+    tickLower: number
+    tickUpper: number
+    amount0: BigintIsh
+    useFullPrecision: boolean
+  }) {
+    return Position.fromAmounts({
+      pool,
+      tickLower,
+      tickUpper,
+      amount0,
+      amount1: MAX_UINT256,
+      useFullPrecision,
+    })
+  }
+
+  /**
+   * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount1 The desired amount of token1
+   * @returns The position
+   */
+  public static fromAmount1({
+    pool,
+    tickLower,
+    tickUpper,
+    amount1,
+  }: {
+    pool: SushiSwapV3Pool
+    tickLower: number
+    tickUpper: number
+    amount1: BigintIsh
+  }) {
+    // this function always uses full precision,
+    return Position.fromAmounts({
+      pool,
+      tickLower,
+      tickUpper,
+      amount0: MAX_UINT256,
+      amount1,
+      useFullPrecision: true,
+    })
+  }
+}

package/evm/pool/sushiswap-v3/entities/SelfPermit.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest'
+import { EvmToken } from '../../../currency/token.js'
+import {
+  type AllowedPermitArguments,
+  SelfPermit,
+  type StandardPermitArguments,
+} from './SelfPermit.js'
+
+const token = new EvmToken({
+  chainId: 1,
+  address: '0x0000000000000000000000000000000000000001',
+  decimals: 18,
+  symbol: 't0',
+  name: 'token0',
+})
+const standardPermitOptions: StandardPermitArguments = {
+  v: 0,
+  r: '0x0000000000000000000000000000000000000000000000000000000000000001',
+  s: '0x0000000000000000000000000000000000000000000000000000000000000002',
+  amount: 123n,
+  deadline: 123n,
+}
+const allowedPermitOptions: AllowedPermitArguments = {
+  v: 0,
+  r: '0x0000000000000000000000000000000000000000000000000000000000000001',
+  s: '0x0000000000000000000000000000000000000000000000000000000000000002',
+  nonce: 123n,
+  expiry: 123n,
+}
+
+describe('SelfPermit', () => {
+  describe('#encodePermit', () => {
+    it('works with StandardPermitArguments', () => {
+      const calldata = SelfPermit.encodePermit(token, standardPermitOptions)
+      expect(calldata).toBe(
+        '0xf3995c670000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000007b000000000000000000000000000000000000000000000000000000000000007b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002',
+      )
+    })
+
+    it('works with AllowedPermitArguments', () => {
+      const calldata = SelfPermit.encodePermit(token, allowedPermitOptions)
+      expect(calldata).toBe(
+        '0x4659a4940000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000007b000000000000000000000000000000000000000000000000000000000000007b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002',
+      )
+    })
+  })
+})

package/evm/pool/sushiswap-v3/entities/SelfPermit.ts

@@ -0,0 +1,68 @@
+import { type Hex, encodeFunctionData } from 'viem'
+import type { BigintIsh } from '../../../../generic/index.js'
+import {
+  selfPermitAbi_selfPermit,
+  selfPermitAbi_selfPermitAllowed,
+} from '../../../abi/selfPermitAbi/index.js'
+import type { EvmToken } from '../../../currency/token.js'
+
+export interface StandardPermitArguments {
+  v: 0 | 1 | 27 | 28
+  r: Hex
+  s: Hex
+  amount: BigintIsh
+  deadline: BigintIsh
+}
+
+export interface AllowedPermitArguments {
+  v: 0 | 1 | 27 | 28
+  r: Hex
+  s: Hex
+  nonce: BigintIsh
+  expiry: BigintIsh
+}
+
+export type PermitOptions = StandardPermitArguments | AllowedPermitArguments
+
+function isAllowedPermit(
+  permitOptions: PermitOptions,
+): permitOptions is AllowedPermitArguments {
+  return 'nonce' in permitOptions
+}
+
+export abstract class SelfPermit {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static encodePermit(token: EvmToken, options: PermitOptions) {
+    if (isAllowedPermit(options)) {
+      return encodeFunctionData({
+        abi: selfPermitAbi_selfPermitAllowed,
+        functionName: 'selfPermitAllowed',
+        args: [
+          token.address,
+          BigInt(options.nonce),
+          BigInt(options.expiry),
+          options.v,
+          options.r,
+          options.s,
+        ],
+      })
+    }
+
+    return encodeFunctionData({
+      abi: selfPermitAbi_selfPermit,
+      functionName: 'selfPermit',
+      args: [
+        token.address,
+        BigInt(options.amount),
+        BigInt(options.deadline),
+        options.v,
+        options.r,
+        options.s,
+      ],
+    })
+  }
+}