Merge pull request #15 from BootNodeDev/feat/removeLiquidity

Feat/remove liquidity

Author: luchobonatti

README.md

@@ -75,6 +75,7 @@ Full API documentation with TypeDoc: [https://bootnodedev.github.io/uni-dev-kit]
     - [`buildSwapCallData`](#buildswapcalldata)
     - [`buildAddLiquidityCallData`](#buildaddliquiditycalldata)
     - [`preparePermit2BatchCallData`](#preparepermit2batchcalldata)
+    - [`buildRemoveLiquidityCallData`](#buildremoveliquiditycalldata)
       - [Basis Points Reference](#basis-points-reference)
   - [Useful Links](#useful-links)
   - [Development](#development)
@@ -214,6 +215,22 @@ const permitData = await uniDevKit.preparePermit2BatchCallData({
 });
 ```
 
+### `buildRemoveLiquidityCallData`
+Build calldata to remove liquidity from a pool.
+```ts
+const { calldata, value } = await uniDevKit.buildRemoveLiquidityCallData({
+  liquidityPercentage: 10_000, // 100%
+  tokenId: '123',
+  slippageTolerance: 50, // 0.5%
+});
+
+const tx = await sendTransaction({
+  to: uniDevKit.getContractAddress('positionManager'),
+  data: calldata,
+  value
+});
+```
+
 #### Basis Points Reference
 
 Throughout the library, percentages are represented in basis points (bps). For example, when setting a slippage tolerance of 0.5%, you would use `50` bps. Here's a quick reference:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniswap-dev-kit",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "A modern TypeScript library for integrating Uniswap into your dapp.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/constants/common.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_DEADLINE = 60 * 10 // 10 minutes
+export const DEFAULT_SLIPPAGE_TOLERANCE = 50

src/core/uniDevKitV4.ts

@@ -17,6 +17,10 @@ import type {
   PreparePermit2DataResult,
 } from '@/types/utils/permit2'
 import { buildAddLiquidityCallData } from '@/utils/buildAddLiquidityCallData'
+import {
+  type BuildRemoveLiquidityCallDataParams,
+  buildRemoveLiquidityCallData,
+} from '@/utils/buildRemoveLiquidityCallData'
 import { buildSwapCallData } from '@/utils/buildSwapCallData'
 import { getPool } from '@/utils/getPool'
 import { getPoolKeyFromPoolId } from '@/utils/getPoolKeyFromPoolId'
@@ -234,4 +238,14 @@ export class UniDevKitV4 {
   async preparePermit2Data(params: PreparePermit2DataParams): Promise<PreparePermit2DataResult> {
     return preparePermit2Data(params, this.instance)
   }
+
+  /**
+   * Builds a remove liquidity call data for a given remove liquidity parameters.
+   * @param params @type {BuildRemoveLiquidityCallDataParams}
+   * @returns Promise resolving to remove liquidity call data including calldata and value
+   * @throws Error if SDK instance is not found or if remove liquidity call data is invalid
+   */
+  async buildRemoveLiquidityCallData(params: BuildRemoveLiquidityCallDataParams) {
+    return buildRemoveLiquidityCallData(params, this.instance)
+  }
 }

src/test/utils/buildRemoveLiquidityCallData.test.ts

@@ -0,0 +1,123 @@
+import { createMockSdkInstance } from '@/test/helpers/sdkInstance'
+import { getPosition } from '@/utils/getPosition'
+import { Token } from '@uniswap/sdk-core'
+import { Pool, Position, V4PositionManager } from '@uniswap/v4-sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const instance = createMockSdkInstance()
+
+vi.mock('@/utils/getPosition', () => ({
+  getPosition: vi.fn(),
+}))
+
+const token0 = new Token(1, '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 6, 'USDC', 'USD Coin')
+const token1 = new Token(
+  1,
+  '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  18,
+  'WETH',
+  'Wrapped Ether',
+)
+const pool = new Pool(
+  token0,
+  token1,
+  3000,
+  60,
+  '0x1111111111111111111111111111111111111111',
+  '79228162514264337593543950336',
+  '1000000', // liquidity as string
+  0,
+)
+const position = new Position({ pool, liquidity: '1000000', tickLower: -60, tickUpper: 60 }) // liquidity as string
+
+const mockPosition = {
+  position,
+  pool,
+  token0,
+  token1,
+  poolId: '0x1111111111111111111111111111111111111111' as `0x${string}`,
+  tokenId: '1',
+}
+
+describe('buildRemoveLiquidityCallData', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('should build calldata for removing 100% liquidity', async () => {
+    vi.mock('@/utils/getDefaultDeadline', () => ({
+      getDefaultDeadline: vi.fn().mockResolvedValue('1234567890'),
+    }))
+    vi.mocked(getPosition).mockReturnValueOnce(Promise.resolve(mockPosition))
+    vi.spyOn(V4PositionManager, 'removeCallParameters').mockReturnValueOnce({
+      calldata: '0x123',
+      value: '0',
+    })
+    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
+    const result = await buildRemoveLiquidityCallData(
+      {
+        liquidityPercentage: 10_000,
+        tokenId: '1',
+        deadline: '123',
+      },
+      instance,
+    )
+    expect(result.calldata).toBe('0x123')
+    expect(result.value).toBe('0')
+  })
+
+  it('should use custom slippageTolerance', async () => {
+    vi.mock('@/utils/getDefaultDeadline', () => ({
+      getDefaultDeadline: vi.fn().mockResolvedValue('1234567890'),
+    }))
+    vi.mocked(getPosition).mockReturnValueOnce(Promise.resolve(mockPosition))
+    const spy = vi.spyOn(V4PositionManager, 'removeCallParameters').mockReturnValueOnce({
+      calldata: '0xabc',
+      value: '1',
+    })
+    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
+    await buildRemoveLiquidityCallData(
+      {
+        liquidityPercentage: 5000,
+        tokenId: '1',
+        slippageTolerance: 123,
+        deadline: '123',
+      },
+      instance,
+    )
+    expect(spy).toHaveBeenCalledWith(
+      mockPosition.position,
+      expect.objectContaining({ slippageTolerance: expect.any(Object) }),
+    )
+  })
+
+  it('should throw if position not found', async () => {
+    vi.mock('@/utils/getDefaultDeadline', () => ({
+      getDefaultDeadline: vi.fn().mockResolvedValue('1234567890'),
+    }))
+    vi.mocked(getPosition).mockReturnValueOnce(
+      Promise.resolve(undefined as unknown as ReturnType<typeof getPosition>),
+    )
+    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
+    await expect(
+      buildRemoveLiquidityCallData({ liquidityPercentage: 10_000, tokenId: '404' }, instance),
+    ).rejects.toThrow('Position not found')
+  })
+
+  it('should throw if V4PositionManager throws', async () => {
+    vi.mock('@/utils/getDefaultDeadline', () => ({
+      getDefaultDeadline: vi.fn().mockResolvedValue('1234567890'),
+    }))
+    vi.mocked(getPosition).mockReturnValueOnce(Promise.resolve(mockPosition))
+    vi.spyOn(V4PositionManager, 'removeCallParameters').mockImplementationOnce(() => {
+      throw new Error('fail')
+    })
+    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
+    await expect(
+      buildRemoveLiquidityCallData(
+        { liquidityPercentage: 10_000, tokenId: '1', deadline: '123' },
+        instance,
+      ),
+    ).rejects.toThrow('fail')
+  })
+})

src/utils/buildAddLiquidityCallData.ts

@@ -1,15 +1,14 @@
+import { DEFAULT_SLIPPAGE_TOLERANCE } from '@/constants/common'
+import { percentFromBips } from '@/helpers/percent'
 import type { UniDevKitV4Instance } from '@/types'
 import type {
   BuildAddLiquidityCallDataResult,
   BuildAddLiquidityParams,
 } from '@/types/utils/buildAddLiquidityCallData'
-import { Percent } from '@uniswap/sdk-core'
+import { getDefaultDeadline } from '@/utils/getDefaultDeadline'
 import { TickMath, encodeSqrtRatioX96, nearestUsableTick } from '@uniswap/v3-sdk'
 import { Position, V4PositionManager } from '@uniswap/v4-sdk'
 
-const DEFAULT_DEADLINE = 1800n // 30 minutes
-const DEFAULT_SLIPPAGE_TOLERANCE = 50
-
 /**
  * Builds the calldata and native value required to add liquidity to a Uniswap V4 pool.
  *
@@ -80,14 +79,10 @@ export async function buildAddLiquidityCallData(
     permit2BatchSignature,
   } = params
 
-  console.log('params', params)
-
   try {
-    const deadline =
-      deadlineParam ??
-      (await instance.client.getBlock().then((b) => b.timestamp + DEFAULT_DEADLINE)).toString()
+    const deadline = deadlineParam ?? (await getDefaultDeadline(instance)).toString()
 
-    const slippagePercent = new Percent(slippageTolerance, 10_000)
+    const slippagePercent = percentFromBips(slippageTolerance)
     const createPool = pool.liquidity.toString() === '0'
 
     const tickLower = tickLowerParam ?? nearestUsableTick(TickMath.MIN_TICK, pool.tickSpacing)

src/utils/buildRemoveLiquidityCallData.ts

@@ -1,34 +1,33 @@
-import { Percent } from '@uniswap/sdk-core'
-import { type Position, V4PositionManager } from '@uniswap/v4-sdk'
+import { DEFAULT_SLIPPAGE_TOLERANCE } from '@/constants/common'
+import { percentFromBips } from '@/helpers/percent'
+import type { UniDevKitV4Instance } from '@/types'
+import { getDefaultDeadline } from '@/utils/getDefaultDeadline'
+import { getPosition } from '@/utils/getPosition'
+import { V4PositionManager } from '@uniswap/v4-sdk'
 
 /**
  * Parameters required to build the calldata for removing liquidity from a Uniswap v4 position.
  */
 export interface BuildRemoveLiquidityCallDataParams {
-  /**
-   * The position object representing the liquidity position to modify.
-   */
-  position: Position
-
   /**
    * The percentage of liquidity to remove from the position.
    */
   liquidityPercentage: number
 
   /**
-   * The deadline for the transaction.
+   * The tokenId of the position to remove liquidity from.
    */
-  deadline: string
+  tokenId: string
 
   /**
    * The slippage tolerance for the transaction.
    */
-  slippageTolerance: number
+  slippageTolerance?: number
 
   /**
-   * The tokenId of the position to remove liquidity from.
+   * The deadline for the transaction. (default: 5 minutes from now)
    */
-  tokenId: string
+  deadline?: string
 }
 
 /**
@@ -41,7 +40,7 @@ export interface BuildRemoveLiquidityCallDataParams {
  * ```typescript
  * const { calldata, value } = buildRemoveLiquidityCallData({
  *   position,
- *   liquidityPercentage: new Percent(1, 1), // 100%
+ *   liquidityPercentage: 10_000, // 100%
  * });
  *
  * const tx = await sendTransaction({
@@ -51,18 +50,29 @@ export interface BuildRemoveLiquidityCallDataParams {
  * });
  * ```
  */
-export function buildRemoveLiquidityCallData({
-  position,
-  liquidityPercentage,
-  deadline,
-  slippageTolerance,
-  tokenId,
-}: BuildRemoveLiquidityCallDataParams) {
+export async function buildRemoveLiquidityCallData(
+  {
+    liquidityPercentage,
+    deadline: deadlineParam,
+    slippageTolerance,
+    tokenId,
+  }: BuildRemoveLiquidityCallDataParams,
+  instance: UniDevKitV4Instance,
+) {
+  // Get position data
+  const positionData = await getPosition({ tokenId }, instance)
+  if (!positionData) {
+    throw new Error('Position not found')
+  }
+
+  const deadline = deadlineParam ?? (await getDefaultDeadline(instance)).toString()
+
+  // Build remove liquidity call data
   try {
-    const { calldata, value } = V4PositionManager.removeCallParameters(position, {
-      slippageTolerance: new Percent(slippageTolerance, 100),
+    const { calldata, value } = V4PositionManager.removeCallParameters(positionData.position, {
+      slippageTolerance: percentFromBips(slippageTolerance ?? DEFAULT_SLIPPAGE_TOLERANCE),
       deadline: deadline,
-      liquidityPercentage: new Percent(liquidityPercentage, 100),
+      liquidityPercentage: percentFromBips(liquidityPercentage),
       tokenId: tokenId,
     })
 

src/utils/getDefaultDeadline.ts

@@ -0,0 +1,9 @@
+import { DEFAULT_DEADLINE } from '@/constants/common'
+import type { UniDevKitV4Instance } from '@/types'
+
+export async function getDefaultDeadline(
+  instance: UniDevKitV4Instance,
+  timeFromNow: number = DEFAULT_DEADLINE,
+): Promise<bigint> {
+  return (await instance.client.getBlock()).timestamp + BigInt(timeFromNow)
+}