@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -10,6 +10,7 @@ import { Adapters, CurveV1Config } from './config';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangePrices,
   ExchangeTxInfo,
   PoolLiquidity,
@@ -60,6 +61,7 @@ import {
   getDexKeysWithNetwork,
   interpolate,
   isDestTokenTransferFeeToBeExchanged,
+  isETHAddress,
   isSrcTokenTransferFeeToBeExchanged,
   Utils,
   uuidToBytes16,
@@ -82,10 +84,15 @@ import {
   CurveSwapFunctions,
   CurveV1SwapType,
   DirectCurveV1Param,
+  DirectCurveV1ParamV6,
+  CurveV1DirectSwap,
 } from './types';
 import { erc20Iface } from '../../lib/utils-interfaces';
 import { applyTransferFee } from '../../lib/token-transfer-fee';
-import { DIRECT_METHOD_NAME } from './constants';
+import { DIRECT_METHOD_NAME, DIRECT_METHOD_NAME_V6 } from './constants';
+import { packCurveData } from '../../lib/curve/encoder';
+import { encodeCurveAssets } from './packer';
+import { hexConcat, hexZeroPad, hexlify } from 'ethers/lib/utils';
 
 const CURVE_DEFAULT_CHUNKS = 10;
 
@@ -96,7 +103,7 @@ const coder = new AbiCoder();
 
 export class CurveV1
   extends SimpleExchange
-  implements IDex<CurveV1Data, DirectCurveV1Param>
+  implements IDex<CurveV1Data, DirectCurveV1Param | CurveV1DirectSwap>
 {
   exchangeRouterInterface: Interface;
   minConversionRate = '1';
@@ -890,13 +897,11 @@ export class CurveV1
     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);
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        optimalSwapExchange.data.exchange,
+      );
     } catch (e) {
       this.logger.error(
         `preProcessTransaction failed to retrieve allowance info: `,
@@ -979,6 +984,100 @@ export class CurveV1
     };
   }
 
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: CurveV1Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (contractMethod !== DIRECT_METHOD_NAME_V6) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const swapParams: DirectCurveV1ParamV6 = [
+      packCurveData(
+        data.exchange,
+        !data.isApproved, // approve flag, if not approved then set to true
+        isETHAddress(destToken) ? 0 : isETHAddress(srcToken) ? 3 : 0,
+        data.underlyingSwap
+          ? CurveV1SwapType.EXCHANGE_UNDERLYING
+          : CurveV1SwapType.EXCHANGE,
+      ).toString(),
+      encodeCurveAssets(data.i, data.j).toString(),
+      srcToken,
+      destToken,
+      fromAmount,
+      toAmount,
+      quotedAmount,
+      metadata,
+      beneficiary,
+    ];
+
+    const encodeParams: CurveV1DirectSwap = [swapParams, partnerAndFee, permit];
+
+    const encoder = (...params: CurveV1DirectSwap) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        DIRECT_METHOD_NAME_V6,
+        [...params],
+      );
+    };
+
+    return {
+      encoder,
+      params: encodeParams,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DIRECT_METHOD_NAME_V6];
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: CurveV1Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, underlyingSwap } = data;
+    const defaultArgs = [i, j, srcAmount, this.minConversionRate];
+    const swapMethod = underlyingSwap
+      ? CurveSwapFunctions.exchange_underlying
+      : CurveSwapFunctions.exchange;
+    const exchangeData = this.exchangeRouterInterface.encodeFunctionData(
+      swapMethod,
+      defaultArgs,
+    );
+
+    return {
+      exchangeData,
+      needWrapNative: this.needWrapNative,
+      sendEthButSupportsInsertFromAmount: true,
+      dexFuncHasRecipient: false,
+      targetExchange: exchange,
+    };
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,

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

@@ -0,0 +1,17 @@
+import { BigNumber } from 'ethers';
+
+export const encodeCurveAssets = (i: number, j: number): BigNumber => {
+  // Ensure i and j are within the range of uint128
+  if (i < 0 || j < 0 || i >= 2 ** 128 || j >= 2 ** 128) {
+    throw new Error('i and j must be within the range of uint128');
+  }
+
+  // Convert i and j to BigNumber
+  const bigI = BigNumber.from(i);
+  const bigJ = BigNumber.from(j);
+
+  // Left shift i by 128 bits and then bitwise OR with j
+  const packedValue = bigI.shl(128).or(bigJ);
+
+  return packedValue;
+};

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

@@ -68,3 +68,21 @@ export type DirectCurveV1Param = [
   permit: string,
   uuid: string,
 ];
+
+export type DirectCurveV1ParamV6 = [
+  curveData: NumberAsString,
+  curveAssets: NumberAsString,
+  srcToken: Address,
+  destToken: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  quotedAmount: NumberAsString,
+  metadata: string,
+  beneficiary: Address,
+];
+
+export type CurveV1DirectSwap = [
+  params: DirectCurveV1ParamV6,
+  partnerAndFee: string,
+  permit: string,
+];

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

@@ -26,10 +26,11 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
-        ContractMethod.directCurveV1Swap,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
+        // ContractMethod.directCurveV1Swap,
+        ContractMethod.swapExactAmountIn,
       ],
     ],
   ]);
@@ -166,14 +167,14 @@ describe('CurveV1Factory E2E', () => {
       tokenBAmount,
     );
   });
-  describe('Polygon', () => {
+  describe('Polygon_V6', () => {
     const network = Network.POLYGON;
 
     const tokenASymbol: string = 'USDC';
     const tokenBSymbol: string = 'axlUSDC';
 
-    const tokenAAmount: string = '111000000';
-    const tokenBAmount: string = '111000000';
+    const tokenAAmount: string = '1110000';
+    const tokenBAmount: string = '1110000';
 
     testForNetwork(
       network,
@@ -204,7 +205,7 @@ describe('CurveV1Factory E2E', () => {
   //   );
   // });
 
-  describe('Polygon amUSDC', () => {
+  describe('Polygon amUSDC V6', () => {
     const network = Network.POLYGON;
 
     const tokenASymbol: string = 'deUSDC';

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

@@ -16,6 +16,7 @@ import {
   TxInfo,
   PreprocessTransactionOptions,
   ExchangeTxInfo,
+  DexExchangeParam,
 } from '../../types';
 import {
   SwapSide,
@@ -927,13 +928,11 @@ export class CurveV1Factory
     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);
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        optimalSwapExchange.data.exchange,
+      );
     } catch (e) {
       this.logger.error(
         `preProcessTransaction failed to retrieve allowance info: `,
@@ -955,6 +954,7 @@ export class CurveV1Factory
     ];
   }
 
+  // FIXME: need v6 function
   getDirectParam(
     srcToken: Address,
     destToken: Address,
@@ -1051,6 +1051,36 @@ export class CurveV1Factory
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: CurveV1FactoryData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, underlyingSwap } = data;
+    const defaultArgs = [i, j, srcAmount, MIN_AMOUNT_TO_RECEIVE];
+    const swapMethod = underlyingSwap
+      ? CurveSwapFunctions.exchange_underlying
+      : CurveSwapFunctions.exchange;
+    const exchangeData = this.ifaces.exchangeRouter.encodeFunctionData(
+      swapMethod,
+      defaultArgs,
+    );
+
+    return {
+      exchangeData,
+      needWrapNative: this.needWrapNative,
+      sendEthButSupportsInsertFromAmount: true,
+      dexFuncHasRecipient: false,
+      targetExchange: exchange,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     if (!this.areFactoryPoolsFetched) {
       await this.fetchFactoryPools(undefined, false);

package/src/dex/curve-v1-factory/state-polling-pools/polling-manager.ts

@@ -127,9 +127,9 @@ export class StatePollingManager {
         }),
       );
 
-      logger.info(
-        `${dexKey}: all (${pools.length}) pools state was successfully updated on network ${dexHelper.config.data.network}`,
-      );
+      // logger.info(
+      //   `${dexKey}: all (${pools.length}) pools state was successfully updated on network ${dexHelper.config.data.network}`,
+      // );
     } catch (e) {
       logger.error(
         `${dexKey}: On network ${

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

@@ -0,0 +1 @@
+export const DIRECT_METHOD_NAME_V6 = 'swapExactAmountInOnCurveV2';

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

@@ -0,0 +1,104 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import {
+  Holders,
+  NativeTokenSymbols,
+  Tokens,
+} from '../../../tests/constants-e2e';
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+import { testE2E } from '../../../tests/utils-e2e';
+
+const dexKey = 'CurveV2';
+
+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: 'USDC',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+    [
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'DAI',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+  ];
+
+  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('CurveV2 E2E', () => {
+  describe('CurveV2_MAINNET_v6', () => {
+    //
+  });
+
+  describe('CurveV2_POLYGON_v6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountInOnCurveV2]],
+    ]);
+
+    testForNetwork(Network.POLYGON, swapMap);
+  });
+});

package/src/dex/{curve-v2.ts → curve-v2/curve-v2.ts}

@@ -1,34 +1,37 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
-import { SwapSide } from '../constants';
+import { SwapSide } from '../../constants';
 import {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   ExchangeTxInfo,
   NumberAsString,
   PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
   TxInfo,
-} from '../types';
-import { IDexTxBuilder } from './idex';
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
   SimpleExchange,
-} from './simple-exchange';
-import GenericFactoryZapABI from '../abi/curve-v2/GenericFactoryZap.json';
-import DirectSwapABI from '../abi/DirectSwap.json';
-import CurveV2ABI from '../abi/CurveV2.json';
-import { IDexHelper } from '../dex-helper';
+} from '../simple-exchange';
+import GenericFactoryZapABI from '../../abi/curve-v2/GenericFactoryZap.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
+import CurveV2ABI from '../../abi/CurveV2.json';
+import { IDexHelper } from '../../dex-helper';
 import { assert } from 'ts-essentials';
 import { Logger } from 'log4js';
 import { OptimalSwapExchange } from '@paraswap/core';
-import { uuidToBytes16 } from '../utils';
-
-export enum CurveV2SwapType {
-  EXCHANGE,
-  EXCHANGE_UNDERLYING,
-  EXCHANGE_GENERIC_FACTORY_ZAP,
-}
+import { isETHAddress, uuidToBytes16 } from '../../utils';
+import { DIRECT_METHOD_NAME_V6 } from './constants';
+import {
+  CurveV2DirectSwap,
+  CurveV2DirectSwapParam,
+  CurveV2SwapType,
+} from './types';
+import { packCurveData } from '../../lib/curve/encoder';
+import { hexConcat, hexZeroPad, hexlify } from 'ethers/lib/utils';
 
 const DIRECT_METHOD_NAME = 'directCurveV2Swap';
 
@@ -85,7 +88,7 @@ enum CurveV2SwapFunctions {
 
 export class CurveV2
   extends SimpleExchange
-  implements IDexTxBuilder<CurveV2Data, DirectCurveV2Param>
+  implements IDexTxBuilder<CurveV2Data, DirectCurveV2Param | CurveV2DirectSwap>
 {
   static dexKeys = ['curvev2'];
   exchangeRouterInterface: Interface;
@@ -169,13 +172,11 @@ export class CurveV2
     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);
+      isApproved = await this.dexHelper.augustusApprovals.hasApproval(
+        options.executionContractAddress,
+        this.dexHelper.config.wrapETH(srcToken).address,
+        optimalSwapExchange.data.exchange,
+      );
     } catch (e) {
       this.logger.error(
         `preProcessTransaction failed to retrieve allowance info: `,
@@ -257,6 +258,71 @@ export class CurveV2
     };
   }
 
+  getDirectParamV6(
+    srcToken: Address,
+    destToken: Address,
+    fromAmount: NumberAsString,
+    toAmount: NumberAsString,
+    quotedAmount: NumberAsString,
+    data: CurveV2Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    partnerAndFee: string,
+    beneficiary: string,
+    blockNumber: number,
+    contractMethod?: string,
+  ) {
+    if (contractMethod !== DIRECT_METHOD_NAME_V6) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    assert(side === SwapSide.SELL, 'Buy not supported');
+
+    const metadata = hexConcat([
+      hexZeroPad(uuidToBytes16(uuid), 16),
+      hexZeroPad(hexlify(blockNumber), 16),
+    ]);
+
+    const swapParams: CurveV2DirectSwapParam = [
+      packCurveData(
+        data.exchange,
+        !data.isApproved, // approve flag, if not approved then set to true
+        isETHAddress(destToken) ? 2 : isETHAddress(srcToken) ? 1 : 0,
+        data.swapType,
+      ).toString(),
+      data.i,
+      data.j,
+      data.originalPoolAddress,
+      srcToken,
+      destToken,
+      fromAmount,
+      toAmount,
+      quotedAmount,
+      metadata,
+      beneficiary,
+    ];
+
+    const encodeParams: CurveV2DirectSwap = [swapParams, partnerAndFee, permit];
+
+    const encoder = (...params: CurveV2DirectSwap) => {
+      return this.augustusV6Interface.encodeFunctionData(
+        DIRECT_METHOD_NAME_V6,
+        [...params],
+      );
+    };
+
+    return {
+      params: encodeParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionNameV6(): string[] {
+    return [DIRECT_METHOD_NAME_V6];
+  }
+
   static getDirectFunctionName(): string[] {
     return [DIRECT_METHOD_NAME];
   }
@@ -315,4 +381,58 @@ export class CurveV2
       exchange,
     );
   }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: CurveV2Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const { exchange, i, j, originalPoolAddress, swapType } = data;
+
+    const args: CurveV2Param | CurveV2ParamsForGenericFactoryZap =
+      swapType === CurveV2SwapType.EXCHANGE_GENERIC_FACTORY_ZAP
+        ? [
+            originalPoolAddress,
+            i.toString(),
+            j.toString(),
+            srcAmount,
+            this.minConversionRate,
+          ]
+        : [i.toString(), j.toString(), srcAmount, this.minConversionRate];
+
+    let swapMethod: string;
+    switch (swapType) {
+      case CurveV2SwapType.EXCHANGE:
+        swapMethod = CurveV2SwapFunctions.exchange;
+        break;
+      case CurveV2SwapType.EXCHANGE_UNDERLYING:
+        swapMethod = CurveV2SwapFunctions.exchange_underlying;
+        break;
+      case CurveV2SwapType.EXCHANGE_GENERIC_FACTORY_ZAP:
+        swapMethod = CurveV2SwapFunctions.exchange_in_generic_factory_zap;
+        break;
+      default:
+        throw new Error(
+          `getSimpleParam: not all cases covered for CurveV2SwapTypes`,
+        );
+    }
+
+    const swapData =
+      swapMethod === CurveV2SwapFunctions.exchange_in_generic_factory_zap
+        ? this.genericFactoryZapIface.encodeFunctionData(swapMethod, args)
+        : this.exchangeRouterInterface.encodeFunctionData(swapMethod, args);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: exchange,
+    };
+  }
 }

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

@@ -0,0 +1,27 @@
+import { Address, NumberAsString } from '@paraswap/core';
+
+export type CurveV2DirectSwapParam = [
+  curveData: NumberAsString, // packed curvedata
+  i: number, // i
+  j: number, // j
+  poolAddress: Address, // pool address
+  srcToken: Address, // src token
+  destToken: Address, // dest token,
+  fromAmount: NumberAsString, // fromAmount
+  toAmount: NumberAsString, // toAmount
+  quotedAmount: NumberAsString, // quotedAmount,
+  metadata: string, // metadata - bytes32
+  beneficiary: Address, // beneficiary
+];
+
+export enum CurveV2SwapType {
+  EXCHANGE,
+  EXCHANGE_UNDERLYING,
+  EXCHANGE_GENERIC_FACTORY_ZAP,
+}
+
+export type CurveV2DirectSwap = [
+  params: CurveV2DirectSwapParam,
+  partnerAndFee: string,
+  permit: string,
+];