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

package/src/dex/OneInchLp.ts

@@ -1,84 +0,0 @@
-import { Interface, JsonFragment } from '@ethersproject/abi';
-import { NULL_ADDRESS, SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import OneInchLpABI from '../abi/OneInchLp.json';
-import { isETHAddress } from '../utils';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-export type OneInchLpData = {
-  exchange: string; // _DOUBLE_CHECK_
-};
-type OneInchLpParam = [
-  src: string,
-  dst: string,
-  amount: string,
-  minReturn: string,
-  referral: string,
-];
-enum OneInchLpFunctions {
-  swap = 'swap',
-}
-
-export class OneInchLp
-  extends SimpleExchange
-  implements IDexTxBuilder<OneInchLpData, OneInchLpParam>
-{
-  static dexKeys = ['oneinchlp'];
-  exchangeRouterInterface: Interface;
-
-  constructor(dexHelper: IDexHelper) {
-    super(dexHelper, 'oneinchlp');
-    this.exchangeRouterInterface = new Interface(
-      OneInchLpABI as JsonFragment[],
-    );
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: OneInchLpData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    return {
-      targetExchange: data.exchange,
-      payload: '0x',
-      networkFee: '0',
-    };
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: OneInchLpData,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    const swapFunction = OneInchLpFunctions.swap;
-    const swapFunctionParams: OneInchLpParam = [
-      isETHAddress(srcToken) ? NULL_ADDRESS : srcToken,
-      isETHAddress(destToken) ? NULL_ADDRESS : destToken,
-      srcAmount,
-      destAmount,
-      NULL_ADDRESS,
-    ];
-    const swapData = this.exchangeRouterInterface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      data.exchange,
-    );
-  }
-}

package/src/dex/bProtocol/bProtocol-e2e.test.ts

@@ -1,93 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  Holders,
-  NativeTokenSymbols,
-} from '../../../tests/constants-e2e';
-
-import { ContractMethod, Network, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-
-const dexKey = 'bprotocol';
-
-// ! LIQUIDITY ISSUES
-
-const testForNetwork = (
-  network: Network,
-  swapMap: Map<SwapSide, ContractMethod[]>,
-) => {
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-
-  const nativeSymbol = NativeTokenSymbols[network];
-
-  const provider = new StaticJsonRpcProvider(
-    generateConfig(network).privateHttpProvider,
-    network,
-  );
-
-  const tokensToTest = [
-    [
-      {
-        symbol: 'LUSD',
-        amount: '100000000000000000000',
-      },
-      {
-        symbol: 'ETH',
-        amount: '35360886801038522',
-      },
-    ],
-  ];
-
-  swapMap.forEach((contractMethods, side) =>
-    contractMethods.forEach((contractMethod: string) => {
-      tokensToTest.forEach(pair => {
-        describe(`${contractMethod}`, () => {
-          it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
-            await testE2E(
-              tokens[pair[0].symbol],
-              tokens[pair[1].symbol],
-              holders[pair[0].symbol],
-              side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
-              side,
-              dexKey,
-              contractMethod as any,
-              network,
-              provider,
-            );
-          });
-
-          it(`${nativeSymbol} -> ${pair[0].symbol}`, async () => {
-            await testE2E(
-              tokens[nativeSymbol],
-              tokens[pair[0].symbol],
-              holders[nativeSymbol],
-              side === SwapSide.SELL ? '1000000000000000000' : pair[0].amount,
-              side,
-              dexKey,
-              contractMethod as any,
-              network,
-              provider,
-            );
-          });
-        });
-      });
-    }),
-  );
-};
-
-// Ensure you have the E2E_ENDPOINT_URL env variable set.
-
-describe('bProtocol E2E', () => {
-  describe('Mainnet V6', () => {
-    const swapMap = new Map<SwapSide, ContractMethod[]>([
-      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-    ]);
-
-    testForNetwork(Network.MAINNET, swapMap);
-  });
-});

package/src/dex/bProtocol/bProtocol.ts

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

package/src/dex/bProtocol/types.ts

@@ -1,13 +0,0 @@
-export type BProtocolData = {
-  exchange: string;
-};
-
-export type BProtocolParam = [
-  lusdAmount: string,
-  minEthReturn: string,
-  dest: string,
-];
-
-export enum BProtocolFunctions {
-  swap = 'swap',
-}

package/src/dex/jarvis.ts

@@ -1,262 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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,
-    );
-  }
-}