@paraswap/dex-lib 3.8.1 → 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/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,
+    );
+  }
+}

package/src/dex/trader-joe-v2.ts

@@ -0,0 +1,148 @@
+import { Network, SwapSide } from '../constants';
+import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
+import { IDexTxBuilder } from './idex';
+import { IDexHelper } from '../dex-helper';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from './simple-exchange';
+import { NumberAsString } from '@paraswap/core';
+import { AsyncOrSync } from 'ts-essentials';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import TraderJoeV2RouterABI from '../abi/TraderJoeV2Router.json';
+
+const TRADERJOE_V2_ROUTER_ADDRESS: { [network: number]: Address } = {
+  [Network.AVALANCHE]: '0xE3Ffc583dC176575eEA7FD9dF2A7c65F7E23f4C3',
+  [Network.ARBITRUM]: '0x7BFd7192E76D950832c77BB412aaE841049D8D9B',
+  [Network.BSC]: '0xb66A2704a0dabC1660941628BE987B4418f7a9E8',
+};
+
+type TraderJoeV2RouterSellParams = [
+  _amountIn: NumberAsString,
+  _amountOutMin: NumberAsString,
+  _pairBinSteps: NumberAsString[],
+  _tokenPath: Address[],
+  to: Address,
+  _deadline: number,
+];
+
+type TraderJoeV2RouterBuyParams = [
+  _amountOut: NumberAsString,
+  _amountInMax: NumberAsString,
+  _pairBinSteps: NumberAsString[],
+  _tokenPath: Address[],
+  to: Address,
+  _deadline: string,
+];
+
+type TraderJoeV2RouterParam =
+  | TraderJoeV2RouterSellParams
+  | TraderJoeV2RouterBuyParams;
+
+export type TraderJoeV2Data = {
+  tokenIn: string; // redundant
+  tokenOut: string; // redundant
+  binStep: string;
+};
+
+enum TraderJoeV2RouterFunctions {
+  swapExactTokensForTokens = 'swapExactTokensForTokens',
+  swapTokensForExactTokens = 'swapTokensForExactTokens',
+}
+
+export class TraderJoeV2
+  extends SimpleExchange
+  implements IDexTxBuilder<TraderJoeV2Data, TraderJoeV2RouterParam>
+{
+  static dexKeys = ['traderjoev2'];
+  protected routerAddress: string;
+  exchangeRouterInterface: Interface;
+  needWrapNative = true;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'traderjoev2');
+
+    this.routerAddress =
+      TRADERJOE_V2_ROUTER_ADDRESS[dexHelper.config.data.network];
+
+    this.exchangeRouterInterface = new Interface(
+      TraderJoeV2RouterABI as JsonFragment[],
+    );
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          _pairBinSteps: 'uint256[]',
+          _tokenPath: 'address[]',
+          _deadline: 'uint256',
+        },
+      },
+      {
+        _pairBinSteps: [data.binStep],
+        _tokenPath: [data.tokenIn, data.tokenOut], // FIXME: redundant, shoot & read from contract
+        _deadline: getLocalDeadlineAsFriendlyPlaceholder(), // FIXME: more gas efficient to pass block.timestamp in adapter
+      },
+    );
+
+    return {
+      targetExchange: this.routerAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  getSimpleParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: TraderJoeV2Data,
+    side: SwapSide,
+  ): AsyncOrSync<SimpleExchangeParam> {
+    const swapFunction =
+      side === SwapSide.SELL
+        ? TraderJoeV2RouterFunctions.swapExactTokensForTokens
+        : TraderJoeV2RouterFunctions.swapTokensForExactTokens;
+
+    const swapFunctionParams: TraderJoeV2RouterParam =
+      side === SwapSide.SELL
+        ? [
+            srcAmount,
+            destAmount,
+            [data.binStep],
+            [srcToken, destToken],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ]
+        : [
+            destAmount,
+            srcAmount,
+            [data.binStep],
+            [srcToken, destToken],
+            this.augustusAddress,
+            getLocalDeadlineAsFriendlyPlaceholder(),
+          ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      this.routerAddress,
+    );
+  }
+}

package/src/dex/uniswap-v3/contract-math/Oracle.ts

@@ -23,7 +23,7 @@ export class Oracle {
   ): OracleObservation {
     const delta = blockTimestamp - last.blockTimestamp;
     return {
-      blockTimestamp: state.blockTimestamp,
+      blockTimestamp,
       tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
       secondsPerLiquidityCumulativeX128:
         last.secondsPerLiquidityCumulativeX128 +
@@ -93,12 +93,12 @@ export class Oracle {
     let beforeOrAt;
     let atOrAfter;
     while (true) {
-      i = (l + r) / 2;
+      i = Math.floor((l + r) / 2);
 
       beforeOrAt = state.observations[i % cardinality];
 
       // we've landed on an uninitialized tick, keep searching higher (more recently)
-      if (!beforeOrAt.initialized) {
+      if (!beforeOrAt || !beforeOrAt.initialized) {
         l = i + 1;
         continue;
       }
@@ -150,7 +150,8 @@ export class Oracle {
     }
 
     beforeOrAt = state.observations[(index + 1) % cardinality];
-    if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
+    if (!beforeOrAt || !beforeOrAt.initialized)
+      beforeOrAt = state.observations[0];
 
     _require(
       Oracle.lte(time, beforeOrAt.blockTimestamp, target),

package/src/dex/zerox/config.ts

@@ -0,0 +1,31 @@
+import { Network } from '../../constants';
+
+export const ZRX_EXCHANGE: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    2: '0x080bf510fcbf18b91105470639e9561022937712',
+    3: '0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0x3F93C3D9304a70c9104642AB8cD37b1E2a7c203A',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};
+
+export const ZRX_EXCHANGE_ERC20PROXY: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    1: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    2: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0xCF21d4b7a265FF779accBA55Ace0F56C8cE6e379',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};