@paraswap/dex-lib 2.19.1 → 2.20.0

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

@@ -535,6 +535,85 @@ describe('BalancerV2 E2E', () => {
       */
   });
 
+  describe('BalancerV2 Polygon', () => {
+    const dexKey = 'BalancerV2';
+    const network = Network.POLYGON;
+    const tokens = Tokens[Network.POLYGON];
+    const holders = Holders[Network.POLYGON];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+          ContractMethod.directBalancerV2GivenInSwap,
+        ],
+      ],
+      [
+        SwapSide.BUY,
+        [
+          ContractMethod.directBalancerV2GivenOutSwap,
+          ContractMethod.simpleBuy,
+          ContractMethod.buy,
+        ],
+      ],
+    ]);
+
+    const pairs: { name: string; sellAmount: string }[][] = [
+      [
+        { name: 'WMATIC', sellAmount: '1000000000000000000' },
+        { name: 'stMATIC', sellAmount: '1000000000000000000' },
+      ],
+      [
+        { name: 'MATIC', sellAmount: '1000000000000000000' },
+        { name: 'stMATIC', sellAmount: '1000000000000000000' },
+      ],
+    ];
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          pairs.forEach(pair => {
+            describe(`${contractMethod}`, () => {
+              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                await testE2E(
+                  tokens[pair[0].name],
+                  tokens[pair[1].name],
+                  holders[pair[0].name],
+                  pair[0].sellAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  tokens[pair[1].name],
+                  tokens[pair[0].name],
+                  holders[pair[1].name],
+                  pair[1].sellAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+            });
+          });
+        });
+      }),
+    );
+  });
+
   describe('BalancerV2 ARBITRUM', () => {
     const dexKey = 'BalancerV2';
     const network = Network.ARBITRUM;

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

@@ -7,6 +7,9 @@ import {
   ExchangePrices,
   Log,
   Logger,
+  TxInfo,
+  PreprocessTransactionOptions,
+  ExchangeTxInfo,
   PoolLiquidity,
   PoolPrices,
   SimpleExchangeParam,
@@ -27,8 +30,13 @@ import { WeightedPool } from './pools/weighted/WeightedPool';
 import { PhantomStablePool } from './pools/phantom-stable/PhantomStablePool';
 import { LinearPool } from './pools/linear/LinearPool';
 import VaultABI from '../../abi/balancer-v2/vault.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
 import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { getBigIntPow, getDexKeysWithNetwork } from '../../utils';
+import {
+  getDexKeysWithNetwork,
+  getBigIntPow,
+  uuidToBytes16,
+} from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper';
 import {
@@ -41,11 +49,15 @@ import {
   PoolStateCache,
   PoolStateMap,
   SubgraphPoolAddressDictionary,
+  BalancerV2DirectParam,
   SubgraphPoolBase,
   SwapTypes,
 } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { Adapters, BalancerConfig } from './config';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
+import { BalancerConfig, Adapters } from './config';
 import {
   getAllPoolsUsedInPaths,
   isSameAddress,
@@ -53,10 +65,12 @@ import {
   poolGetPathForTokenInOut,
 } from './utils';
 import {
+  DirectMethods,
   MIN_USD_LIQUIDITY_TO_FETCH,
   STABLE_GAS_COST,
   VARIABLE_GAS_COST_PER_CYCLE,
 } from './constants';
+import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
 
 const fetchAllPools = `query ($count: Int) {
   pools: pools(
@@ -493,13 +507,16 @@ export class BalancerV2EventPool extends StatefulEventSubscriber<PoolStateMap> {
 
 export class BalancerV2
   extends SimpleExchange
-  implements IDex<BalancerV2Data, BalancerParam, OptimizedBalancerV2Data>
+  implements
+    IDex<BalancerV2Data, BalancerV2DirectParam, OptimizedBalancerV2Data>
 {
   public eventPools: BalancerV2EventPool;
 
   readonly hasConstantPriceLargeAmounts = false;
   readonly isFeeOnTransferSupported = false;
 
+  readonly directSwapIface = new Interface(DirectSwapABI);
+
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(BalancerConfig);
 
@@ -1019,6 +1036,138 @@ export class BalancerV2
     return params;
   }
 
+  static getDirectFunctionName(): string[] {
+    return [DirectMethods.directSell, DirectMethods.directBuy];
+  }
+
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<OptimizedBalancerV2Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<OptimizedBalancerV2Data>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    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);
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: OptimizedBalancerV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<BalancerV2DirectParam> {
+    if (
+      contractMethod !== DirectMethods.directSell &&
+      contractMethod !== DirectMethods.directBuy
+    ) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const [, swaps, assets, funds, limits, _deadline] = this.getBalancerParam(
+      srcToken,
+      destToken,
+      srcAmount,
+      destAmount,
+      data,
+      side,
+    );
+
+    const swapParams: BalancerV2DirectParam = [
+      swaps,
+      assets,
+      funds,
+      limits,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      _deadline,
+      feePercent,
+      this.vaultAddress,
+      partner,
+      isApproved,
+      beneficiary,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: BalancerV2DirectParam) => {
+      return this.directSwapIface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethods.directSell
+          : DirectMethods.directBuy,
+        [params],
+      );
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,

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

@@ -8,3 +8,8 @@ export const STABLE_GAS_COST = 84_000;
 
 // I see three pools used in trade: (57856 + 79098 + 51041) / 3 = 62665 ~ 63k
 export const VARIABLE_GAS_COST_PER_CYCLE = 63_000;
+
+export enum DirectMethods {
+  directSell = 'directBalancerV2GivenInSwap',
+  directBuy = 'directBalancerV2GivenOutSwap',
+}

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

@@ -1,3 +1,4 @@
+import { NumberAsString } from '@paraswap/core';
 import { Address } from '../../types';
 
 // These should match the Balancer Pool types available on Subgraph
@@ -85,12 +86,13 @@ export type BalancerSwapV2 = {
 
 export type OptimizedBalancerV2Data = {
   swaps: BalancerSwapV2[];
+  isApproved?: boolean;
 };
 
 export type BalancerFunds = {
   sender: string;
-  recipient: string;
   fromInternalBalance: boolean;
+  recipient: string;
   toInternalBalance: boolean;
 };
 
@@ -117,6 +119,24 @@ export type BalancerParam = [
   deadline: string,
 ];
 
+export type BalancerV2DirectParam = [
+  swaps: BalancerSwap[],
+  assets: Address[],
+  funds: BalancerFunds,
+  limits: NumberAsString[],
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  deadline: NumberAsString,
+  feePercent: NumberAsString,
+  vault: Address,
+  partner: Address,
+  isApproved: boolean,
+  beneficiary: Address,
+  permit: string,
+  uuid: string,
+];
+
 export type BalancerV2Data = {
   poolId: string;
 };

package/src/dex/curve-v1/constants.ts

@@ -2,6 +2,8 @@ import { CurveV1Config } from './config';
 import { SwerveConfig } from './forks/swerve/config';
 import { CurveForksConfig } from './forks/curve-forks/config';
 
+export const DIRECT_METHOD_NAME = 'directCurveV1Swap';
+
 export const AllCurveForks = [
   ...Object.keys(CurveV1Config),
   ...Object.keys(CurveForksConfig),

package/src/dex/curve-v1/curve-v1-e2e.test.ts

@@ -133,6 +133,63 @@ describe('CurveV1 E2E', () => {
     });
   });
 
+  describe('CurveV1 POLYGON', () => {
+    const network = Network.POLYGON;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokensToTest = [
+      [
+        {
+          symbol: 'USDT',
+          amount: (10 ** 8).toString(),
+        },
+        {
+          symbol: 'DAI',
+          amount: (10 ** 8).toString(),
+        },
+      ],
+    ];
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+          ContractMethod.directCurveV1Swap,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        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,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+
   describe('FANTOM', () => {
     const network = Network.FANTOM;
     const tokens = Tokens[network];

package/src/dex/curve-v1/curve-v1.ts

@@ -1,17 +1,24 @@
 import { Interface, AbiCoder, JsonFragment } from '@ethersproject/abi';
+import _ from 'lodash';
+import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
+import { assert } from 'ts-essentials';
 import BigNumber from 'bignumber.js';
 import CurveABI from '../../abi/Curve.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
 import { Adapters, CurveV1Config } from './config';
 
 import {
   AdapterExchangeParam,
   Address,
   ExchangePrices,
+  ExchangeTxInfo,
   PoolLiquidity,
   PoolPrices,
+  PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
   TransferFeeParams,
+  TxInfo,
 } from '../../types';
 import {
   Network,
@@ -48,8 +55,6 @@ import { TBTCPool, address as TBTCPoolAddress } from './pools/tBTCpool';
 import { USDKPool, address as USDKPoolAddress } from './pools/usdkpool';
 import { USTPool, address as USTPoolAddress } from './pools/ustpool';
 import { SLINKPool, address as SLINKPoolAddress } from './pools/sLinkpool';
-
-import * as _ from 'lodash';
 import {
   getBigIntPow,
   getDexKeysWithNetwork,
@@ -57,9 +62,13 @@ import {
   isDestTokenTransferFeeToBeExchanged,
   isSrcTokenTransferFeeToBeExchanged,
   Utils,
+  uuidToBytes16,
 } from '../../utils';
 import { BN_0 } from '../../bignumber-constants';
-import { SimpleExchange } from '../simple-exchange';
+import {
+  getLocalDeadlineAsFriendlyPlaceholder,
+  SimpleExchange,
+} from '../simple-exchange';
 import { IDex } from '../idex';
 import { IDexHelper } from '../../dex-helper';
 import { Logger } from 'log4js';
@@ -71,9 +80,12 @@ import {
   CurveV1Data,
   TokenWithReasonableVolume,
   CurveSwapFunctions,
+  CurveV1SwapType,
+  DirectCurveV1Param,
 } from './types';
 import { erc20Iface } from '../../lib/utils-interfaces';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
+import { DIRECT_METHOD_NAME } from './constants';
 
 const CURVE_DEFAULT_CHUNKS = 10;
 
@@ -82,7 +94,10 @@ const CURVE_POOL_GAS = 200 * 1000;
 
 const coder = new AbiCoder();
 
-export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
+export class CurveV1
+  extends SimpleExchange
+  implements IDex<CurveV1Data, DirectCurveV1Param>
+{
   exchangeRouterInterface: Interface;
   minConversionRate = '1';
 
@@ -102,6 +117,8 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
 
   protected disableFeeOnTransferTokenAddresses: Set<string>;
 
+  readonly directSwapIface = new Interface(DirectSwapABI);
+
   readonly SRC_TOKEN_DEX_TRANSFERS = 1;
   readonly DEST_TOKEN_DEX_TRANSFERS = 1;
 
@@ -840,6 +857,128 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
     return this.adapters[side];
   }
 
+  static getDirectFunctionName(): string[] {
+    return [DIRECT_METHOD_NAME];
+  }
+
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<CurveV1Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<CurveV1Data>, ExchangeTxInfo]> {
+    if (!options.isDirectMethod) {
+      return [
+        optimalSwapExchange,
+        {
+          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+        },
+      ];
+    }
+
+    assert(
+      optimalSwapExchange.data !== undefined,
+      `preProcessTransaction: data field is missing`,
+    );
+
+    let isApproved: boolean | undefined;
+
+    try {
+      this.erc20Contract.options.address =
+        this.dexHelper.config.wrapETH(srcToken).address;
+      const allowance = await this.erc20Contract.methods
+        .allowance(this.augustusAddress, optimalSwapExchange.data.exchange)
+        .call(undefined, 'latest');
+      isApproved =
+        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
+    } catch (e) {
+      this.logger.error(
+        `preProcessTransaction failed to retrieve allowance info: `,
+        e,
+      );
+    }
+
+    return [
+      {
+        ...optimalSwapExchange,
+        data: {
+          ...optimalSwapExchange.data,
+          isApproved,
+        },
+      },
+      {
+        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: CurveV1Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<DirectCurveV1Param> {
+    if (contractMethod !== DIRECT_METHOD_NAME) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const swapParams: DirectCurveV1Param = [
+      srcToken,
+      destToken,
+      data.exchange,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      feePercent,
+      data.i.toString(),
+      data.j.toString(),
+      partner,
+      isApproved,
+      data.underlyingSwap
+        ? CurveV1SwapType.EXCHANGE_UNDERLYING
+        : CurveV1SwapType.EXCHANGE,
+      beneficiary,
+      // For CurveV1 we work as it is, without wrapping and unwrapping
+      false,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: DirectCurveV1Param) => {
+      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
+        params,
+      ]);
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -943,7 +1082,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
       // the balances array in the pool as it was a mess to have each curve abi
       // Some have balances[uint128] some have balances[uint256]
       // One of the consequence for such a hack is below for ETH Pools
-      // TODO: below can be highly optimised
+      // TODO: below can be highly optimized
       // * we don't need to query token decimals every iteration
       // * we can use the decimals from the tokens list using the api
 

package/src/dex/curve-v1/types.ts

@@ -1,3 +1,4 @@
+import { NumberAsString } from '@paraswap/core';
 import { Address, Token } from '../../types';
 
 export type CurveV1Data = {
@@ -6,6 +7,7 @@ export type CurveV1Data = {
   j: number;
   underlyingSwap: boolean;
   deadline: number;
+  isApproved?: boolean;
 };
 
 export type PoolConfig = {
@@ -42,3 +44,27 @@ export enum CurveSwapFunctions {
   exchange = 'exchange',
   exchange_underlying = 'exchange_underlying',
 }
+
+export enum CurveV1SwapType {
+  EXCHANGE,
+  EXCHANGE_UNDERLYING,
+}
+
+export type DirectCurveV1Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  i: NumberAsString,
+  j: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  swapType: CurveV1SwapType,
+  beneficiary: Address,
+  needWrapNative: boolean,
+  permit: string,
+  uuid: string,
+];

package/src/dex/curve-v1-factory/constants.ts

@@ -34,3 +34,5 @@ export const NETWORK_ID_TO_NAME: Record<number, string> = {
 // revisited
 export const FACTORY_MAX_PLAIN_COINS = 4;
 export const FACTORY_MAX_PLAIN_IMPLEMENTATIONS_FOR_COIN = 10;
+
+export const DIRECT_METHOD_NAME = 'directCurveV1Swap';

package/src/dex/curve-v1-factory/curve-v1-factory-e2e.test.ts

@@ -29,6 +29,7 @@ function testForNetwork(
         ContractMethod.simpleSwap,
         ContractMethod.multiSwap,
         ContractMethod.megaSwap,
+        ContractMethod.directCurveV1Swap,
       ],
     ],
   ]);