[wip] feat(api): bridge limit script

packages/rest-api/package.json

@@ -18,10 +18,12 @@
     "postinstall": "npm run build"
   },
   "dependencies": {
+    "@ethersproject/address": "^5.7.0",
     "@ethersproject/bignumber": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
     "@ethersproject/units": "5.7.0",
     "@synapsecns/sdk-router": "^0.11.1",
+    "axios": "^1.7.7",
     "bignumber": "^1.1.0",
     "ethers": "5.7.2",
     "express": "^4.18.2",

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

@@ -0,0 +1,118 @@
+import axios from 'axios'
+import { validationResult } from 'express-validator'
+import { BigNumber } from 'ethers'
+import { parseUnits } from '@ethersproject/units'
+import { getAddress } from '@ethersproject/address'
+
+import { Synapse } from '../services/synapseService'
+import { tokenAddressToToken } from '../utils/tokenAddressToToken'
+
+export const getBridgeLimitsController = 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 rfqResponse = await axios.get('https://rfq-api.omnirpc.io/quotes', {
+      params: {
+        originChainId: fromChain,
+        originTokenAddress: fromTokenInfo.address,
+        destChainId: toChain,
+        destTokenAddress: toTokenInfo.address,
+      },
+    })
+
+    const rfqQuotes = rfqResponse.data
+
+    let bestRfqQuote = null
+
+    if (Array.isArray(rfqQuotes) && rfqQuotes.length > 0) {
+      const filteredQuotes = rfqQuotes
+        .slice(0, 20)
+        .filter(
+          (quote) =>
+            Number(quote.origin_chain_id) === Number(fromChain) &&
+            Number(quote.dest_chain_id) === Number(toChain) &&
+            getAddress(quote.origin_token_addr) ===
+              getAddress(fromTokenInfo.address) &&
+            getAddress(quote.dest_token_addr) ===
+              getAddress(toTokenInfo.address)
+        )
+
+      bestRfqQuote = filteredQuotes.reduce((maxQuote, currentQuote) => {
+        const currentAmount = Number(currentQuote.max_origin_amount)
+        const maxAmount = maxQuote ? Number(maxQuote.max_origin_amount) : 0
+        return currentAmount > maxAmount ? currentQuote : maxQuote
+      }, null)
+    }
+
+    const upperLimitAmount = parseUnits('1000000', fromTokenInfo.decimals)
+    const upperLimitBridgeQuotes = await Synapse.allBridgeQuotes(
+      Number(fromChain),
+      Number(toChain),
+      fromTokenInfo.address,
+      toTokenInfo.address,
+      upperLimitAmount
+    )
+
+    const lowerLimitAmount = parseUnits('100', fromTokenInfo.decimals)
+    const lowerLimitBridgeQuotes = await Synapse.allBridgeQuotes(
+      Number(fromChain),
+      Number(toChain),
+      fromTokenInfo.address,
+      toTokenInfo.address,
+      lowerLimitAmount
+    )
+
+    const bestUpperLimitSDKQuote = upperLimitBridgeQuotes[0]
+
+    let maxOriginQuote
+
+    const minBridgeFeeQuote = lowerLimitBridgeQuotes.reduce(
+      (minQuote, currentQuote) => {
+        const currentFeeAmount = currentQuote.feeAmount
+        const minFeeAmount = minQuote ? minQuote.feeAmount : null
+
+        return !minFeeAmount || currentFeeAmount.lt(minFeeAmount)
+          ? currentQuote
+          : minQuote
+      },
+      null
+    )
+
+    if (bestRfqQuote) {
+      const bestRfqQuoteMaxAmountBN = BigNumber.from(
+        bestRfqQuote.max_origin_amount
+      )
+      maxOriginQuote = bestRfqQuoteMaxAmountBN.gt(
+        bestUpperLimitSDKQuote.maxAmountOut
+      )
+        ? { source: 'RFQ', amount: bestRfqQuoteMaxAmountBN }
+        : {
+            source: bestUpperLimitSDKQuote.bridgeModuleName,
+            amount: bestUpperLimitSDKQuote.maxAmountOut,
+          }
+    } else {
+      maxOriginQuote = {
+        source: bestUpperLimitSDKQuote.bridgeModuleName,
+        amount: bestUpperLimitSDKQuote.maxAmountOut,
+      }
+    }
+
+    return res.json({
+      maxOriginAmount: maxOriginQuote.amount,
+      minOriginAmount: minBridgeFeeQuote.feeAmount,
+    })
+  } catch (err) {
+    res.status(500).json({
+      error:
+        'An unexpected error occurred in /getBridgeLimits. Please try again later.',
+      details: err.message,
+    })
+  }
+}

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

@@ -0,0 +1,41 @@
+import express from 'express'
+import { check } from 'express-validator'
+import { isAddress } from '@ethersproject/address'
+
+import { CHAINS_ARRAY } from '../constants/chains'
+import { showFirstValidationError } from '../middleware/showFirstValidationError'
+import { getBridgeLimitsController } from '../controllers/getBridgeLimitsController'
+
+const router = express.Router()
+
+router.get(
+  '/',
+  [
+    check('fromChain')
+      .isNumeric()
+      .custom((value) => CHAINS_ARRAY.some((c) => c.id === Number(value)))
+      .withMessage('Unsupported fromChain')
+      .exists()
+      .withMessage('originChainId is required'),
+    check('toChain')
+      .isNumeric()
+      .custom((value) => CHAINS_ARRAY.some((c) => c.id === Number(value)))
+      .withMessage('Unsupported toChain')
+      .exists()
+      .withMessage('toChain is required'),
+    check('fromToken')
+      .exists()
+      .withMessage('fromToken is required')
+      .custom((value) => isAddress(value))
+      .withMessage('Invalid fromToken address'),
+    check('toToken')
+      .exists()
+      .withMessage('toToken is required')
+      .custom((value) => isAddress(value))
+      .withMessage('Invalid toToken address'),
+  ],
+  showFirstValidationError,
+  getBridgeLimitsController
+)
+
+export default router

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

@@ -5,6 +5,7 @@ import swapRoute from './swapRoute'
 import swapTxInfoRoute from './swapTxInfoRoute'
 import bridgeRoute from './bridgeRoute'
 import bridgeTxInfoRoute from './bridgeTxInfoRoute'
+import getBridgeLimitsRoute from './getBridgeLimitsRoute'
 import getSynapseTxIdRoute from './getSynapseTxIdRoute'
 import getBridgeTxStatusRoute from './getBridgeTxStatusRoute'
 import getDestinationTxRoute from './getDestinationTxRoute'
@@ -17,6 +18,7 @@ router.use('/swap', swapRoute)
 router.use('/swapTxInfo', swapTxInfoRoute)
 router.use('/bridge', bridgeRoute)
 router.use('/bridgeTxInfo', bridgeTxInfoRoute)
+router.use('/getBridgeLimits', getBridgeLimitsRoute)
 router.use('/getSynapseTxId', getSynapseTxIdRoute)
 router.use('/getBridgeTxStatus', getBridgeTxStatusRoute)
 router.use('/getDestinationTx', getDestinationTxRoute)

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

@@ -0,0 +1,81 @@
+import request from 'supertest'
+import express from 'express'
+
+import getBridgeLimitsRoute from '../routes/getBridgeLimitsRoute'
+
+const app = express()
+app.use('/getBridgeLimits', getBridgeLimitsRoute)
+
+describe('Get Bridge Limits Route', () => {
+  it('should return min/max origin amounts for valid input', async () => {
+    const response = await request(app).get('/getBridgeLimits').query({
+      fromChain: 1,
+      fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+      toChain: 10,
+      toToken: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+    })
+
+    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('/getBridgeLimits').query({
+      fromChain: '999',
+      toChain: '137',
+      fromToken: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff',
+      toToken: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty(
+      'message',
+      'Unsupported fromChain'
+    )
+  }, 10_000)
+
+  it('should return 400 for unsupported ', async () => {
+    const response = await request(app).get('/getBridgeLimits').query({
+      fromChain: '999',
+      toChain: '137',
+      fromToken: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff',
+      toToken: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+    })
+    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('/getBridgeLimits').query({
+      fromChain: '137',
+      toChain: '999',
+      fromToken: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+      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('/getBridgeLimits').query({
+      fromChain: '1',
+      toChain: '137',
+      toToken: '0x176211869cA2b568f2A7D4EE941E073a821EE1ff',
+    })
+    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('/getBridgeLimits').query({
+      fromChain: '1',
+      toChain: '137',
+      fromToken: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    })
+    expect(response.status).toBe(400)
+    expect(response.body.error).toHaveProperty('field', 'toToken')
+  }, 10_000)
+})

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

@@ -0,0 +1,17 @@
+import { BRIDGE_MAP } from '../constants/bridgeMap'
+
+export const tokenAddressToToken = (chain: string, tokenAddress: string) => {
+  const chainData = BRIDGE_MAP[chain]
+  if (!chainData) {
+    return null
+  }
+  const tokenInfo = chainData[tokenAddress]
+  if (!tokenInfo) {
+    return null
+  }
+  return {
+    address: tokenAddress,
+    symbol: tokenInfo.symbol,
+    decimals: tokenInfo.decimals,
+  }
+}