Merge branch 'feat/sdk-syn-intents' into staging/syn-intents-api-sdk

packages/sdk-router/src/rfq/engine/defaultEngine.ts

@@ -9,7 +9,6 @@ import {
   SYNAPSE_INTENT_PREVIEWER_ADDRESS_MAP,
   SWAP_QUOTER_V2_ADDRESS_MAP,
 } from '../../constants/addresses'
-import { BigintIsh } from '../../constants'
 import { ChainProvider } from '../../router'
 import { SynapseIntentPreviewer as PreviewerContract } from '../../typechain/SynapseIntentPreviewer'
 import { IDefaultActionsInterface } from '../../typechain/IDefaultActions'
@@ -21,10 +20,10 @@ import {
   Recipient,
   RecipientEntity,
   EngineID,
-  Slippage,
   toWei,
   applySlippage,
   isCorrectSlippage,
+  RouteInput,
 } from './swapEngine'
 
 export class DefaultEngine implements SwapEngine {
@@ -69,14 +68,9 @@ export class DefaultEngine implements SwapEngine {
     })
   }
 
-  public async findRoute(
-    chainId: number,
-    tokenIn: string,
-    tokenOut: string,
-    amountIn: BigintIsh,
-    finalRecipient: Recipient,
-    slippage: Slippage
-  ): Promise<SwapEngineRoute> {
+  public async findRoute(input: RouteInput): Promise<SwapEngineRoute> {
+    const { chainId, tokenIn, tokenOut, amountIn, finalRecipient, slippage } =
+      input
     const { previewer, swapQuoter } = this.contracts[chainId]
     if (
       !previewer ||
@@ -112,6 +106,8 @@ export class DefaultEngine implements SwapEngine {
     }
   }
 
+  // TODO: findRoutes
+
   private getForwardTo(recipient: Recipient): string {
     return recipient.entity === RecipientEntity.Self
       ? AddressZero

packages/sdk-router/src/rfq/engine/engineSet.ts

@@ -14,7 +14,7 @@ import {
   USER_SIMULATED_ADDRESS,
   Slippage,
   SlippageDefault,
-  SlippageFull,
+  SlippageMax,
 } from './swapEngine'
 import { CCTPRouterQuery } from '../../module'
 import { encodeStepParams } from '../steps'
@@ -55,7 +55,7 @@ export class EngineSet {
     tokenIn: TokenInput,
     tokensOut: string[]
   ): Promise<SwapEngineRoute[]> {
-    const recipient: Recipient = {
+    const finalRecipient: Recipient = {
       entity: RecipientEntity.Self,
       address: this.getTokenZap(chainId),
     }
@@ -65,14 +65,14 @@ export class EngineSet {
       tokensOut.map(async (tokenOut) =>
         Promise.all(
           Object.values(this.engines).map(async (engine) =>
-            engine.findRoute(
+            engine.findRoute({
               chainId,
-              tokenIn.address,
+              tokenIn: tokenIn.address,
               tokenOut,
-              tokenIn.amount,
-              recipient,
-              SlippageFull
-            )
+              amountIn: tokenIn.amount,
+              finalRecipient,
+              slippage: SlippageMax,
+            })
           )
         )
       )
@@ -88,7 +88,7 @@ export class EngineSet {
   ): Promise<SwapEngineRoute[]> {
     // Check that the chain is supported
     this.getTokenZap(chainId)
-    const recipient: Recipient = {
+    const finalRecipient: Recipient = {
       entity: RecipientEntity.UserSimulated,
       address: USER_SIMULATED_ADDRESS,
     }
@@ -100,14 +100,14 @@ export class EngineSet {
       tokensIn.map(async (tokenIn) =>
         Promise.all(
           Object.values(this.engines).map(async (engine) => {
-            const route = await engine.findRoute(
+            const route = await engine.findRoute({
               chainId,
-              tokenIn.address,
+              tokenIn: tokenIn.address,
               tokenOut,
-              tokenIn.amount,
-              recipient,
-              SlippageFull
-            )
+              amountIn: tokenIn.amount,
+              finalRecipient,
+              slippage: SlippageMax,
+            })
             return this.limitSingleZap(route)
           })
         )
@@ -125,14 +125,14 @@ export class EngineSet {
     finalRecipient: Recipient,
     slippage: Slippage = SlippageDefault
   ): Promise<SwapEngineRoute> {
-    return this._getEngine(engineID).findRoute(
+    return this._getEngine(engineID).findRoute({
       chainId,
-      tokenIn.address,
+      tokenIn: tokenIn.address,
       tokenOut,
-      tokenIn.amount,
+      amountIn: tokenIn.amount,
       finalRecipient,
-      slippage
-    )
+      slippage,
+    })
   }
 
   public getOriginQuery(

packages/sdk-router/src/rfq/engine/noOpEngine.ts

@@ -1,18 +1,27 @@
 import { BigNumber } from 'ethers'
 
 import { isSameAddress } from '../../utils/addressUtils'
-import { SwapEngine, SwapEngineRoute, EmptyRoute, EngineID } from './swapEngine'
-import { BigintIsh } from '../../constants'
+import {
+  SwapEngine,
+  SwapEngineRoute,
+  EmptyRoute,
+  EngineID,
+  RouteInput,
+} from './swapEngine'
 
 export class NoOpEngine implements SwapEngine {
   public readonly id: EngineID = EngineID.NoOp
 
-  public async findRoute(
-    _chainId: number,
-    tokenIn: string,
-    tokenOut: string,
-    amountIn: BigintIsh
-  ): Promise<SwapEngineRoute> {
+  public async findRoute(input: RouteInput): Promise<SwapEngineRoute> {
+    return this._findRoute(input)
+  }
+
+  public async findRoutes(inputs: RouteInput[]): Promise<SwapEngineRoute[]> {
+    return inputs.map((input) => this._findRoute(input))
+  }
+
+  private _findRoute(input: RouteInput): SwapEngineRoute {
+    const { tokenIn, tokenOut, amountIn } = input
     if (!isSameAddress(tokenIn, tokenOut)) {
       return EmptyRoute
     }

packages/sdk-router/src/rfq/engine/paraSwapEngine.test.ts

@@ -5,7 +5,7 @@ import { ParaSwapEngine } from './paraSwapEngine'
 global.fetch = require('node-fetch')
 
 describe('Integration test: ParaSwapEngine', () => {
-  it('returns a response', async () => {
+  it('Ethereum USDC -> USDT', async () => {
     const paraSwapEngine = new ParaSwapEngine([], {})
     const response = await paraSwapEngine.getResponse({
       srcToken: ETH_USDC,
@@ -22,4 +22,21 @@ describe('Integration test: ParaSwapEngine', () => {
     expect(response).toBeDefined()
     console.log(JSON.stringify(response, null, 2))
   })
+
+  it('Arbitrum FRAX -> ETH', async () => {
+    const paraSwapEngine = new ParaSwapEngine([], {})
+    const response = await paraSwapEngine.getResponse({
+      srcToken: '0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F',
+      srcDecimals: 18,
+      destToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+      destDecimals: 18,
+      amount: '250160206404537300',
+      side: 'SELL',
+      userAddress: '0x289db76b9E19487190D356ecB64324A5c716fFe1',
+      network: '42161',
+      slippage: 9999,
+      version: '6.2',
+    })
+    console.log(JSON.stringify(response, null, 2))
+  })
 })

packages/sdk-router/src/rfq/engine/paraSwapEngine.ts

@@ -14,7 +14,7 @@ import {
   EngineID,
   isCorrectSlippage,
   Recipient,
-  Slippage,
+  RouteInput,
   SwapEngine,
   SwapEngineRoute,
 } from './swapEngine'
@@ -24,7 +24,7 @@ import { ChainProvider } from '../../router'
 import { isNativeToken } from '../../utils/handleNativeToken'
 
 const PARASWAP_API_URL = 'https://api.paraswap.io/swap'
-const PARASWAP_API_TIMEOUT = 1000
+const PARASWAP_API_TIMEOUT = 2000
 
 const MAX_SLIPPAGE = 9999
 
@@ -86,14 +86,9 @@ export class ParaSwapEngine implements SwapEngine {
     })
   }
 
-  public async findRoute(
-    chainId: number,
-    tokenIn: string,
-    tokenOut: string,
-    amountIn: BigintIsh,
-    finalRecipient: Recipient,
-    slippage: Slippage
-  ): Promise<SwapEngineRoute> {
+  public async findRoute(input: RouteInput): Promise<SwapEngineRoute> {
+    const { chainId, tokenIn, tokenOut, amountIn, finalRecipient, slippage } =
+      input
     const tokenZap = this.tokenZapAddressMap[chainId]
     if (
       !tokenZap ||
@@ -144,6 +139,8 @@ export class ParaSwapEngine implements SwapEngine {
     }
   }
 
+  // TODO: findRoutes
+
   public async getResponse(
     request: ParaSwapRequest
   ): Promise<ParaSwapResponse> {

packages/sdk-router/src/rfq/engine/swapEngine.ts

@@ -41,30 +41,34 @@ export type Slippage = {
   denominator: number
 }
 
+// Default slippage used by the swap engines, 10 bips (0.1%)
 export const SlippageDefault: Slippage = {
   numerator: 10,
   denominator: 10000,
 }
 
-export const SlippageFull: Slippage = {
-  numerator: 1,
-  denominator: 1,
+// Max slippage that can be used by the swap engines, 100 bips (1%)
+export const SlippageMax: Slippage = {
+  numerator: 100,
+  denominator: 10000,
 }
 
 export const USER_SIMULATED_ADDRESS =
   '0xFAcefaCEFACefACeFaCefacEFaCeFACEFAceFAcE'
 
+export type RouteInput = {
+  chainId: number
+  tokenIn: string
+  tokenOut: string
+  amountIn: BigintIsh
+  finalRecipient: Recipient
+  slippage: Slippage
+}
+
 export interface SwapEngine {
   readonly id: EngineID
 
-  findRoute(
-    chainId: number,
-    tokenIn: string,
-    tokenOut: string,
-    amountIn: BigintIsh,
-    finalRecipient: Recipient,
-    slippage: Slippage
-  ): Promise<SwapEngineRoute>
+  findRoute(input: RouteInput): Promise<SwapEngineRoute>
 }
 
 export const validateEngineID = (engineID: number): engineID is EngineID => {