feat(api): bridge limits [SLT-165]

packages/rest-api/package.json

@@ -15,9 +15,11 @@
     "lint:check": "eslint . --max-warnings=0",
     "ci:lint": "npm run lint:check",
     "test": "jest",
-    "test:coverage": "jest --collect-coverage"
+    "test:coverage": "jest --collect-coverage",
+    "generate:limits-map": "node src/scripts/generateBridgeLimitMapping.js"
   },
   "dependencies": {
+    "@ethersproject/address": "^5.7.0",
     "@ethersproject/bignumber": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
     "@ethersproject/units": "5.7.0",

packages/rest-api/src/controllers/bridgeLimitsController.ts

@@ -0,0 +1,108 @@
+import { validationResult } from 'express-validator'
+import { BigNumber } from 'ethers'
+import { parseUnits } from '@ethersproject/units'
+
+import { Synapse } from '../services/synapseService'
+import { tokenAddressToToken } from '../utils/tokenAddressToToken'
+import { formatBNToString } from '../utils/formatBNToString'
+
+export const bridgeLimitsController = async (req, res) => {
+  const errors = validationResult(req)
+  if (!errors.isEmpty()) {
+    return res.status(400).json({ errors: errors.array() })
+  }
+  try {
+    const { fromChain, fromToken, toChain, toToken } = req.query
+
+    const fromTokenInfo = tokenAddressToToken(fromChain, fromToken)
+    const toTokenInfo = tokenAddressToToken(toChain, toToken)
+
+    const upperLimitValue = parseUnits('1000000', fromTokenInfo.decimals)
+    const upperLimitBridgeQuotes = await Synapse.allBridgeQuotes(
+      Number(fromChain),
+      Number(toChain),
+      fromTokenInfo.address,
+      toTokenInfo.address,
+      upperLimitValue
+    )
+
+    const lowerLimitValues = ['0.01', '10']
+    let lowerLimitBridgeQuotes = null
+
+    for (const limit of lowerLimitValues) {
+      const lowerLimitAmount = parseUnits(limit, fromTokenInfo.decimals)
+
+      lowerLimitBridgeQuotes = await Synapse.allBridgeQuotes(
+        Number(fromChain),
+        Number(toChain),
+        fromTokenInfo.address,
+        toTokenInfo.address,
+        lowerLimitAmount
+      )
+
+      if (lowerLimitBridgeQuotes && lowerLimitBridgeQuotes.length > 0) {
+        break
+      }
+    }
+
+    const maxBridgeAmountQuote = upperLimitBridgeQuotes.reduce(
+      (maxQuote, currentQuote) => {
+        const currentMaxAmount = currentQuote.maxAmountOut
+        const maxAmount = maxQuote ? maxQuote.maxAmountOut : BigNumber.from(0)
+
+        return currentMaxAmount.gt(maxAmount) ? currentQuote : maxQuote
+      },
+      null
+    )
+
+    const minBridgeAmountQuote = lowerLimitBridgeQuotes.reduce(
+      (minQuote, currentQuote) => {
+        const currentFeeAmount = currentQuote.feeAmount
+        const minFeeAmount = minQuote ? minQuote.feeAmount : null
+
+        return !minFeeAmount || currentFeeAmount.lt(minFeeAmount)
+          ? currentQuote
+          : minQuote
+      },
+      null
+    )
+
+    if (!maxBridgeAmountQuote || !minBridgeAmountQuote) {
+      return res.json({
+        maxOriginAmount: null,
+        minOriginAmount: null,
+      })
+    }
+
+    const maxAmountOriginQueryTokenOutInfo = tokenAddressToToken(
+      toChain,
+      maxBridgeAmountQuote.destQuery.tokenOut
+    )
+
+    const minAmountOriginQueryTokenOutInfo = tokenAddressToToken(
+      fromChain,
+      minBridgeAmountQuote.originQuery.tokenOut
+    )
+
+    const maxOriginAmount = formatBNToString(
+      maxBridgeAmountQuote.maxAmountOut,
+      maxAmountOriginQueryTokenOutInfo.decimals
+    )
+
+    const minOriginAmount = formatBNToString(
+      minBridgeAmountQuote.feeAmount,
+      minAmountOriginQueryTokenOutInfo.decimals
+    )
+
+    return res.json({
+      maxOriginAmount,
+      minOriginAmount,
+    })
+  } catch (err) {
+    res.status(500).json({
+      error:
+        'An unexpected error occurred in /bridgeLimits. Please try again later.',
+      details: err.message,
+    })
+  }
+}

packages/rest-api/src/routes/bridgeLimitsRoute.ts

@@ -0,0 +1,50 @@
+import express from 'express'
+import { check } from 'express-validator'
+
+import { CHAINS_ARRAY } from '../constants/chains'
+import { showFirstValidationError } from '../middleware/showFirstValidationError'
+import { bridgeLimitsController } from '../controllers/bridgeLimitsController'
+import { isTokenSupportedOnChain } from './../utils/isTokenSupportedOnChain'
+import { isTokenAddress } from '../utils/isTokenAddress'
+
+const router = express.Router()
+
+router.get(
+  '/',
+  [
+    check('fromChain')
+      .exists()
+      .withMessage('fromChain is required')
+      .isNumeric()
+      .custom((value) => CHAINS_ARRAY.some((c) => c.id === Number(value)))
+      .withMessage('Unsupported fromChain'),
+    check('toChain')
+      .exists()
+      .withMessage('Unsupported toChain')
+      .isNumeric()
+      .custom((value) => CHAINS_ARRAY.some((c) => c.id === Number(value)))
+      .withMessage('toChain is required'),
+    check('fromToken')
+      .exists()
+      .withMessage('fromToken is required')
+      .custom((value) => isTokenAddress(value))
+      .withMessage('Invalid fromToken address')
+      .custom((value, { req }) =>
+        isTokenSupportedOnChain(value, req.query.fromChain as string)
+      )
+      .withMessage('Token not supported on specified chain'),
+    check('toToken')
+      .exists()
+      .withMessage('toToken is required')
+      .custom((value) => isTokenAddress(value))
+      .withMessage('Invalid toToken address')
+      .custom((value, { req }) =>
+        isTokenSupportedOnChain(value, req.query.toChain as string)
+      )
+      .withMessage('Token not supported on specified chain'),
+  ],
+  showFirstValidationError,
+  bridgeLimitsController
+)
+
+export default router

packages/rest-api/src/routes/index.ts

@@ -10,6 +10,7 @@ import bridgeTxStatusRoute from './bridgeTxStatusRoute'
 import destinationTxRoute from './destinationTxRoute'
 import tokenListRoute from './tokenListRoute'
 import destinationTokensRoute from './destinationTokensRoute'
+import bridgeLimitsRoute from './bridgeLimitsRoute'
 
 const router = express.Router()
 
@@ -18,6 +19,7 @@ router.use('/swap', swapRoute)
 router.use('/swapTxInfo', swapTxInfoRoute)
 router.use('/bridge', bridgeRoute)
 router.use('/bridgeTxInfo', bridgeTxInfoRoute)
+router.use('/bridgeLimits', bridgeLimitsRoute)
 router.use('/synapseTxId', synapseTxIdRoute)
 router.use('/bridgeTxStatus', bridgeTxStatusRoute)
 router.use('/destinationTx', destinationTxRoute)

packages/rest-api/src/tests/bridgeLimitsRoute.test.ts

@@ -0,0 +1,81 @@
+import request from 'supertest'
+import express from 'express'
+
+import bridgeLimitsRoute from '../routes/bridgeLimitsRoute'
+import { USDC, ETH } from '../constants/bridgeable'
+
+const app = express()
+app.use('/bridgeLimits', bridgeLimitsRoute)
+
+describe('Get Bridge Limits Route', () => {
+  it('should return min/max origin amounts bridging USDC', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: 1,
+      fromToken: USDC.addresses[1],
+      toChain: 10,
+      toToken: USDC.addresses[10],
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.body).toHaveProperty('maxOriginAmount')
+    expect(response.body).toHaveProperty('minOriginAmount')
+  }, 10_000)
+
+  it('should return min/max origin amounts bridging ETH', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: 1,
+      fromToken: ETH.addresses[1],
+      toChain: 10,
+      toToken: ETH.addresses[10],
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.body).toHaveProperty('maxOriginAmount')
+    expect(response.body).toHaveProperty('minOriginAmount')
+  }, 10_000)
+
+  it('should return 400 for unsupported fromChain', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: '999',
+      toChain: '137',
+      fromToken: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff',
+      toToken: USDC.addresses[137],
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty(
+      'message',
+      'Unsupported fromChain'
+    )
+  }, 10_000)
+
+  it('should return 400 for unsupported toChain', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: '137',
+      toChain: '999',
+      fromToken: USDC.addresses[137],
+      toToken: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff',
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty('message', 'Unsupported toChain')
+  }, 10_000)
+
+  it('should return 400 for missing fromToken', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: '1',
+      toChain: '137',
+      toToken: USDC.addresses[137],
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty('field', 'fromToken')
+  }, 10_000)
+
+  it('should return 400 for missing toToken', async () => {
+    const response = await request(app).get('/bridgeLimits').query({
+      fromChain: '1',
+      toChain: '137',
+      fromToken: USDC.addresses[1],
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty('field', 'toToken')
+  }, 10_000)
+})

packages/rest-api/src/utils/bridgeLimitMapping.ts

@@ -0,0 +1,104 @@
+import { BRIDGE_MAP } from '../constants/bridgeMap'
+import * as ALL_TOKENS from '../constants/bridgeable'
+
+const constructJSON = (swappableMap, exclusionList) => {
+  const result = {}
+
+  // Iterate through the origin chains
+  for (const originChainId in swappableMap) {
+    for (const originTokenAddress in swappableMap[originChainId]) {
+      const originToken = swappableMap[originChainId][originTokenAddress]
+      const originKey = `${originToken.symbol}-${originChainId}`
+
+      // Use transformPair to get token object
+      const transformedOriginToken = transformPair(originKey)
+
+      if (!transformedOriginToken || exclusionList.includes(originKey)) {
+        continue
+      }
+
+      // Initialize origin chain and origin token with symbol and swappableType if not existing
+      if (!result[originChainId]) {
+        result[originChainId] = {}
+      }
+
+      if (!result[originChainId][transformedOriginToken.address]) {
+        result[originChainId][transformedOriginToken.address] = {
+          symbol: transformedOriginToken.symbol,
+          swappableType: transformedOriginToken.swapableType, // Fetch swappableType
+          routes: {},
+        }
+      }
+
+      // Iterate through destination chains
+      for (const destinationChainId in swappableMap) {
+        if (originChainId === destinationChainId) {
+          continue
+        }
+
+        for (const destinationTokenAddress in swappableMap[
+          destinationChainId
+        ]) {
+          const destinationToken =
+            swappableMap[destinationChainId][destinationTokenAddress]
+          const destinationKey = `${destinationToken.symbol}-${destinationChainId}`
+
+          // Use transformPair for destination token as well
+          const transformedDestinationToken = transformPair(destinationKey)
+
+          if (
+            !transformedDestinationToken ||
+            exclusionList.includes(destinationKey)
+          ) {
+            continue
+          }
+
+          // Check for bridge compatibility by comparing origin and destination symbols
+          for (const bridgeSymbol of originToken.origin) {
+            if (
+              originToken.origin.includes(bridgeSymbol) &&
+              destinationToken.destination.includes(bridgeSymbol)
+            ) {
+              // Initialize destination token with symbol, minValue, maxValue if not existing
+              if (
+                !result[originChainId][transformedOriginToken.address].routes[
+                  destinationChainId
+                ]
+              ) {
+                result[originChainId][transformedOriginToken.address].routes[
+                  destinationChainId
+                ] = {}
+              }
+
+              result[originChainId][transformedOriginToken.address].routes[
+                destinationChainId
+              ][transformedDestinationToken.address] = {
+                symbol: transformedDestinationToken.symbol,
+                minOriginValue: null,
+                maxOriginValue: null,
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+export const transformPair = (string: string): any => {
+  const [symbol, chainId] = string.split('-')
+  const token = Object.values(ALL_TOKENS).find((t) => t.routeSymbol === symbol)
+  const address = token?.addresses[chainId]
+  if (token && address) {
+    return {
+      symbol,
+      chainId,
+      address,
+      swapableType: token.swapableType,
+    }
+  }
+}
+
+export const BRIDGE_LIMIT_MAPPING = constructJSON(BRIDGE_MAP, [])