feat: add uniswap swap quote provider

package.json

@@ -89,7 +89,11 @@
     "@ethersproject/contracts": "^5.6.2",
     "@ethersproject/providers": "^5.6.8",
     "@ethersproject/units": "^5.6.1",
+    "@indexcoop/tokenlists": "1.48.0",
     "@lifi/sdk": "3.0.0-beta.1",
+    "@uniswap/sdk-core": "^5.3.1",
+    "@uniswap/smart-order-router": "^3.35.12",
+    "@uniswap/v3-sdk": "^3.13.1",
     "axios": "^0.27.2",
     "viem": "^2.10.2"
   }

src/quote/swap/adapters/adapter.test.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ETH, stETH, WETH } from 'constants/tokens'
+import { AlchemyProviderUrl } from 'tests/utils'
+
+import { IndexSwapQuoteProvider } from './adapter'
+import { Exchange } from 'utils'
+
+const rpcUrl = AlchemyProviderUrl
+
+// ETH/stETH
+const curvePool = '0xdc24316b9ae028f1497c275eb9192a3ea0f67022'
+const eth = ETH.address!
+const steth = stETH.address!
+const weth = WETH.address!
+const ONE = '1000000000000000000'
+
+describe('IndexSwapQuoteProvider', () => {
+  test('returns a swap quote for buying stETH with ETH', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: eth,
+      outputToken: steth,
+      outputAmount: ONE,
+    }
+    const provider = new IndexSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.Curve)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.fees.length).toBe(0)
+    expect(quote.swapData?.path).toEqual([weth, steth])
+    expect(quote.swapData?.pool).toBe(curvePool)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('returns a swap quote for selling stETH for ETH', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: steth,
+      outputToken: eth,
+      inputAmount: ONE,
+    }
+    const provider = new IndexSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.Curve)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.fees.length).toBe(0)
+    expect(quote.swapData?.path).toEqual([weth, steth])
+    expect(quote.swapData?.pool).toBe(curvePool)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+})

src/quote/swap/adapters/adapter.ts

@@ -0,0 +1,33 @@
+import { ETH, stETH } from 'constants/tokens'
+import { CurveSwapQuoteProvider } from 'quote/swap/adapters/curve'
+import { UniswapSwapQuoteProvider } from 'quote/swap/adapters/uniswap'
+import {
+  SwapQuote,
+  SwapQuoteProvider,
+  SwapQuoteRequest,
+} from 'quote/swap/interfaces'
+import { isSameAddress } from 'utils'
+
+export class IndexSwapQuoteProvider implements SwapQuoteProvider {
+  constructor(readonly rpcUrl: string) {}
+
+  public async getSwapQuote(
+    request: SwapQuoteRequest
+  ): Promise<SwapQuote | null> {
+    const { inputToken, outputToken } = request
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const eth = ETH.address!
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const stEth = stETH.address!
+    const isEth =
+      isSameAddress(inputToken, eth) || isSameAddress(outputToken, eth)
+    const isStEth =
+      isSameAddress(inputToken, stEth) || isSameAddress(outputToken, stEth)
+    if (isStEth && isEth) {
+      const curveSwapQuoteProvider = new CurveSwapQuoteProvider(this.rpcUrl)
+      return await curveSwapQuoteProvider.getSwapQuote(request)
+    }
+    const uniswapSwapQuoteProvider = new UniswapSwapQuoteProvider(this.rpcUrl)
+    return await uniswapSwapQuoteProvider.getSwapQuote(request)
+  }
+}

src/quote/swap/adapters/curve/index.test.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ETH, stETH, WETH } from 'constants/tokens'
+import { AlchemyProviderUrl } from 'tests/utils'
+
+import { CurveSwapQuoteProvider } from './'
+import { Exchange } from 'utils'
+
+const rpcUrl = AlchemyProviderUrl
+
+// ETH/stETH
+const curvePool = '0xdc24316b9ae028f1497c275eb9192a3ea0f67022'
+const eth = ETH.address!
+const steth = stETH.address!
+const weth = WETH.address!
+const ONE = '1000000000000000000'
+
+describe('CurveSwapQuoteProvider', () => {
+  test('getting a swap quote for buying stETH', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: eth,
+      outputToken: steth,
+      outputAmount: ONE,
+    }
+    const provider = new CurveSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.Curve)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.fees.length).toBe(0)
+    expect(quote.swapData?.path).toEqual([weth, steth])
+    expect(quote.swapData?.pool).toBe(curvePool)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for selling stETH', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: steth,
+      outputToken: eth,
+      inputAmount: ONE,
+    }
+    const provider = new CurveSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.Curve)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.fees.length).toBe(0)
+    expect(quote.swapData?.path).toEqual([weth, steth])
+    expect(quote.swapData?.pool).toBe(curvePool)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+})

src/quote/swap/adapters/curve/index.ts

@@ -0,0 +1,53 @@
+import { BigNumber } from '@ethersproject/bignumber'
+import { Contract } from '@ethersproject/contracts'
+
+import {
+  SwapQuoteProvider,
+  SwapQuoteRequest,
+  SwapQuote,
+} from 'quote/swap/interfaces'
+import { getRpcProvider } from 'utils/rpc-provider'
+
+import { getSwapData } from './swap-data'
+
+export class CurveSwapQuoteProvider implements SwapQuoteProvider {
+  constructor(readonly rpcUrl: string) {}
+
+  getPoolContract() {
+    const rpcProvider = getRpcProvider(this.rpcUrl)
+    const pool = '0xdc24316b9ae028f1497c275eb9192a3ea0f67022'
+    const abi = [
+      'function get_dy(int128 i, int128 j, uint256 dx) public view returns (uint256)',
+    ]
+    return new Contract(pool, abi, rpcProvider)
+  }
+
+  async getSwapQuote(request: SwapQuoteRequest): Promise<SwapQuote | null> {
+    const {
+      chainId,
+      inputAmount,
+      inputToken,
+      outputAmount,
+      outputToken,
+      slippage,
+    } = request
+    const pool = this.getPoolContract()
+    let quoteAmount = BigNumber.from(0)
+    if (outputAmount) {
+      quoteAmount = await pool.get_dy(0, 1, BigNumber.from(outputAmount))
+    } else {
+      quoteAmount = await pool.get_dy(1, 0, BigNumber.from(inputAmount))
+    }
+    return {
+      chainId,
+      inputToken,
+      outputToken,
+      inputAmount: inputAmount ?? quoteAmount.toString(),
+      outputAmount: outputAmount ?? quoteAmount.toString(),
+      // Will not be used anywhere, so no need to return constructed call data
+      callData: '0x',
+      slippage: slippage ?? 0,
+      swapData: getSwapData(),
+    }
+  }
+}

src/quote/swap/adapters/curve/swap-data.ts

@@ -0,0 +1,14 @@
+import { stETH, WETH } from 'constants/tokens'
+import { Exchange, SwapData } from 'utils'
+
+export function getSwapData(): SwapData {
+  // The curve adapter is mostly just used for ETH/stETH swapping, so we can
+  // hard-code the return here.
+  return {
+    exchange: Exchange.Curve,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    path: [WETH.address!, stETH.address!],
+    fees: [], // not needed for curve
+    pool: '0xdc24316b9ae028f1497c275eb9192a3ea0f67022',
+  }
+}

src/quote/swap/adapters/uniswap/index.test.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { EthAddress } from 'constants/addresses'
+import { ChainId } from 'constants/chains'
+import { USDC, WETH } from 'constants/tokens'
+import { AlchemyProviderUrl, AlchemyProviderUrlArbitrum } from 'tests/utils'
+
+import { UniswapSwapQuoteProvider } from './'
+import { Exchange } from 'utils'
+
+const rpcUrl = AlchemyProviderUrl
+const rpcUrlArbitrum = AlchemyProviderUrlArbitrum
+
+const weth = WETH.address!
+const usdc = USDC.address!
+const ONE = '1000000000000000000'
+
+describe('UniswapSwapQuoteProvider', () => {
+  test('getting a swap quote for a specified output amount', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: usdc,
+      outputToken: weth,
+      outputAmount: ONE,
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.UniV3)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.path).toEqual([
+      request.inputToken,
+      request.outputToken,
+    ])
+    expect(quote.swapData?.fees.length).toBe(1)
+    expect(quote.outputAmount).toEqual(request.outputAmount)
+    expect(quote.inputAmount).not.toEqual(quote.outputAmount)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for a specified input amount', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: usdc,
+      outputToken: weth,
+      inputAmount: '100000000',
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.UniV3)
+    expect(quote.swapData?.path.length).toBe(2)
+    expect(quote.swapData?.path).toEqual([
+      request.inputToken,
+      request.outputToken,
+    ])
+    expect(quote.swapData?.fees.length).toBe(1)
+    expect(quote.inputAmount).toEqual(request.inputAmount)
+    expect(quote.inputAmount).not.toEqual(quote.outputAmount)
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.outputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for a specified input amount (stETH)', async () => {
+    const request = {
+      chainId: 1,
+      inputToken: usdc,
+      outputToken: '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84',
+      inputAmount: '100000000',
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrl)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData?.exchange).toBe(Exchange.Sushiswap)
+    expect(quote.swapData?.path.length).toBe(3)
+    expect(quote.swapData?.path).toEqual([
+      request.inputToken,
+      weth,
+      request.outputToken,
+    ])
+    expect(quote.swapData?.fees).toEqual([3000, 3000])
+    // expect(quote.callData).not.toBe('0x')
+    expect(BigInt(quote.outputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for a specified input amount - Arbitrum', async () => {
+    const request = {
+      chainId: ChainId.Arbitrum,
+      inputToken: EthAddress,
+      outputToken: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f', // wBTC
+      inputAmount: ONE,
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrlArbitrum)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData).toEqual({
+      exchange: 3,
+      path: [
+        '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+        '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+      ],
+      fees: [500],
+      pool: '0x0000000000000000000000000000000000000000',
+    })
+    // expect(quote.callData).not.toBe('0x')
+    expect(quote.inputAmount).toEqual(request.inputAmount)
+    expect(quote.inputAmount).not.toEqual(quote.outputAmount)
+    expect(BigInt(quote.outputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for a specified input amount - Arbitrum', async () => {
+    const request = {
+      chainId: ChainId.Arbitrum,
+      inputToken: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f', // wBTC
+      outputToken: EthAddress,
+      inputAmount: ONE,
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrlArbitrum)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData).toEqual({
+      exchange: 3,
+      path: [
+        '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        '0x912CE59144191C1204E64559FE8253a0e49E6548',
+        '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+      ],
+      fees: [3000, 500],
+      pool: '0x0000000000000000000000000000000000000000',
+    })
+    // expect(quote.callData).not.toBe('0x')
+    expect(quote.inputAmount).toEqual(request.inputAmount)
+    expect(quote.inputAmount).not.toEqual(quote.outputAmount)
+    expect(BigInt(quote.outputAmount) > BigInt(0)).toBe(true)
+  })
+
+  test('getting a swap quote for a specified input amount - Arbitrum', async () => {
+    const request = {
+      chainId: ChainId.Arbitrum,
+      inputToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH
+      outputToken: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC
+      outputAmount: '100000000',
+    }
+    const provider = new UniswapSwapQuoteProvider(rpcUrlArbitrum)
+    const quote = await provider.getSwapQuote(request)
+    if (!quote) fail()
+    expect(quote).not.toBeNull()
+    expect(quote.swapData).toEqual({
+      exchange: 3,
+      path: [
+        '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+        '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+      ],
+      fees: [500],
+      pool: '0x0000000000000000000000000000000000000000',
+    })
+    // expect(quote.callData).not.toBe('0x')
+    expect(quote.outputAmount).toEqual(request.outputAmount)
+    expect(quote.inputAmount).not.toEqual(quote.outputAmount)
+    expect(BigInt(quote.inputAmount) > BigInt(0)).toBe(true)
+  })
+})