@paraswap/dex-lib 3.7.9-dex-deprecation.0 → 3.8.0

package/src/dex/curve-v1-factory/state-polling-pools/pool-polling-base.ts

@@ -5,7 +5,13 @@ import {
   MAX_ALLOWED_STATE_DELAY_FACTOR,
   MIN_LIQUIDITY_IN_USD,
 } from '../constants';
-import { CurveV1FactoryData, PoolConstants, PoolState } from '../types';
+import {
+  CurveV1FactoryData,
+  ImplementationNames,
+  PoolConstants,
+  PoolContextConstants,
+  PoolState,
+} from '../types';
 import { Address } from '@paraswap/core';
 
 export type MulticallReturnedTypes = bigint | bigint[];
@@ -38,11 +44,12 @@ export abstract class PoolPollingBase {
     readonly dexKey: string,
     readonly network: number,
     readonly cacheStateKey: string,
-    readonly implementationName: string,
+    readonly implementationName: ImplementationNames,
     readonly implementationAddress: Address,
     readonly stateUpdatePeriodMs: number,
     readonly poolIdentifier: string,
     readonly poolConstants: PoolConstants,
+    readonly poolContextConstants: PoolContextConstants,
     readonly address: Address,
     readonly curveLiquidityApiSlug: string,
     readonly isLendingPool: boolean,
@@ -120,10 +127,17 @@ export abstract class PoolPollingBase {
 
     if (iC !== undefined && jC !== undefined) {
       return {
-        exchange: this.address,
-        i: iC,
-        j: jC,
-        underlyingSwap: false,
+        path: [
+          {
+            tokenIn: srcAddress,
+            tokenOut: destAddress,
+            exchange: this.address,
+            i: iC,
+            j: jC,
+            underlyingSwap: false,
+            n_coins: this.poolConstants.COINS.length,
+          },
+        ],
       };
     }
 
@@ -140,10 +154,17 @@ export abstract class PoolPollingBase {
       // I expect them to be included in old CurveV1 implementation
       if (iU !== undefined && jU !== undefined && !(iU > 0 && jU > 0)) {
         return {
-          exchange: this.address,
-          i: iU,
-          j: jU,
-          underlyingSwap: true,
+          path: [
+            {
+              tokenIn: srcAddress,
+              tokenOut: destAddress,
+              exchange: this.address,
+              i: iU,
+              j: jU,
+              underlyingSwap: true,
+              n_coins: this.poolConstants.COINS.length,
+            },
+          ],
         };
       }
     }

package/src/dex/curve-v1-factory/types.ts

@@ -15,6 +15,7 @@ export type PoolContextConstants = {
   // for all pools
   isWrapNative: boolean;
   isLending: boolean;
+  isStable?: boolean;
 
   // Starting from this point, constants are context relevant for pricing
 
@@ -68,10 +69,15 @@ export type PoolStateWithUpdateInfo<T> = {
 };
 
 export type CurveV1FactoryData = {
-  exchange: Address;
-  i: number;
-  j: number;
-  underlyingSwap: boolean;
+  path: {
+    tokenIn: Address;
+    tokenOut: Address;
+    exchange: Address;
+    i: number;
+    j: number;
+    underlyingSwap: boolean;
+    n_coins: number;
+  }[];
   isApproved?: boolean;
 };
 
@@ -118,8 +124,6 @@ export enum FactoryImplementationNames {
   FACTORY_PLAIN_4_OPTIMIZED = 'factory_plain_4_optimized',
 
   FACTORY_STABLE_NG = 'factory_stable_ng',
-  // FACTORY_STABLE_6_NG = 'factory_stable_6_ng',
-  // FACTORY_STABLE_8_NG = 'factory_stable_8_ng',
 }
 
 export enum CustomImplementationNames {
@@ -188,6 +192,7 @@ type DexParamFactory = {
 
 export type DexParams = {
   factories: DexParamFactory[] | null;
+  router: Address;
   stateUpdatePeriodMs: number;
   factoryPoolImplementations: Record<Address, FactoryPoolImplementations>;
   customPools: Record<string, CustomPoolConfig>;
@@ -202,8 +207,19 @@ export enum CurveSwapFunctions {
   exchange_underlying = 'exchange_underlying',
 }
 
+export enum CurveRouterSwapType {
+  exchange = 1,
+  exchange_underlying = 2,
+}
+
+export enum CurveRouterPoolType {
+  non_stable = 0,
+  stable = 10,
+}
+
 export type CurveV1FactoryIfaces = {
   exchangeRouter: Interface;
+  curveV1Router: Interface;
   factory: Interface;
   erc20: Interface;
   threePool: Interface;

package/src/dex/curve-v1-stable-ng/config.ts

@@ -13,6 +13,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x16C6521Dff6baB339122a0FE25a9116693265353', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 5 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -59,6 +60,18 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           liquidityApiSlug: '/factory-stable-ng',
           isStoreRateSupported: true,
         },
+        '0xc65cb3156225380beda366610bab18d5835a1647': {
+          name: ImplementationNames.FACTORY_STABLE_NG,
+          address: '0xc65cb3156225380beda366610bab18d5835a1647',
+          liquidityApiSlug: '/factory-stable-ng',
+          isStoreRateSupported: true,
+        },
+        '0xa0ec67a3c483674f77915893346a8ca3abe2b785': {
+          name: ImplementationNames.FACTORY_STABLE_NG,
+          address: '0xa0ec67a3c483674f77915893346a8ca3abe2b785',
+          liquidityApiSlug: '/factory-stable-ng',
+          isStoreRateSupported: true,
+        },
       },
       customPools: {},
     },
@@ -69,6 +82,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -95,6 +109,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -115,6 +130,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x2191718CD32d02B8E60BAdFFeA33E4B5DD9A0A0D', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -141,6 +157,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x0DCDED3545D565bA3B19E683431381007245d983', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),
@@ -161,6 +178,7 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
           isStableNg: true,
         },
       ],
+      router: '0x4f37A9d177470499A2dD084621020b023fcffc1F', // https://github.com/curvefi/curve-router-ng
       stateUpdatePeriodMs: 2 * 1000,
       disabledPools: new Set([]),
       disabledImplementations: new Set([]),

package/src/dex/curve-v1-stable-ng/curve-v1-stable-ng-e2e.test.ts

@@ -63,6 +63,23 @@ describe('CurveV1StableNG E2E', () => {
         sidesToContractMethods,
       );
     });
+
+    describe('GHO -> crvUSD', () => {
+      const tokenASymbol: string = 'GHO';
+      const tokenBSymbol: string = 'crvUSD';
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '1000000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+      );
+    });
   });
 
   describe('Polygon', () => {

package/src/dex/index.ts

@@ -2,10 +2,12 @@ import _ from 'lodash';
 import { UnoptimizedRate } from '../types';
 import { CurveV2 } from './curve-v2/curve-v2';
 import { IDexTxBuilder, DexConstructor, IDex, IRouteOptimizer } from './idex';
+import { Jarvis } from './jarvis';
 import { JarvisV6 } from './jarvis-v6/jarvis-v6';
 import { StablePool } from './stable-pool/stable-pool';
 import { Weth } from './weth/weth';
 import { PolygonMigrator } from './polygon-migrator/polygon-migrator';
+import { ZeroX } from './zerox';
 import { UniswapV3 } from './uniswap-v3/uniswap-v3';
 import { BalancerV2 } from './balancer-v2/balancer-v2';
 import { balancerV2Merge } from './balancer-v2/optimizer';
@@ -16,10 +18,15 @@ import { BiSwap } from './uniswap-v2/biswap';
 import { MDEX } from './uniswap-v2/mdex';
 import { Dfyn } from './uniswap-v2/dfyn';
 import { Bancor } from './bancor/bancor';
+import { BProtocol } from './bProtocol/bProtocol';
+import { MStable } from './mStable';
+import { Shell } from './shell';
+import { Onebit } from './onebit/onebit';
 import { Compound } from './compound/compound';
 import { AaveV2 } from './aave-v2/aave-v2';
 import { AaveV3 } from './aave-v3/aave-v3';
 import { IdleDao } from './idle-dao/idle-dao';
+import { OneInchLp } from './OneInchLp';
 import { DodoV1 } from './dodo-v1/dodo-v1';
 import { DodoV2 } from './dodo-v2';
 import { Smoothy } from './smoothy/smoothy';
@@ -55,6 +62,7 @@ import { CurveFork } from './curve-v1/forks/curve-forks/curve-forks';
 import { Swerve } from './curve-v1/forks/swerve/swerve';
 import { CurveV1Factory } from './curve-v1-factory/curve-v1-factory';
 import { CurveV1StableNg } from './curve-v1-stable-ng/curve-v1-stable-ng';
+import { curveV1Merge } from './curve-v1-factory/optimizer';
 import { GenericRFQ } from './generic-rfq/generic-rfq';
 import { WstETH } from './wsteth/wsteth';
 import { Camelot } from './camelot/camelot';
@@ -64,6 +72,7 @@ import { MaverickV1 } from './maverick-v1/maverick-v1';
 import { MaverickV2 } from './maverick-v2/maverick-v2';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ThenaFusion } from './quickswap/thena-fusion';
+import { TraderJoeV2 } from './trader-joe-v2';
 import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { TraderJoeV21 } from './trader-joe-v2.1/trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
@@ -85,13 +94,21 @@ const LegacyDexes = [
   CurveV2,
   StablePool,
   Smoothy,
+  ZeroX,
   Bancor,
+  BProtocol,
+  MStable,
+  Shell,
+  Onebit,
   Compound,
+  OneInchLp,
   DodoV1,
   DodoV2,
   QuickSwapV3,
   ThenaFusion,
+  TraderJoeV2,
   TraderJoeV21,
+  Jarvis,
   Lido,
   AugustusRFQOrder,
   EtherFi,
@@ -187,6 +204,7 @@ export class DexAdapterService {
     balancerV1Merge,
     balancerV2Merge,
     uniswapMerge,
+    curveV1Merge,
   ];
 
   constructor(

package/src/dex/jarvis.ts

@@ -0,0 +1,262 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { NULL_ADDRESS, SwapSide } from '../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../types';
+import { IDexTxBuilder } from './idex';
+import { SimpleExchange } from './simple-exchange';
+import JarvisABI from '../abi/Jarvis.json';
+import Web3 from 'web3';
+import { IDexHelper } from '../dex-helper';
+import { extractReturnAmountPosition } from '../executor/utils';
+
+const THIRTY_MINUTES = 60 * 30;
+
+export type JarvisData = {
+  derivatives: string;
+  destDerivatives?: string;
+  pools: string[];
+  fee: string;
+  method: JarvisFunctions;
+  router: Address;
+};
+
+type JarvisMintParam = [
+  derivative: string,
+  minNumTokens: string,
+  collateralAmount: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisRedeemParam = [
+  derivative: string,
+  numTokens: string,
+  minCollateral: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisExchangeParam = [
+  derivative: string,
+  destPool: string,
+  destDerivative: string,
+  numTokens: string,
+  minDestNumTokens: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisParam = JarvisExchangeParam | JarvisMintParam | JarvisRedeemParam;
+
+enum JarvisFunctions {
+  mint = 'mint',
+  redeem = 'redeem',
+  exchange = 'exchange',
+}
+
+export class Jarvis
+  extends SimpleExchange
+  implements IDexTxBuilder<JarvisData, JarvisParam>
+{
+  static dexKeys = ['jarvis'];
+  poolInterface: Interface;
+  needWrapNative = false;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'jarvis');
+    this.poolInterface = new Interface(JarvisABI as JsonFragment[]);
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: JarvisData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { method } = data;
+    const type = [
+      JarvisFunctions.mint,
+      JarvisFunctions.redeem,
+      JarvisFunctions.exchange,
+    ].indexOf(method);
+
+    if (type === undefined) {
+      throw new Error(
+        `Jarvis: Invalid OpType ${method}, Should be one of ['mint', 'exchange', 'redeem']`,
+      );
+    }
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          opType: 'uint',
+          derivatives: 'address',
+          destDerivatives: 'address',
+          fee: 'uint128',
+          destPool: 'address',
+          expiration: 'uint128',
+        },
+      },
+      {
+        opType: type,
+        derivatives: data.derivatives,
+        destDerivatives: data.destDerivatives || NULL_ADDRESS,
+        fee: data.fee,
+        destPool: data.pools[1] || NULL_ADDRESS,
+        expiration: (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0),
+      },
+    );
+
+    return {
+      targetExchange: data.pools[0],
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: JarvisData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = data.method;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+    let swapFunctionParams: JarvisParam;
+    switch (swapFunction) {
+      case JarvisFunctions.mint:
+        swapFunctionParams = [
+          data.derivatives,
+          destAmount,
+          srcAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      case JarvisFunctions.redeem:
+        swapFunctionParams = [
+          data.derivatives,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      case JarvisFunctions.exchange:
+        swapFunctionParams = [
+          data.derivatives,
+          data.pools[1],
+          data.destDerivatives!,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+
+    const swapData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.pools[0],
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: JarvisData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = data.method;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+    let swapFunctionParams: JarvisParam;
+    let outputName: string;
+
+    switch (swapFunction) {
+      case JarvisFunctions.mint:
+        swapFunctionParams = [
+          data.derivatives,
+          destAmount,
+          srcAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'syntheticTokensMinted';
+        break;
+      case JarvisFunctions.redeem:
+        swapFunctionParams = [
+          data.derivatives,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'collateralRedeemed';
+        break;
+      case JarvisFunctions.exchange:
+        swapFunctionParams = [
+          data.derivatives,
+          data.pools[1],
+          data.destDerivatives!,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'destNumTokensMinted';
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+
+    const swapData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pools[0],
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.poolInterface,
+              swapFunction,
+              outputName,
+            )
+          : undefined,
+    };
+  }
+}

package/src/dex/mStable.ts

@@ -0,0 +1,147 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { Provider } from '@ethersproject/providers';
+import { SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import { IDexTxBuilder } from './idex';
+import { SimpleExchange } from './simple-exchange';
+import MStableAssetABI from '../abi/MStableAsset.json';
+import Web3 from 'web3';
+import { IDexHelper } from '../dex-helper';
+
+enum MStableFunctions {
+  mint = 'mint',
+  swap = 'swap',
+  redeem = 'redeem',
+}
+type MStableData = {
+  exchange: string;
+  opType: MStableFunctions;
+  isAssetContract: boolean;
+};
+type MStableMint = [
+  _input: string,
+  _inputQuantity: string,
+  _minOutputQuantity: string,
+  _recipient: string,
+];
+type MStableSwap = [
+  _input: string,
+  _output: string,
+  _inputQuantity: string,
+  _minOutputQuantity: string,
+  _recipient: string,
+];
+type MStableRedeem = [
+  _output: string,
+  _mAssetQuantity: string,
+  _minOutputQuantity: string,
+  _recipient: string,
+];
+
+type MStableParam = MStableMint | MStableSwap | MStableRedeem;
+
+export class MStable
+  extends SimpleExchange
+  implements IDexTxBuilder<MStableData, MStableParam>
+{
+  static dexKeys = ['mStable'];
+  mStableAsset: Interface;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'mStable');
+    this.mStableAsset = new Interface(MStableAssetABI as JsonFragment[]);
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: MStableData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { opType } = data;
+    const type = [
+      MStableFunctions.swap,
+      MStableFunctions.mint,
+      MStableFunctions.redeem,
+    ].indexOf(opType);
+
+    if (type === undefined) {
+      throw new Error(
+        `mStable: Invalid OpType ${opType}, Should be one of ['mint', 'swap', 'redeem']`,
+      );
+    }
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          opType: 'uint',
+        },
+      },
+      {
+        opType: type,
+      },
+    );
+
+    return {
+      targetExchange: data.exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: MStableData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const { opType, isAssetContract } = data;
+
+    const [swapFunction, swapFunctionsParams] = ((): [
+      MStableFunctions,
+      MStableParam,
+    ] => {
+      switch (opType) {
+        case MStableFunctions.mint:
+          return [
+            opType,
+            [srcToken, srcAmount, destAmount, this.augustusAddress],
+          ];
+        case MStableFunctions.swap:
+          return [
+            opType,
+            [srcToken, destToken, srcAmount, destAmount, this.augustusAddress],
+          ];
+        case MStableFunctions.redeem:
+          return [
+            opType,
+            [destToken, srcAmount, destAmount, this.augustusAddress],
+          ];
+        default:
+          throw new Error(
+            `mStable's OpType ${opType} not supported, failed to build`,
+          );
+      }
+    })();
+
+    // mStableAsset & mStablePool both have the same interface hence we can
+    // simply use mStableAsset contract
+    const swapData = this.mStableAsset.encodeFunctionData(
+      swapFunction,
+      swapFunctionsParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.exchange,
+    );
+  }
+}