@paraswap/dex-lib 2.45.0 → 3.0.0

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

@@ -11,46 +11,7 @@ import {
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
-import { TransferFeeParams } from '../../types';
-
-/*
-  README
-  ======
-
-  This test script should add e2e tests for Algebra. The tests
-  should cover as many cases as possible. Most of the DEXes follow
-  the following test structure:
-    - DexName
-      - ForkName + Network
-        - ContractMethod
-          - ETH -> Token swap
-          - Token -> ETH swap
-          - Token -> Token swap
-
-  The template already enumerates the basic structure which involves
-  testing simpleSwap, multiSwap, megaSwap contract methods for
-  ETH <> TOKEN and TOKEN <> TOKEN swaps. You should replace tokenA and
-  tokenB with any two highly liquid tokens on Algebra for the tests
-  to work. If the tokens that you would like to use are not defined in
-  Tokens or Holders map, you can update the './tests/constants-e2e'
-
-  Other than the standard cases that are already added by the template
-  it is highly recommended to add test cases which could be specific
-  to testing Algebra (Eg. Tests based on poolType, special tokens,
-  etc).
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-e2e.test.ts`
-
-  e2e tests use the Tenderly fork api. Please add the following to your
-  .env file:
-  TENDERLY_TOKEN=Find this under Account>Settings>Authorization.
-  TENDERLY_ACCOUNT_ID=Your Tenderly account name.
-  TENDERLY_PROJECT=Name of a Tenderly project you have created in your
-  dashboard.
-
-  (This comment should be removed from the final implementation)
-*/
+import { TransferFeeParamsForRoute } from '../../types';
 
 function testForNetwork(
   network: Network,
@@ -60,12 +21,19 @@ function testForNetwork(
   tokenAAmount: string,
   tokenBAmount: string,
   nativeTokenAmount: string,
-  transferFees: TransferFeeParams = {
-    srcFee: 0,
-    destFee: 0,
-    srcDexFee: 0,
-    destDexFee: 0,
+  // To be tested against E2E endpoint
+  transferFees: TransferFeeParamsForRoute = {
+    srcTokenTransferFee: 0,
+    destTokenTransferFee: 0,
+    srcTokenDexTransferFee: 0,
+    destTokenDexTransferFee: 0,
   },
+  // transferFees: TransferFeeParams = {
+  //   srcFee: 0,
+  //   destFee: 0,
+  //   srcDexFee: 0,
+  //   destDexFee: 0,
+  // },
 ) {
   const provider = new StaticJsonRpcProvider(
     generateConfig(network).privateHttpProvider,
@@ -80,14 +48,15 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
       ],
     ],
     // TODO: If buy is not supported remove the buy contract methods
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-    // [SwapSide.BUY, [ContractMethod.simpleBuy]],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -96,7 +65,8 @@ function testForNetwork(
         contractMethods.forEach((contractMethod: ContractMethod) => {
           describe(`${contractMethod}`, () => {
             // if src token is tax token and BUY side, then should fail (skip)
-            if (!!transferFees?.srcDexFee && side === SwapSide.BUY) return;
+            if (!!transferFees?.srcTokenTransferFee && side === SwapSide.BUY)
+              return;
 
             it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
               await testE2E(
@@ -111,7 +81,7 @@ function testForNetwork(
                 provider,
                 undefined,
                 undefined,
-                transferFees,
+                transferFees as any,
               );
             });
             it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
@@ -130,9 +100,9 @@ function testForNetwork(
                 // switch src and dest fee when tax token is dest token
                 {
                   ...transferFees,
-                  srcDexFee: transferFees.destDexFee,
-                  destDexFee: transferFees.srcDexFee,
-                },
+                  srcTokenDexTransferFee: transferFees.destTokenDexTransferFee,
+                  destTokenDexTransferFee: transferFees.srcTokenDexTransferFee,
+                } as any,
               );
             });
             it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
@@ -151,9 +121,9 @@ function testForNetwork(
                 // switch src and dest fee when tax token is dest token
                 {
                   ...transferFees,
-                  srcDexFee: transferFees.destDexFee,
-                  destDexFee: transferFees.srcDexFee,
-                },
+                  srcTokenDexTransferFee: transferFees.destTokenDexTransferFee,
+                  destTokenDexTransferFee: transferFees.srcTokenDexTransferFee,
+                } as any,
               );
             });
             it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
@@ -169,7 +139,7 @@ function testForNetwork(
                 provider,
                 undefined,
                 undefined,
-                transferFees,
+                transferFees as any,
               );
             });
           });
@@ -183,13 +153,13 @@ describe('Algebra', () => {
   describe('QuickSwapV3 E2E', () => {
     const dexKey = 'QuickSwapV3';
 
-    describe('Polygon', () => {
+    describe('Polygon_V6', () => {
       const network = Network.POLYGON;
-      const tokenASymbol: string = 'USDC';
-      const tokenBSymbol: string = 'DAI';
+      const tokenASymbol: string = 'USDT';
+      const tokenBSymbol: string = 'USDC';
 
       const tokenAAmount: string = '1000000000';
-      const tokenBAmount: string = '1000000000000000000000';
+      const tokenBAmount: string = '1000000000';
       const nativeTokenAmount = '1000000000000000000';
 
       testForNetwork(
@@ -248,11 +218,11 @@ describe('Algebra', () => {
     });
   });
 
-  describe('CamelotV3', () => {
+  describe('CamelotV3_V6', () => {
     const dexKey = 'CamelotV3';
     const network = Network.ARBITRUM;
 
-    describe('Arbitrum: Tax Tokens', () => {
+    describe('Arbitrum: TaxTokens', () => {
       const tokenASymbol: string = 'RDPX';
       const tokenBSymbol: string = 'WETH';
 
@@ -269,17 +239,17 @@ describe('Algebra', () => {
         tokenBAmount,
         nativeTokenAmount,
         {
-          srcFee: 0,
-          destFee: 0,
-          srcDexFee: 1000,
-          destDexFee: 0,
-        },
+          srcTokenTransferFee: 0,
+          destTokenTransferFee: 0,
+          srcTokenDexTransferFee: 1000,
+          destTokenDexTransferFee: 0,
+        } as any,
       );
     });
 
     describe('Arbitrum: Non-Tax tokens', () => {
-      const tokenASymbol: string = 'USDCe';
-      const tokenBSymbol: string = 'USDT';
+      const tokenASymbol: string = 'USDT';
+      const tokenBSymbol: string = 'USDCe';
 
       const tokenAAmount: string = '1000000000';
       const tokenBAmount: string = '1000000000';

package/src/dex/algebra/algebra.ts

@@ -1,5 +1,5 @@
 import { defaultAbiCoder } from '@ethersproject/abi';
-import { DeepReadonly } from 'ts-essentials';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import { AbiItem } from 'web3-utils';
 import { pack } from '@ethersproject/solidity';
 import _ from 'lodash';
@@ -13,6 +13,8 @@ import {
   Address,
   PoolLiquidity,
   Token,
+  DexExchangeParam,
+  NumberAsString,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -314,7 +316,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
       }
     } catch (e) {
       if (e instanceof Error && e.message.endsWith('Pool does not exist')) {
-        /* 
+        /*
          protection against 2 race conditions
           1/ if pool.initialize() promise rejects after the Pool creation event got treated
           2/ if the rpc node we hit on the http request is lagging behind the one we got event from (websocket)
@@ -820,7 +822,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
 
     if (data.feeOnTransfer) {
       _require(
-        data.path.length !== 1,
+        data.path.length === 1,
         `LOGIC ERROR: multihop is not supported for feeOnTransfer token, passed: ${data.path
           .map(p => `${p?.tokenIn}->${p?.tokenOut}`)
           .join(' ')}`,
@@ -873,6 +875,71 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
     );
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: AlgebraData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    let swapFunction;
+    let swapFunctionParams;
+
+    if (data.feeOnTransfer) {
+      _require(
+        data.path.length === 1,
+        `LOGIC ERROR: multihop is not supported for feeOnTransfer token, passed: ${data.path
+          .map(p => `${p?.tokenIn}->${p?.tokenOut}`)
+          .join(' ')}`,
+      );
+      swapFunction = AlgebraFunctions.exactInputWithFeeToken;
+      swapFunctionParams = {
+        limitSqrtPrice: '0',
+        recipient: recipient,
+        deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+        amountIn: srcAmount,
+        amountOutMinimum: destAmount,
+        tokenIn: data.path[0].tokenIn,
+        tokenOut: data.path[0].tokenOut,
+      };
+    } else {
+      swapFunction =
+        side === SwapSide.SELL
+          ? AlgebraFunctions.exactInput
+          : AlgebraFunctions.exactOutput;
+      const path = this._encodePath(data.path, side);
+      swapFunctionParams =
+        side === SwapSide.SELL
+          ? {
+              recipient: recipient,
+              deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+              amountIn: srcAmount,
+              amountOutMinimum: destAmount,
+              path,
+            }
+          : {
+              recipient: recipient,
+              deadline: getLocalDeadlineAsFriendlyPlaceholder(),
+              amountOut: destAmount,
+              amountInMaximum: srcAmount,
+              path,
+            };
+    }
+
+    const exchangeData = this.routerIface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.router,
+    };
+  }
+
   async getTopPoolsForToken(
     tokenAddress: Address,
     limit: number,

package/src/dex/augustus-approvals.ts

@@ -0,0 +1,175 @@
+import { Address, ParaSwapVersion } from '@paraswap/core';
+import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
+import { ICache, IDexHelper } from '../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import ERC20ABI from '../abi/erc20.json';
+import { uint256ToBigInt } from '../lib/decoders';
+import { MultiCallParams, MultiWrapper } from '../lib/multi-wrapper';
+import { ConfigHelper } from '../config';
+
+const DEFAULT_APPROVE_CACHE_KEY_VALUE = 'true';
+
+// key = spender_token_target
+type ApprovalsMapping = Record<string, boolean>;
+
+export class AugustusApprovals {
+  erc20Interface: Interface;
+
+  private cache: ICache;
+
+  protected network: number;
+  protected augustusAddress: Address;
+  protected augustusV6Address: Address | undefined;
+
+  private readonly cacheApprovesKey: string;
+
+  constructor(
+    config: ConfigHelper,
+    cache: ICache,
+    protected multiWrapper: MultiWrapper,
+  ) {
+    this.network = config.data.network;
+    this.augustusAddress = config.data.augustusAddress;
+    this.augustusV6Address = config.data.augustusV6Address;
+    this.erc20Interface = new Interface(ERC20ABI);
+    this.cache = cache;
+
+    this.cacheApprovesKey = `${CACHE_PREFIX}_${this.network}_generic_approves`;
+  }
+
+  async hasApproval(
+    spender: Address,
+    token: Address,
+    target: Address,
+  ): Promise<boolean> {
+    const approvals = await this.hasApprovals(spender, [[token, target]]);
+    return approvals[0];
+  }
+
+  async hasApprovals(
+    spender: Address,
+    tokenTargetMapping: [token: Address, target: Address][],
+  ): Promise<boolean[]> {
+    let approvalsMapping: Record<string, boolean> = {};
+
+    tokenTargetMapping.forEach(([token, target]) => {
+      const key = this.createCacheKey(spender, token, target);
+      // set approved 'true' for ETH
+      approvalsMapping[key] = token.toLowerCase() === ETHER_ADDRESS;
+    });
+
+    approvalsMapping = await this.addCachedApprovals(approvalsMapping);
+
+    const cachedApprovals = Object.values(approvalsMapping);
+    if (cachedApprovals.every(approval => approval === true))
+      return cachedApprovals;
+
+    approvalsMapping = await this.addOnChainApprovals(approvalsMapping);
+
+    // to keep same order and length as input
+    return tokenTargetMapping
+      .map(([token, target]) => this.createCacheKey(spender, token, target))
+      .map(key => approvalsMapping[key]);
+  }
+
+  private async addCachedApprovals(
+    approvalsMapping: ApprovalsMapping,
+  ): Promise<ApprovalsMapping> {
+    const keys = this.filterKeys(approvalsMapping);
+    if (keys.length === 0) return approvalsMapping;
+
+    const approvals = await this.cache.hmget(this.cacheApprovesKey, keys);
+
+    approvals.forEach((approved, index) => {
+      if (approved !== null) {
+        approvalsMapping[keys[index]] = true;
+      }
+    });
+
+    return approvalsMapping;
+  }
+
+  private async setCachedApprovals(
+    approvalsMapping: ApprovalsMapping,
+  ): Promise<void> {
+    const keys = this.filterKeys(approvalsMapping, true);
+    if (keys.length === 0) return;
+
+    const mappings = Object.fromEntries(
+      keys.map(key => [key, DEFAULT_APPROVE_CACHE_KEY_VALUE]),
+    );
+
+    await this.cache.hmset(this.cacheApprovesKey, mappings);
+  }
+
+  private async getOnChainApprovals(
+    spenderTokenTargetMapping: [
+      spender: Address,
+      token: Address,
+      target: Address,
+    ][],
+  ): Promise<boolean[]> {
+    const allowanceCalldata: MultiCallParams<bigint>[] =
+      spenderTokenTargetMapping.map(([spender, token, target]) => ({
+        target: token,
+        callData: this.erc20Interface.encodeFunctionData('allowance', [
+          spender,
+          target,
+        ]),
+        decodeFunction: uint256ToBigInt,
+      }));
+
+    const allowances = await this.multiWrapper.tryAggregate<bigint>(
+      false,
+      allowanceCalldata,
+    );
+
+    return allowances.map(allowance =>
+      // as we are give approvals for max amount, just check if it's not zero
+      allowance.success ? allowance.returnData !== 0n : false,
+    );
+  }
+
+  private async addOnChainApprovals(approvalsMapping: ApprovalsMapping) {
+    const keys = this.filterKeys(approvalsMapping);
+    if (keys.length === 0) return approvalsMapping;
+
+    const onChainApprovals = await this.getOnChainApprovals(
+      keys.map(key => this.splitCacheKey(key)),
+    );
+
+    if (onChainApprovals.includes(true)) {
+      const setApprovalsInCache: Record<string, boolean> = {};
+      onChainApprovals.forEach((approved, index) => {
+        if (approved) {
+          approvalsMapping[keys[index]] = true;
+          setApprovalsInCache[keys[index]] = true;
+        }
+      });
+
+      await this.setCachedApprovals(setApprovalsInCache);
+    }
+
+    return approvalsMapping;
+  }
+
+  private createCacheKey(
+    spender: Address,
+    token: Address,
+    target: Address,
+  ): string {
+    return `${spender}_${token}_${target}`;
+  }
+
+  private splitCacheKey(
+    key: string,
+  ): [spender: Address, token: Address, target: Address] {
+    return key.split('_') as [Address, Address, Address];
+  }
+
+  private filterKeys(tokenTargetMapping: ApprovalsMapping, approved = false) {
+    return Object.entries(tokenTargetMapping)
+      .filter(([key, app]) => app === approved)
+      .map(([key]) => key);
+  }
+}

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

@@ -0,0 +1,93 @@
+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 = 'bprotocol';
+
+// ! LIQUIDITY ISSUES
+
+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: 'LUSD',
+        amount: '100000000000000000000',
+      },
+      {
+        symbol: 'ETH',
+        amount: '35360886801038522',
+      },
+    ],
+  ];
+
+  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('bProtocol E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+});

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

@@ -1,18 +1,17 @@
 import { Interface, JsonFragment } from '@ethersproject/abi';
-import { SwapSide } from '../constants';
-import { AdapterExchangeParam, Address, SimpleExchangeParam } from '../types';
-import { IDexTxBuilder } from './idex';
-import { SimpleExchange } from './simple-exchange';
-import BProtocolABI from '../abi/BProtocol.json';
-import { IDexHelper } from '../dex-helper';
-
-export type BProtocolData = {
-  exchange: string;
-};
-type BProtocolParam = [lusdAmount: string, minEthReturn: string, dest: string];
-enum BProtocolFunctions {
-  swap = 'swap',
-}
+import { SwapSide } from '../../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import BProtocolABI from '../../abi/BProtocol.json';
+import { IDexHelper } from '../../dex-helper';
+import { BProtocolData, BProtocolFunctions, BProtocolParam } from './types';
 
 export class BProtocol
   extends SimpleExchange
@@ -71,4 +70,31 @@ export class BProtocol
       data.exchange,
     );
   }
+
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: BProtocolData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = BProtocolFunctions.swap;
+    const swapFunctionParams: BProtocolParam = [
+      srcAmount,
+      destAmount,
+      recipient,
+    ];
+    const swapData = this.exchangeRouterInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.exchange,
+    };
+  }
 }

package/src/dex/bProtocol/types.ts

@@ -0,0 +1,13 @@
+export type BProtocolData = {
+  exchange: string;
+};
+
+export type BProtocolParam = [
+  lusdAmount: string,
+  minEthReturn: string,
+  dest: string,
+];
+
+export enum BProtocolFunctions {
+  swap = 'swap',
+}

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

@@ -32,12 +32,14 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    // [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe(`${network}`, () => {
@@ -94,7 +96,7 @@ function testForNetwork(
 describe('BalancerV1 E2E', () => {
   const dexKey = 'BalancerV1';
 
-  describe('Mainnet', () => {
+  describe('Mainnet_V6', () => {
     const network = Network.MAINNET;
 
     const tokenASymbol: string = 'USDC';