@paraswap/dex-lib 2.16.2 → 2.16.3-rfq-direct.0

package/src/dex/generic-rfq/generic-rfq.ts

@@ -6,6 +6,7 @@ import {
   PreprocessTransactionOptions,
   Config,
   PoolLiquidity,
+  TxInfo,
 } from '../../types';
 import { Network, SwapSide } from '../../constants';
 import { IDexHelper } from '../../dex-helper';
@@ -15,12 +16,19 @@ import { ParaSwapLimitOrdersData } from '../paraswap-limit-orders/types';
 import { ONE_ORDER_GASCOST } from '../paraswap-limit-orders/constant';
 import { RateFetcher } from './rate-fetcher';
 import {
+  AugustusRFQRouterFunctions,
+  GenericRFQParam,
   PriceAndAmountBigNumber,
   RFQConfig,
   SlippageCheckError,
 } from './types';
-import { OptimalSwapExchange } from '@paraswap/core';
+import { Address, NumberAsString, OptimalSwapExchange } from '@paraswap/core';
 import { BI_MAX_UINT256 } from '../../bigint-constants';
+import { Interface } from 'ethers/lib/utils';
+import AugustusRFQRouterABI from '../../abi/AugustusRFQRouter.abi.json';
+import { IDexTxBuilder } from '../idex';
+import { isETHAddress } from '../../utils';
+import { assert } from 'ts-essentials';
 
 export const OVERORDER_BPS = 100;
 export const BPS_MAX_VALUE = 10000n;
@@ -28,10 +36,15 @@ export const BPS_MAX_VALUE = 10000n;
 export const overOrder = (amount: string, bps: number) =>
   ((BigInt(amount) * (BPS_MAX_VALUE + BigInt(bps))) / BPS_MAX_VALUE).toString();
 
-export class GenericRFQ extends ParaSwapLimitOrders {
+export class GenericRFQ
+  extends ParaSwapLimitOrders
+  implements IDexTxBuilder<ParaSwapLimitOrdersData, GenericRFQParam>
+{
   readonly isStatePollingDex = true;
   private rateFetcher: RateFetcher;
 
+  private routerInterface: Interface;
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] = [];
 
   static builderDexKeysWithNetwork(config: Config): void {
@@ -51,6 +64,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
   ) {
     super(network, dexKey, dexHelper);
     this.rateFetcher = new RateFetcher(dexHelper, config, dexKey, this.logger);
+    this.routerInterface = new Interface(AugustusRFQRouterABI);
   }
 
   async initializePricing(blockNumber: number): Promise<void> {
@@ -297,4 +311,58 @@ export class GenericRFQ extends ParaSwapLimitOrders {
       this.rateFetcher.stop();
     }
   }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ParaSwapLimitOrdersData,
+    side: SwapSide,
+    permit: string,
+    contractMethod: string,
+  ): TxInfo<GenericRFQParam> {
+    const usePermit = permit !== '0x';
+
+    assert(
+      contractMethod ===
+        (usePermit
+          ? AugustusRFQRouterFunctions.swapOnAugustusRFQWithPermit
+          : AugustusRFQRouterFunctions.swapOnAugustusRFQ),
+    );
+
+    if (data.orderInfos === null && data.orderInfos!.length === 1) {
+      throw new Error('`orderInfos` cannot be empty');
+    }
+
+    const encoder = (...params: GenericRFQParam) => {
+      return this.routerInterface.encodeFunctionData(
+        usePermit
+          ? AugustusRFQRouterFunctions.swapOnAugustusRFQWithPermit
+          : AugustusRFQRouterFunctions.swapOnAugustusRFQ,
+        params,
+      );
+    };
+
+    const wrapETH = isETHAddress(srcAmount) ? 1 : 0;
+    return {
+      params: usePermit
+        ? [
+            data.orderInfos![0].order,
+            data.orderInfos![0].signature,
+            wrapETH,
+            permit,
+          ]
+        : [data.orderInfos![0].order, data.orderInfos![0].signature, wrapETH],
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [
+      AugustusRFQRouterFunctions.swapOnAugustusRFQ,
+      AugustusRFQRouterFunctions.swapOnAugustusRFQWithPermit,
+    ];
+  }
 }

package/src/dex/generic-rfq/types.ts

@@ -1,7 +1,10 @@
 import BigNumber from 'bignumber.js';
 import { RequestConfig } from '../../dex-helper/irequest-wrapper';
 import { Address, Token } from '../../types';
-import { AugustusOrderWithString } from '../paraswap-limit-orders/types';
+import {
+  AugustusOrderWithString,
+  OrderInfoType,
+} from '../paraswap-limit-orders/types';
 
 export type Pair = {
   base: string;
@@ -96,3 +99,25 @@ export type RFQFirmRateResponse = {
 };
 
 export class SlippageCheckError extends Error {}
+
+export enum AugustusRFQRouterFunctions {
+  swapOnAugustusRFQ = 'swapOnAugustusRFQ',
+  swapOnAugustusRFQWithPermit = 'swapOnAugustusRFQWithPermit',
+}
+
+export type SwapOnGenericRFQParam = [
+  order: OrderInfoType,
+  signature: string,
+  wrapETH: number,
+];
+
+export type SwapOnGenericRFQWithPermitParam = [
+  order: OrderInfoType,
+  signature: string,
+  wrapETH: number,
+  permit: string,
+];
+
+export type GenericRFQParam =
+  | SwapOnGenericRFQParam
+  | SwapOnGenericRFQWithPermitParam;

package/src/dex/index.ts

@@ -215,7 +215,7 @@ export class DexAdapterService {
       this.genericRFQDexKeys.add(rfqName.toLowerCase());
     });
 
-    this.directFunctionsNames = [...LegacyDexes, ...Dexes]
+    this.directFunctionsNames = [...LegacyDexes, ...Dexes, GenericRFQ]
       .flatMap(dexAdapter => {
         const _dexAdapter = dexAdapter as IGetDirectFunctionName;
         return _dexAdapter.getDirectFunctionName

package/src/dex/paraswap-limit-orders/types.ts

@@ -58,16 +58,18 @@ export type DexParams = {
   rfqAddress: string;
 };
 
+export type OrderInfoType = Omit<
+  AugustusOrder,
+  'nonceAndMeta' | 'makerAmount' | 'takerAmount' | 'expiry'
+> & {
+  expiry: string;
+  nonceAndMeta: BigIntAsString;
+  makerAmount: BigIntAsString;
+  takerAmount: BigIntAsString;
+};
+
 export type OrderInfo = {
-  order: Omit<
-    AugustusOrder,
-    'nonceAndMeta' | 'makerAmount' | 'takerAmount' | 'expiry'
-  > & {
-    expiry: string;
-    nonceAndMeta: BigIntAsString;
-    makerAmount: BigIntAsString;
-    takerAmount: BigIntAsString;
-  };
+  order: OrderInfoType;
   signature: string;
   takerTokenFillAmount: BigIntAsString;
   permitTakerAsset: string;

package/tests/utils-e2e.ts

@@ -468,7 +468,7 @@ export async function newTestE2E({
           .addAllowance(
             senderAddress,
             config.tokenTransferProxyAddress,
-            amount.toString(),
+            MAX_UINT,
           );
       } else {
         srcToken
@@ -476,7 +476,7 @@ export async function newTestE2E({
           .addAllowance(
             senderAddress,
             config.tokenTransferProxyAddress,
-            (BigInt(MAX_UINT) / 8n).toString(),
+            MAX_UINT,
           );
       }