@paraswap/dex-lib 3.8.2 → 3.8.3-integral-dex

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,
+    );
+  }
+}

package/src/dex/onebit/onebit.ts

@@ -0,0 +1,113 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { Provider } from '@ethersproject/providers';
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import OnebitABI from '../../abi/Onebit.json';
+import { IDexHelper } from '../../dex-helper';
+import { OnebitData, OnebitFunctions, OnebitParam } from './types';
+import { extractReturnAmountPosition } from '../../executor/utils';
+
+export class Onebit
+  extends SimpleExchange
+  implements IDexTxBuilder<OnebitData, OnebitParam>
+{
+  static dexKeys = ['omm1'];
+  exchangeRouterInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'omm1');
+    this.exchangeRouterInterface = new Interface(OnebitABI as JsonFragment[]);
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OnebitData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.router,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OnebitData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = OnebitFunctions.swapTokensWithTrust;
+    const swapFunctionParams: OnebitParam = [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      this.augustusAddress,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.router,
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OnebitData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = OnebitFunctions.swapTokensWithTrust;
+    const swapFunctionParams: OnebitParam = [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      recipient,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.router,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+            )
+          : undefined,
+    };
+  }
+}

package/src/dex/onebit/types.ts

@@ -0,0 +1,17 @@
+import { Address } from '@paraswap/core';
+
+export type OnebitData = {
+  router: Address;
+};
+
+export type OnebitParam = [
+  srcToken: string,
+  destToken: string,
+  srcAmount: string,
+  destAmountMin: string,
+  to: string,
+];
+
+export enum OnebitFunctions {
+  swapTokensWithTrust = 'swapTokensWithTrust',
+}

package/src/dex/paraswap-limit-orders/paraswap-limit-orders-e2e.test.ts

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Holders, Tokens } from '../../../tests/constants-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { ParaSwapOrderResponse, ParaSwapOrderBookResponse } from './types';
@@ -12,168 +12,87 @@ import { generateConfig } from '../../config';
 describe('ParaSwapLimitOrders E2E', () => {
   const dexKey = 'ParaSwapLimitOrders';
 
-  // describe('ParaSwapLimitOrders MAINNET', () => {
-  //   const network = Network.MAINNET;
-  //   const tokens = Tokens[network];
-  //   const provider = new StaticJsonRpcProvider(
-  //     generateConfig(network).privateHttpProvider,
-  //     network,
-  //   );
-  //
-  //   const tokenASymbol: string = 'DAI';
-  //   const tokenBSymbol: string = 'WETH';
-  //
-  //   // Do not change arbitrarily. Need to adjust the orders amounts too
-  //   const tokenAAmount: string = '50000000000000000000';
-  //   const tokenBAmount: string = '110000000000000000';
-  //
-  //   const sideToContractMethods = new Map([
-  //     [
-  //       SwapSide.SELL,
-  //       [
-  //         ContractMethod.simpleSwap,
-  //         ContractMethod.multiSwap,
-  //         ContractMethod.megaSwap,
-  //       ],
-  //     ],
-  //     [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-  //   ]);
-  //   const maker = '0xc3643bC869DC0dcd2Df8729fC3cb768d4F86F57a';
-  //   const taker = '0xCf8C4a46816b146Ed613d23f6D22e1711915d653';
-  //
-  //   const ordersToUse: ParaSwapOrderResponse[] = [
-  //     {
-  //       order: {
-  //         nonceAndMeta:
-  //           '6845735429342786815130681271919807714789080615235334578045452288',
-  //         expiry: '0',
-  //         makerAsset: tokens[tokenASymbol].address,
-  //         takerAsset: tokens[tokenBSymbol].address,
-  //         maker,
-  //         taker: '0x0000000000000000000000000000000000000000',
-  //         makerAmount: '10000000000000000000',
-  //         takerAmount: '20000000000000000',
-  //       },
-  //       signature:
-  //         '0xa75880885e92ed7d46c842d3d20138c60c33c411642ec33a82b73216c508b5503bc57a3ec4fcc2f8ece2477c9eb9716850ae8b97f64d86afac56d3dace8f9f701b',
-  //       takerTokenFillAmount: '20000000000000000',
-  //       permitTakerAsset: '0x',
-  //       permitMakerAsset: '0x',
-  //     },
-  //     {
-  //       order: {
-  //         nonceAndMeta:
-  //           '11585127861177800418865894644506682666974354234368387567816015872',
-  //         expiry: '0',
-  //         makerAsset: tokens[tokenASymbol].address,
-  //         takerAsset: tokens[tokenBSymbol].address,
-  //         maker,
-  //         taker: '0x0000000000000000000000000000000000000000',
-  //         makerAmount: '50000000000000000000',
-  //         takerAmount: '110000000000000000',
-  //       },
-  //       signature:
-  //         '0x33ce6d9a609190d3d936c0cac2609ab13ad9aaa64d79917d32064003903105302cb80dcf0133e102d513a45c61d9b813a9c85b2f627aec7fed53d858dad90df61c',
-  //       takerTokenFillAmount: '110000000000000000',
-  //       permitTakerAsset: '0x',
-  //       permitMakerAsset: '0x',
-  //     },
-  //     {
-  //       order: {
-  //         nonceAndMeta:
-  //           '11375705433687422051822427911677732183148366573414372269099057152',
-  //         expiry: '0',
-  //         makerAsset: tokens[tokenASymbol].address,
-  //         takerAsset: tokens[tokenBSymbol].address,
-  //         maker,
-  //         taker: '0x0000000000000000000000000000000000000000',
-  //         makerAmount: '70000000000000000000',
-  //         takerAmount: '170000000000000000',
-  //       },
-  //       signature:
-  //         '0x989eec978c60b1104c7133beae1da691353d138f1fe32862e75a9fc36d294e92655e327fcaa83b6506c6712268ea03423249714308418955dfcc067583fd823a1b',
-  //       takerTokenFillAmount: '170000000000000000',
-  //       permitTakerAsset: '0x',
-  //       permitMakerAsset: '0x',
-  //     },
-  //   ];
-  //
-  //   const orderBookToUse: ParaSwapOrderBookResponse[] = ordersToUse.map(o => ({
-  //     swappableMakerBalance: o.order.makerAmount,
-  //     swappableTakerBalance: o.order.takerAmount,
-  //   }));
-  //
-  //   const dummyLimitOrderProvider = new DummyLimitOrderProvider();
-  //   dummyLimitOrderProvider.setOrdersToExecute(network, ordersToUse);
-  //   dummyLimitOrderProvider.setOrderBook(
-  //     network,
-  //     tokens[tokenBSymbol].address,
-  //     tokens[tokenASymbol].address,
-  //     orderBookToUse,
-  //   );
-  //
-  //   sideToContractMethods.forEach((contractMethods, side) =>
-  //     contractMethods.forEach((contractMethod: ContractMethod) => {
-  //       describe(`${contractMethod}`, () => {
-  //         it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-  //           await testE2E(
-  //             tokens[tokenBSymbol],
-  //             tokens[tokenASymbol],
-  //             taker,
-  //             side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-  //             side,
-  //             dexKey,
-  //             contractMethod,
-  //             network,
-  //             provider,
-  //             undefined,
-  //             dummyLimitOrderProvider,
-  //           );
-  //         });
-  //       });
-  //     }),
-  //   );
-  // });
-
-  describe('USDC -> DAI.e', () => {
-    const network = Network.AVALANCHE;
+  describe('ParaSwapLimitOrders MAINNET', () => {
+    const network = Network.MAINNET;
     const tokens = Tokens[network];
-    const holders = Holders[network];
-
     const provider = new StaticJsonRpcProvider(
       generateConfig(network).privateHttpProvider,
       network,
     );
 
-    const sideToContractMethods = new Map([
-      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
-    ]);
-
-    const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'DAIE';
+    const tokenASymbol: string = 'DAI';
+    const tokenBSymbol: string = 'WETH';
 
-    const tokenAAmount: string = '2200000';
-    const tokenBAmount: string = '2000000000000000000';
+    // Do not change arbitrarily. Need to adjust the orders amounts too
+    const tokenAAmount: string = '50000000000000000000';
+    const tokenBAmount: string = '110000000000000000';
 
-    const maker = '0x450C01300B83bE379113256038b4Dd3b45d23B5e';
-    const taker = '0x187b6Ab771482CCFEE7cD2C35176080631082368';
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    ]);
+    const maker = '0xc3643bC869DC0dcd2Df8729fC3cb768d4F86F57a';
+    const taker = '0xCf8C4a46816b146Ed613d23f6D22e1711915d653';
 
     const ordersToUse: ParaSwapOrderResponse[] = [
       {
         order: {
           nonceAndMeta:
-            '1970736690787950733482238420044572595585384097365282143164432384',
+            '6845735429342786815130681271919807714789080615235334578045452288',
           expiry: '0',
-          makerAsset: '0xd586e7f844cea2f87f50152665bcbc2c279d8d70',
-          takerAsset: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+          makerAsset: tokens[tokenASymbol].address,
+          takerAsset: tokens[tokenBSymbol].address,
           maker,
           taker: '0x0000000000000000000000000000000000000000',
-          makerAmount: '2000000000000000000',
-          takerAmount: '2200000',
+          makerAmount: '10000000000000000000',
+          takerAmount: '20000000000000000',
         },
-        signature: '0x',
-        takerTokenFillAmount: '2200000',
+        signature:
+          '0xa75880885e92ed7d46c842d3d20138c60c33c411642ec33a82b73216c508b5503bc57a3ec4fcc2f8ece2477c9eb9716850ae8b97f64d86afac56d3dace8f9f701b',
+        takerTokenFillAmount: '20000000000000000',
+        permitTakerAsset: '0x',
+        permitMakerAsset: '0x',
+      },
+      {
+        order: {
+          nonceAndMeta:
+            '11585127861177800418865894644506682666974354234368387567816015872',
+          expiry: '0',
+          makerAsset: tokens[tokenASymbol].address,
+          takerAsset: tokens[tokenBSymbol].address,
+          maker,
+          taker: '0x0000000000000000000000000000000000000000',
+          makerAmount: '50000000000000000000',
+          takerAmount: '110000000000000000',
+        },
+        signature:
+          '0x33ce6d9a609190d3d936c0cac2609ab13ad9aaa64d79917d32064003903105302cb80dcf0133e102d513a45c61d9b813a9c85b2f627aec7fed53d858dad90df61c',
+        takerTokenFillAmount: '110000000000000000',
+        permitTakerAsset: '0x',
+        permitMakerAsset: '0x',
+      },
+      {
+        order: {
+          nonceAndMeta:
+            '11375705433687422051822427911677732183148366573414372269099057152',
+          expiry: '0',
+          makerAsset: tokens[tokenASymbol].address,
+          takerAsset: tokens[tokenBSymbol].address,
+          maker,
+          taker: '0x0000000000000000000000000000000000000000',
+          makerAmount: '70000000000000000000',
+          takerAmount: '170000000000000000',
+        },
+        signature:
+          '0x989eec978c60b1104c7133beae1da691353d138f1fe32862e75a9fc36d294e92655e327fcaa83b6506c6712268ea03423249714308418955dfcc067583fd823a1b',
+        takerTokenFillAmount: '170000000000000000',
         permitTakerAsset: '0x',
         permitMakerAsset: '0x',
       },
@@ -182,9 +101,6 @@ describe('ParaSwapLimitOrders E2E', () => {
     const orderBookToUse: ParaSwapOrderBookResponse[] = ordersToUse.map(o => ({
       swappableMakerBalance: o.order.makerAmount,
       swappableTakerBalance: o.order.takerAmount,
-      makerAmount: o.order.makerAmount,
-      takerAmount: o.order.takerAmount,
-      isFillOrKill: true,
     }));
 
     const dummyLimitOrderProvider = new DummyLimitOrderProvider();
@@ -201,10 +117,10 @@ describe('ParaSwapLimitOrders E2E', () => {
         describe(`${contractMethod}`, () => {
           it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
             await testE2E(
-              tokens[tokenASymbol],
               tokens[tokenBSymbol],
-              holders[tokenASymbol],
-              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              tokens[tokenASymbol],
+              taker,
+              side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
               side,
               dexKey,
               contractMethod,

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

@@ -38,7 +38,6 @@ import {
   ONE_ORDER_GASCOST,
 } from './constant';
 import BigNumber from 'bignumber.js';
-import { SpecialDex } from '../../executor/types';
 
 const BLACKLIST_CACHE_PREFIX = `lo_blacklist`;
 
@@ -398,9 +397,7 @@ export class ParaSwapLimitOrders
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: true,
       exchangeData: swapData,
-      specialDexFlag: SpecialDex.SWAP_ON_AUGUSTUS_RFQ,
       targetExchange: this.augustusRFQAddress,
-      specialDexSupportsInsertFromAmount: true,
       returnAmountPos: undefined,
     };
   }

package/src/dex/shell.ts

@@ -0,0 +1,84 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import { IDexTxBuilder } from './idex';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from './simple-exchange';
+import ShellABI from '../abi/Shell.json';
+import { IDexHelper } from '../dex-helper';
+
+export type ShellData = {
+  exchange: Address;
+  deadline?: number;
+};
+type ShellParam = [
+  _origin: string,
+  _target: string,
+  _originAmount: string,
+  _minTargetAmount: string,
+  _deadline: string,
+];
+enum ShellFunctions {
+  originSwap = 'originSwap',
+}
+
+export class Shell
+  extends SimpleExchange
+  implements IDexTxBuilder<ShellData, ShellParam>
+{
+  static dexKeys = ['shell'];
+  exchangeRouterInterface: Interface;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'shell');
+    this.exchangeRouterInterface = new Interface(ShellABI as JsonFragment[]);
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: ShellData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.exchange,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: ShellData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = ShellFunctions.originSwap;
+    const swapFunctionParams: ShellParam = [
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      getLocalDeadlineAsFriendlyPlaceholder(),
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.exchange,
+    );
+  }
+}