@paraswap/dex-lib 2.45.0 → 3.0.0

package/src/dex/uniswap-v2/uniswap-v2-optimizer.ts

@@ -0,0 +1,114 @@
+import { UnoptimizedRate, OptimalSwap, Address } from '../../types';
+import { isETHAddress } from '../../utils';
+import { AllUniswapForks } from './constants';
+import _ from 'lodash';
+
+// Refactor the optimization of swap rates for better clarity and efficiency
+export function uniswapOptimizer(rate: UnoptimizedRate): UnoptimizedRate {
+  const optimizeSwapRoute = (swaps: OptimalSwap[]): OptimalSwap[] => {
+    let lastOptimizedSwap: OptimalSwap | null = null;
+    const optimizedSwaps = swaps.reduce<OptimalSwap[]>(
+      (accumulatedSwaps, currentSwap) => {
+        const isUniswapSwap =
+          currentSwap.swapExchanges.length === 1 &&
+          isSwapExchangeAUniswapFork(currentSwap.swapExchanges[0].exchange);
+
+        if (!isUniswapSwap) {
+          lastOptimizedSwap = null;
+          accumulatedSwaps.push(currentSwap);
+          return accumulatedSwaps;
+        }
+
+        if (canBeMergedWithLastSwap(lastOptimizedSwap, currentSwap)) {
+          lastOptimizedSwap = mergeSwaps(lastOptimizedSwap!, currentSwap);
+        } else {
+          lastOptimizedSwap = _.cloneDeep(currentSwap);
+          accumulatedSwaps.push(lastOptimizedSwap);
+        }
+
+        return accumulatedSwaps;
+      },
+      [],
+    );
+
+    return optimizedSwaps;
+  };
+
+  rate.bestRoute = rate.bestRoute.map(route => ({
+    ...route,
+    swaps: optimizeSwapRoute(route.swaps),
+  }));
+
+  return rate;
+}
+
+function isSwapExchangeAUniswapFork(exchangeName: string): boolean {
+  return AllUniswapForks.some(
+    fork => fork.toLowerCase() === exchangeName.toLowerCase(),
+  );
+}
+
+function canBeMergedWithLastSwap(
+  lastSwap: OptimalSwap | null,
+  currentSwap: OptimalSwap,
+): boolean {
+  return (
+    !!lastSwap &&
+    _.last(<Address[]>lastSwap.swapExchanges[0].data.path)!.toLowerCase() ===
+      currentSwap.swapExchanges[0].data.path[0].toLowerCase()
+  );
+}
+
+function mergeSwaps(
+  lastSwap: OptimalSwap,
+  currentSwap: OptimalSwap,
+): OptimalSwap {
+  lastSwap.swapExchanges[0].data.path.push(
+    currentSwap.swapExchanges[0].data.path[1],
+  );
+  lastSwap.swapExchanges[0].exchange = deriveExchangeName(
+    lastSwap,
+    currentSwap,
+  );
+  lastSwap.swapExchanges[0].data.pools.push(
+    currentSwap.swapExchanges[0].data.pools[0],
+  );
+  lastSwap.swapExchanges[0].poolAddresses!.push(
+    currentSwap.swapExchanges[0].poolAddresses![0],
+  );
+  lastSwap.swapExchanges[0].data.gasUSD = calculateCombinedGasUSD(
+    lastSwap,
+    currentSwap,
+  );
+
+  if (isETHAddress(currentSwap.destToken)) {
+    lastSwap.swapExchanges[0].data.weth =
+      currentSwap.swapExchanges[0].data.weth;
+  }
+
+  lastSwap.destToken = currentSwap.destToken;
+  lastSwap.destDecimals = currentSwap.destDecimals;
+  lastSwap.swapExchanges[0].destAmount =
+    currentSwap.swapExchanges[0].destAmount;
+
+  return lastSwap;
+}
+
+function deriveExchangeName(
+  lastSwap: OptimalSwap,
+  currentSwap: OptimalSwap,
+): string {
+  return lastSwap.swapExchanges[0].exchange ===
+    currentSwap.swapExchanges[0].exchange
+    ? lastSwap.swapExchanges[0].exchange
+    : 'UniswapForkOptimized';
+}
+
+function calculateCombinedGasUSD(
+  lastSwap: OptimalSwap,
+  currentSwap: OptimalSwap,
+): string {
+  const lastGasUSD = parseFloat(lastSwap.swapExchanges[0].data.gasUSD);
+  const currentGasUSD = parseFloat(currentSwap.swapExchanges[0].data.gasUSD);
+  return (lastGasUSD + currentGasUSD).toFixed(6);
+}

package/src/dex/uniswap-v2/uniswap-v2.ts

@@ -1,4 +1,5 @@
 import { AbiCoder, Interface } from '@ethersproject/abi';
+import { pack } from '@ethersproject/solidity';
 import _ from 'lodash';
 import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import erc20ABI from '../../abi/erc20.json';
@@ -15,6 +16,7 @@ import {
   Token,
   TxInfo,
   TransferFeeParams,
+  DexExchangeParam,
 } from '../../types';
 import {
   UniswapData,
@@ -23,6 +25,9 @@ import {
   UniswapPool,
   UniswapV2Data,
   UniswapV2Functions,
+  UniswapV2FunctionsV6,
+  UniswapV2ParamsDirect,
+  UniswapV2ParamsDirectBase,
   UniswapV2PoolOrderedParams,
 } from './types';
 import { IDex } from '../idex';
@@ -43,6 +48,7 @@ import {
   isETHAddress,
   prependWithOx,
   getBigIntPow,
+  uuidToBytes16,
 } from '../../utils';
 import uniswapV2ABI from '../../abi/uniswap-v2/uniswap-v2-pool.json';
 import uniswapV2factoryABI from '../../abi/uniswap-v2/uniswap-v2-factory.json';
@@ -53,6 +59,16 @@ import { UniswapV2Config, Adapters } from './config';
 import { Uniswapv2ConstantProductPool } from './uniswap-v2-constant-product-pool';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
 import _rebaseTokens from '../../rebase-tokens.json';
+import { Flag, SpecialDex } from '../../executor/types';
+import {
+  hexZeroPad,
+  hexlify,
+  solidityPack,
+  hexDataLength,
+  id,
+  hexConcat,
+} from 'ethers/lib/utils';
+import { BigNumber } from 'ethers';
 
 const rebaseTokens = _rebaseTokens as { chainId: number; address: string }[];
 
@@ -96,6 +112,11 @@ export const directUniswapFunctionName = [
   UniswapV2Functions.buyOnUniswapV2Fork,
 ];
 
+export const directUniswapFunctionNameV6 = [
+  UniswapV2FunctionsV6.swap,
+  UniswapV2FunctionsV6.buy,
+];
+
 export interface UniswapV2Pair {
   token0: Token;
   token1: Token;
@@ -199,7 +220,7 @@ function encodePools(
 
 export class UniswapV2
   extends SimpleExchange
-  implements IDex<UniswapV2Data, UniswapParam>
+  implements IDex<UniswapV2Data, UniswapParam | UniswapV2ParamsDirect>
 {
   pairs: { [key: string]: UniswapV2Pair } = {};
   feeFactor = 10000;
@@ -207,10 +228,14 @@ export class UniswapV2
 
   routerInterface: Interface;
   exchangeRouterInterface: Interface;
-  static directFunctionName = directUniswapFunctionName;
+
+  needWrapNative = true;
 
   logger: Logger;
 
+  static directFunctionName = directUniswapFunctionName;
+  static directFunctionNameV6 = directUniswapFunctionNameV6;
+
   readonly hasConstantPriceLargeAmounts = false;
   readonly isFeeOnTransferSupported: boolean = true;
   readonly SRC_TOKEN_DEX_TRANSFERS = 1;
@@ -821,6 +846,77 @@ export class UniswapV2
     );
   }
 
+  // TODO: Rebase tokens handling?
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: UniswapData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const pools = encodePools(data.pools, this.feeFactor);
+
+    let exchangeData: string;
+    let specialDexFlag: SpecialDex;
+    let transferSrcTokenBeforeSwap: Address | undefined;
+    let targetExchange: Address;
+    let dexFuncHasRecipient: boolean;
+
+    // if (this.dexKey === 'BakerySwap') {
+    //   const weth = this.getWETHAddress(srcToken, destToken, data.weth);
+
+    //   exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+    //     UniswapV2Functions.swap,
+    //     [srcToken, srcAmount, destAmount, weth, pools],
+    //   );
+    //   specialDexFlag = SpecialDex.DEFAULT;
+    //   targetExchange = data.router;
+    //   dexFuncHasRecipient = false;
+    // } else if (side === SwapSide.SELL) {
+
+    if (side === SwapSide.SELL) {
+      // 28 bytes are prepended in the Bytecode builder
+      const exchangeDataTypes = ['bytes4', 'bytes32', 'bytes32'];
+      const exchangeDataToPack = [
+        hexZeroPad(hexlify(0), 4),
+        hexZeroPad(hexlify(data.pools.length), 32), // pool count
+        hexZeroPad(hexlify(BigNumber.from(srcAmount)), 32),
+      ];
+      pools.forEach(pool => {
+        exchangeDataTypes.push('bytes32');
+        exchangeDataToPack.push(hexZeroPad(hexlify(BigNumber.from(pool)), 32));
+      });
+
+      exchangeData = solidityPack(exchangeDataTypes, exchangeDataToPack);
+      specialDexFlag = SpecialDex.SWAP_ON_UNISWAP_V2_FORK;
+      transferSrcTokenBeforeSwap = data.pools[0].address;
+      targetExchange = recipient;
+      dexFuncHasRecipient = true;
+    } else {
+      const weth = this.getWETHAddress(srcToken, destToken, data.weth);
+
+      exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+        UniswapV2Functions.buy,
+        [srcToken, srcAmount, destAmount, weth, pools],
+      );
+      specialDexFlag = SpecialDex.DEFAULT;
+      targetExchange = data.router;
+      dexFuncHasRecipient = false;
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      specialDexSupportsInsertFromAmount: true,
+      dexFuncHasRecipient,
+      exchangeData,
+      targetExchange,
+      specialDexFlag,
+      transferSrcTokenBeforeSwap,
+    };
+  }
+
   // TODO: Move to new uniswapv2&forks router interface
   getDirectParam(
     srcToken: Address,
@@ -898,4 +994,112 @@ export class UniswapV2
   static getDirectFunctionName(): string[] {
     return this.directFunctionName;
   }
+
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: UniswapV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (!contractMethod) throw new Error(`contractMethod need to be passed`);
+    if (!UniswapV2.getDirectFunctionNameV6().includes(contractMethod!)) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    // univ2 has 1 pool per pair
+    const path = this._encodePathV6(
+      { srcToken, destToken, direction: data.pools[0].direction },
+      side,
+      data.wethAddress,
+    );
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const uniData: UniswapV2ParamsDirectBase = [
+      srcToken,
+      destToken,
+      fromAmount,
+      quotedAmount,
+      toAmount,
+      metadata,
+      beneficiary,
+      path,
+    ];
+
+    const swapParams: UniswapV2ParamsDirect = [uniData, partnerAndFee, permit];
+
+    const encoder = (...params: (string | UniswapV2ParamsDirect)[]) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? UniswapV2FunctionsV6.swap
+          : UniswapV2FunctionsV6.buy,
+        [...params],
+      );
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return this.directFunctionNameV6;
+  }
+
+  // univ2 always had 1 pool per pair
+  private _encodePathV6(
+    path: {
+      srcToken: Address;
+      destToken: Address;
+      direction: boolean;
+    },
+    side: SwapSide,
+    weth?: Address,
+  ): string {
+    if (path == null) {
+      this.logger.error(
+        `${this.dexKey}: Received invalid path=${path} for side=${side} to encode`,
+      );
+      return '0x';
+    }
+
+    // v6 expects weth for eth in pools
+    if (isETHAddress(path.srcToken)) {
+      path.srcToken =
+        weth || this.dexHelper.config.data.wrappedNativeTokenAddress;
+    }
+
+    if (isETHAddress(path.destToken)) {
+      path.destToken =
+        weth || this.dexHelper.config.data.wrappedNativeTokenAddress;
+    }
+
+    // contract expects tokens to be sorted, and direction switched in case sorting changes src/dest order
+    const [srcTokenSorted, destTokenSorted] =
+      BigInt(path.srcToken) > BigInt(path.destToken)
+        ? [path.destToken, path.srcToken]
+        : [path.srcToken, path.destToken];
+
+    const direction = srcTokenSorted === path.srcToken ? 1 : 0;
+
+    const tokensEncoded = pack(
+      ['address', 'address'],
+      [srcTokenSorted, destTokenSorted],
+    );
+    return tokensEncoded + '0'.repeat(47) + direction;
+  }
 }

package/src/dex/uniswap-v3/constants.ts

@@ -39,3 +39,8 @@ export enum DirectMethods {
   directSell = 'directUniV3Swap',
   directBuy = 'directUniV3Buy',
 }
+
+export enum DirectMethodsV6 {
+  directSell = 'swapExactAmountInOnUniswapV3',
+  directBuy = 'swapExactAmountOutOnUniswapV3',
+}

package/src/dex/uniswap-v3/types.ts

@@ -124,6 +124,23 @@ export type UniswapV3Param = [
   uuid: string,
 ];
 
+export type UniswapV3ParamsDirectBase = [
+  srcToken: Address,
+  destToken: Address,
+  fromAmount: NumberAsString,
+  quotedAmount: NumberAsString,
+  toAmount: NumberAsString,
+  metadata: string,
+  beneficiary: Address,
+  pools: string,
+];
+
+export type UniswapV3ParamsDirect = [
+  params: UniswapV3ParamsDirectBase,
+  partnerAndFee: string,
+  permit: string,
+];
+
 export enum UniswapV3Functions {
   exactInput = 'exactInput',
   exactOutput = 'exactOutput',