@paraswap/dex-lib 2.45.0 → 3.0.0-fix-for-rc

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

@@ -4,16 +4,17 @@ import _, { keyBy } from 'lodash';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
+  ExchangeTxInfo,
   Log,
   Logger,
-  TxInfo,
-  PreprocessTransactionOptions,
-  ExchangeTxInfo,
   PoolLiquidity,
   PoolPrices,
+  PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
+  TxInfo,
 } from '../../types';
 import {
   ETHER_ADDRESS,
@@ -33,31 +34,33 @@ import VaultABI from '../../abi/balancer-v2/vault.json';
 import DirectSwapABI from '../../abi/DirectSwap.json';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
 import {
-  getDexKeysWithNetwork,
   getBigIntPow,
+  getDexKeysWithNetwork,
   uuidToBytes16,
 } from '../../utils';
-import { IDex } from '../../dex/idex';
+import { Context, IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper';
 import {
   BalancerParam,
   BalancerPoolTypes,
   BalancerSwap,
   BalancerV2Data,
+  BalancerV2DirectParam,
   OptimizedBalancerV2Data,
   PoolState,
   PoolStateCache,
   PoolStateMap,
   SubgraphPoolAddressDictionary,
-  BalancerV2DirectParam,
   SubgraphPoolBase,
   SwapTypes,
+  BalancerV2DirectParamV6,
+  BalancerV2DirectParamV6Swap,
 } from './types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
   SimpleExchange,
 } from '../simple-exchange';
-import { BalancerConfig, Adapters } from './config';
+import { Adapters, BalancerConfig } from './config';
 import {
   getAllPoolsUsedInPaths,
   isSameAddress,
@@ -66,11 +69,16 @@ import {
 } from './utils';
 import {
   DirectMethods,
+  DirectMethodsV6,
   MIN_USD_LIQUIDITY_TO_FETCH,
   STABLE_GAS_COST,
   VARIABLE_GAS_COST_PER_CYCLE,
 } from './constants';
 import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
+import { hexConcat, hexlify, hexZeroPad, solidityPack } from 'ethers/lib/utils';
+import BalancerVaultABI from '../../abi/balancer-v2/vault.json';
+import { BigNumber, utils } from 'ethers';
+import { Executors, SpecialDex } from '../../executor/types';
 
 // If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
 const enabledPoolTypes = [
@@ -591,14 +599,20 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
 export class BalancerV2
   extends SimpleExchange
   implements
-    IDex<BalancerV2Data, BalancerV2DirectParam, OptimizedBalancerV2Data>
+    IDex<
+      BalancerV2Data,
+      BalancerV2DirectParam | BalancerV2DirectParamV6Swap,
+      OptimizedBalancerV2Data
+    >
 {
   public eventPools: BalancerV2EventPool;
 
   readonly hasConstantPriceLargeAmounts = false;
   readonly isFeeOnTransferSupported = false;
+  readonly needWrapNative = true; // temporary
 
   readonly directSwapIface = new Interface(DirectSwapABI);
+  readonly balancerVaultInterface = new Interface(BalancerVaultABI);
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(BalancerConfig);
@@ -1119,6 +1133,133 @@ export class BalancerV2
     return params;
   }
 
+  public getBalancerParamV6(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: string,
+    destAmount: string,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    recipient: Address,
+    sender: Address,
+    isDirect?: boolean,
+  ): BalancerParam {
+    let swapOffset = 0;
+    let swaps: BalancerSwap[] = [];
+    let assets: string[] = [];
+    let limits: string[] = [];
+
+    const isDirectSwap = !!isDirect;
+
+    for (const swapData of data.swaps) {
+      const pool = this.poolIdMap[swapData.poolId];
+      const hasEth = [srcToken.toLowerCase(), destToken.toLowerCase()].includes(
+        ETHER_ADDRESS.toLowerCase(),
+      );
+      const _srcToken = this.dexHelper.config.wrapETH({
+        address: srcToken,
+        decimals: 18,
+      }).address;
+      const _destToken = this.dexHelper.config.wrapETH({
+        address: destToken,
+        decimals: 18,
+      }).address;
+
+      let path = poolGetPathForTokenInOut(
+        _srcToken,
+        _destToken,
+        pool,
+        this.poolAddressMap,
+        side,
+      );
+
+      if (side === SwapSide.BUY) {
+        path = path.reverse();
+      }
+
+      let _swaps = path.map((hop, index) => ({
+        poolId: hop.pool.id,
+        assetInIndex: swapOffset + index,
+        assetOutIndex: swapOffset + index + 1,
+        amount:
+          (side === SwapSide.SELL && index === 0) ||
+          (side === SwapSide.BUY && index === path.length - 1)
+            ? swapData.amount
+            : '0',
+        userData: '0x',
+      }));
+
+      swapOffset += path.length + 1;
+
+      // BalancerV2 Uses Address(0) as ETH
+      let _assets = [_srcToken, ...path.map(hop => hop.tokenOut.address)].map(
+        t => (hasEth && this.dexHelper.config.isWETH(t) ? NULL_ADDRESS : t),
+      );
+
+      if (isDirectSwap && side === SwapSide.BUY) {
+        _assets = _assets.reverse();
+        _swaps = _swaps.map(swap => ({
+          ...swap,
+          assetInIndex: _assets.length - swap.assetInIndex - 1,
+          assetOutIndex: _assets.length - swap.assetOutIndex - 1,
+        }));
+      }
+
+      let _limits: string[];
+      if (isDirectSwap) {
+        _limits = this.createSwapArray(
+          _assets.length,
+          side === SwapSide.SELL ? 0 : 1,
+          srcAmount,
+          destAmount,
+        );
+      } else {
+        _limits = _assets.map(_ => MAX_INT);
+      }
+
+      swaps = swaps.concat(_swaps);
+      assets = assets.concat(_assets);
+      limits = limits.concat(_limits);
+    }
+
+    const funds = {
+      // for Direct: Both sender and recipient is AugustusV6
+      // for Generic, `sender`: BUY -> pass Executor3, for SELL -> pass NULL_ADDRESS (it's gonna be determined in the contract)
+      sender,
+      recipient,
+      fromInternalBalance: false,
+      toInternalBalance: false,
+    };
+
+    const params: BalancerParam = [
+      side === SwapSide.SELL ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
+      side === SwapSide.SELL ? swaps : swaps.reverse(),
+      assets,
+      funds,
+      limits,
+      MAX_UINT,
+    ];
+
+    return params;
+  }
+
+  private createSwapArray(
+    lengthOfAssets: number,
+    swapKind: 0 | 1,
+    fromAmount: string,
+    toAmount: string,
+  ): string[] {
+    let swapArray = new Array(lengthOfAssets).fill('0');
+
+    // Assign values based on swapKind
+    swapArray[0] =
+      swapKind === 0 ? fromAmount : BigNumber.from(toAmount).mul(-1).toString();
+    swapArray[lengthOfAssets - 1] =
+      swapKind === 0 ? BigNumber.from(toAmount).mul(-1).toString() : fromAmount;
+
+    return swapArray;
+  }
+
   static getDirectFunctionName(): string[] {
     return [DirectMethods.directSell, DirectMethods.directBuy];
   }
@@ -1152,13 +1293,11 @@ export class BalancerV2
     let isApproved: boolean | undefined;
 
     try {
-      this.erc20Contract.options.address =
-        this.dexHelper.config.wrapETH(srcToken).address;
-      const allowance = await this.erc20Contract.methods
-        .allowance(this.augustusAddress, this.vaultAddress)
-        .call(undefined, 'latest');
-      isApproved =
-        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        this.vaultAddress,
+      );
     } catch (e) {
       this.logger.error(
         `preProcessTransaction failed to retrieve allowance info: `,
@@ -1251,6 +1390,97 @@ export class BalancerV2
     };
   }
 
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: OptimizedBalancerV2Data,
+    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 (!BalancerV2.getDirectFunctionNameV6().includes(contractMethod!)) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const balancerParams = this.getBalancerParamV6(
+      srcToken,
+      destToken,
+      fromAmount,
+      toAmount,
+      data,
+      side,
+      this.dexHelper.config.data.augustusV6Address!,
+      this.dexHelper.config.data.augustusV6Address!,
+      true,
+    );
+
+    const swapParams: BalancerV2DirectParamV6 = [
+      quotedAmount,
+      metadata,
+      this.encodeBeneficiaryAndApproveFlag(beneficiary, !data.isApproved),
+    ];
+
+    const encodeParams: BalancerV2DirectParamV6Swap = [
+      swapParams,
+      partnerAndFee,
+      permit,
+      this.encodeBalancerParam(balancerParams),
+    ];
+
+    const encoder = (...params: BalancerV2DirectParamV6Swap) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethodsV6.directSell
+          : DirectMethodsV6.directBuy,
+        [...params],
+      );
+    };
+
+    return {
+      encoder,
+      params: encodeParams,
+      networkFee: '0',
+    };
+  }
+
+  private encodeBeneficiaryAndApproveFlag(
+    beneficiary: Address,
+    approveFlag: boolean,
+  ) {
+    const addressBN = BigNumber.from(beneficiary);
+    const flagBN = approveFlag ? BigNumber.from(1).shl(255) : BigNumber.from(0);
+
+    return addressBN.or(flagBN).toString();
+  }
+
+  private encodeBalancerParam(param: BalancerParam): string {
+    const [kind, swaps, assets, funds, limits, deadline] = param;
+
+    const encoded = this.balancerVaultInterface.encodeFunctionData(
+      'batchSwap',
+      [kind, swaps, assets, funds, limits, deadline],
+    );
+    return encoded;
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DirectMethodsV6.directSell, DirectMethodsV6.directBuy];
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -1283,6 +1513,57 @@ export class BalancerV2
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    context: Context,
+  ): DexExchangeParam {
+    const params = this.getBalancerParamV6(
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      data,
+      side,
+      recipient,
+      side === SwapSide.BUY
+        ? this.dexHelper.config.data.executorsAddresses![Executors.THREE]
+        : NULL_ADDRESS,
+    );
+
+    let exchangeData = this.eventPools.vaultInterface.encodeFunctionData(
+      'batchSwap',
+      params,
+    );
+    let specialDexFlag = SpecialDex.DEFAULT;
+
+    if (side === SwapSide.SELL) {
+      const swaps = params[1];
+      const totalAmount = swaps.reduce<BigNumber>((acc, swap) => {
+        return acc.add(swap.amount);
+      }, BigNumber.from(0));
+
+      exchangeData = solidityPack(
+        ['bytes32', 'bytes'],
+        [hexZeroPad(hexlify(totalAmount), 32), exchangeData],
+      );
+      specialDexFlag = SpecialDex.SWAP_ON_BALANCER_V2;
+    }
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      specialDexFlag,
+      targetExchange: this.vaultAddress,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     this.eventPools.allPools = await this.eventPools.fetchAllSubgraphPools();
   }

package/src/dex/balancer-v2/constants.ts

@@ -13,3 +13,8 @@ export enum DirectMethods {
   directSell = 'directBalancerV2GivenInSwap',
   directBuy = 'directBalancerV2GivenOutSwap',
 }
+
+export enum DirectMethodsV6 {
+  directSell = 'swapExactAmountInOnBalancerV2',
+  directBuy = 'swapExactAmountOutOnBalancerV2',
+}

package/src/dex/balancer-v2/types.ts

@@ -137,6 +137,19 @@ export type BalancerV2DirectParam = [
   uuid: string,
 ];
 
+export type BalancerV2DirectParamV6 = [
+  quotedAmount: NumberAsString,
+  metadata: string,
+  beneficiaryAndApproveFlag: NumberAsString,
+];
+
+export type BalancerV2DirectParamV6Swap = [
+  params: BalancerV2DirectParamV6,
+  partnerAndFee: string,
+  permit: string,
+  balancerParams: string,
+];
+
 export type BalancerV2Data = {
   poolId: string;
 };

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

@@ -0,0 +1,91 @@
+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 = 'bancor';
+
+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: 'BNT',
+        amount: '1000000000000000000000',
+      },
+      {
+        symbol: 'USDT',
+        amount: '1000000000000000000000',
+      },
+    ],
+  ];
+
+  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('Bancor E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

package/src/dex/{bancor.ts → bancor/bancor.ts}

@@ -1,37 +1,18 @@
 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 BancorABI from '../abi/Bancor.json';
-import Web3 from 'web3';
-import { IDexHelper } from '../dex-helper';
-
-const BANCOR_NETWORK: { [network: string]: string } = {
-  1: '0x2F9EC37d6CcFFf1caB21733BdaDEdE11c823cCB0',
-};
-
-const BancorRegistry: { [network: string]: string } = {
-  1: '0x52ae12abe5d8bd778bd5397f99ca900624cfadd4',
-};
-
-export type BancorData = {
-  minDestToken: string;
-  path: Address[];
-  bancorNetwork?: string;
-};
-
-type BancorParam = [
-  path: Address[],
-  srcAmount: string,
-  minDestToken: string,
-  affiliateAccount: string,
-  affiliateFee: string,
-];
-
-enum BancorFunctions {
-  convert2 = 'convert2',
-}
+import { NULL_ADDRESS, SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import BancorABI from '../../abi/Bancor.json';
+import { IDexHelper } from '../../dex-helper';
+import { BancorData, BancorFunctions, BancorParam } from './types';
+import { BANCOR_NETWORK, BancorRegistry } from './config';
 
 export class Bancor
   extends SimpleExchange
@@ -104,4 +85,36 @@ export class Bancor
       data.bancorNetwork || BANCOR_NETWORK[this.network],
     );
   }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    data: BancorData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const defaultArgs = [
+      data.path,
+      srcAmount,
+      data.minDestToken || '1',
+      NULL_ADDRESS,
+      '0',
+    ];
+    const swapMethod = BancorFunctions.convert2;
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapMethod,
+      defaultArgs,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: data.bancorNetwork || BANCOR_NETWORK[this.network],
+    };
+  }
 }

package/src/dex/bancor/config.ts

@@ -0,0 +1,9 @@
+import { Network } from '../../constants';
+
+export const BANCOR_NETWORK: { [network: string]: string } = {
+  [Network.MAINNET]: '0x2F9EC37d6CcFFf1caB21733BdaDEdE11c823cCB0',
+};
+
+export const BancorRegistry: { [network: string]: string } = {
+  [Network.MAINNET]: '0x52ae12abe5d8bd778bd5397f99ca900624cfadd4',
+};

package/src/dex/bancor/types.ts

@@ -0,0 +1,19 @@
+import { Address } from '@paraswap/core';
+
+export type BancorData = {
+  minDestToken: string;
+  path: Address[];
+  bancorNetwork?: string;
+};
+
+export type BancorParam = [
+  path: Address[],
+  srcAmount: string,
+  minDestToken: string,
+  affiliateAccount: string,
+  affiliateFee: string,
+];
+
+export enum BancorFunctions {
+  convert2 = 'convert2',
+}