@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.4

package/src/dex/dexalot/dexalot-integration.test.ts

@@ -185,4 +185,125 @@ describe('Dexalot', function () {
       }
     });
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const tokenASymbol = 'USDT';
+    const tokenBSymbol = 'USDC';
+
+    const amountsForTokenA = [
+      0n,
+      1n * BI_POWS[tokens[tokenASymbol].decimals],
+      2n * BI_POWS[tokens[tokenASymbol].decimals],
+      3n * BI_POWS[tokens[tokenASymbol].decimals],
+      4n * BI_POWS[tokens[tokenASymbol].decimals],
+      5n * BI_POWS[tokens[tokenASymbol].decimals],
+      6n * BI_POWS[tokens[tokenASymbol].decimals],
+      7n * BI_POWS[tokens[tokenASymbol].decimals],
+      8n * BI_POWS[tokens[tokenASymbol].decimals],
+      9n * BI_POWS[tokens[tokenASymbol].decimals],
+      10n * BI_POWS[tokens[tokenASymbol].decimals],
+    ];
+
+    const amountsForTokenB = [
+      0n,
+      1n * BI_POWS[tokens[tokenBSymbol].decimals],
+      2n * BI_POWS[tokens[tokenBSymbol].decimals],
+      3n * BI_POWS[tokens[tokenBSymbol].decimals],
+      4n * BI_POWS[tokens[tokenBSymbol].decimals],
+      5n * BI_POWS[tokens[tokenBSymbol].decimals],
+      6n * BI_POWS[tokens[tokenBSymbol].decimals],
+      7n * BI_POWS[tokens[tokenBSymbol].decimals],
+      8n * BI_POWS[tokens[tokenBSymbol].decimals],
+      9n * BI_POWS[tokens[tokenBSymbol].decimals],
+      10n * BI_POWS[tokens[tokenBSymbol].decimals],
+    ];
+
+    beforeEach(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      dexalot = new Dexalot(network, dexKey, dexHelper);
+      await dexalot.initializePricing(blockNumber);
+      await sleep(5000);
+    });
+
+    afterEach(async () => {
+      dexalot.releaseResources();
+      await sleep(5000);
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.SELL,
+        amountsForTokenA,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenASymbol} ${tokenBSymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenASymbol,
+        tokenBSymbol,
+        SwapSide.BUY,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.SELL,
+        amountsForTokenB,
+      );
+    });
+
+    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenBSymbol} ${tokenASymbol}`, async function () {
+      await testPricingOnNetwork(
+        dexalot,
+        network,
+        dexKey,
+        blockNumber,
+        tokenBSymbol,
+        tokenASymbol,
+        SwapSide.BUY,
+        amountsForTokenA,
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const dexalot = new Dexalot(network, dexKey, dexHelper);
+      const poolLiquidity = await dexalot.getTopPoolsForToken(
+        tokens[tokenASymbol].address,
+        10,
+      );
+      console.log(`${tokenASymbol} Top Pools:`, poolLiquidity);
+
+      if (!dexalot.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][tokenASymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
 });

package/src/dex/dexalot/dexalot.ts

@@ -599,6 +599,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
         takerAmount: isSell ? optimalSwapExchange.srcAmount : undefined,
         userAddress: options.txOrigin,
         chainid: this.network,
+        executor: this.augustusAddress,
         partner: options.partner,
         slippage: slippageBps,
       };
@@ -1020,6 +1021,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
       needWrapNative: this.needWrapNative,
       dexFuncHasRecipient: false,
       targetExchange: this.mainnetRFQAddress,
+      returnAmountPos: undefined,
     };
   }
 

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

@@ -13,6 +13,7 @@ import { NumberAsString } from '@paraswap/core';
 import { IDexHelper } from '../../dex-helper';
 import { DodoV1Data, DodoV1Functions, DodoV1Param } from './types';
 import { DODOAproveAddress, DODOV2ProxyAddress } from './config';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class DodoV1
   extends SimpleExchange
@@ -118,6 +119,14 @@ export class DodoV1
       exchangeData: swapData,
       targetExchange: DODOV2ProxyAddress[this.network],
       spender: DODOAproveAddress[this.network],
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.dodoV2Proxy,
+              swapFunction,
+              'returnAmount',
+            )
+          : undefined,
     };
   }
 }

package/src/dex/dodo-v2.ts

@@ -13,6 +13,7 @@ import { NumberAsString } from '@paraswap/core';
 import { isETHAddress } from '../utils';
 import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
+import { extractReturnAmountPosition } from '../executor/utils';
 
 const DODOAproveAddress: { [network: number]: Address } = {
   [Network.MAINNET]: '0xCB859eA579b28e02B87A1FDE08d087ab9dbE5149',
@@ -252,6 +253,14 @@ export class DodoV2
       exchangeData: swapData,
       targetExchange: data.dodoProxy,
       spender: maybeSpender,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.exchangeRouterInterface,
+              swapFunction,
+              'returnAmount',
+            )
+          : undefined,
     };
   }
 }

package/src/dex/etherfi.ts

@@ -0,0 +1,239 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { ETHER_ADDRESS, NULL_ADDRESS, SwapSide } from '../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../types';
+import { IDexTxBuilder } from './idex';
+import { SimpleExchange } from './simple-exchange';
+import eETHPoolABI from '../abi/etherfi/eETHPool.json';
+import weETHABI from '../abi/etherfi/weETH.json';
+import { IDexHelper } from '../dex-helper';
+import { isETHAddress } from '../utils';
+import { assert } from 'ts-essentials';
+import { WethFunctions } from './weth/types';
+import { extractReturnAmountPosition } from '../executor/utils';
+
+type EtherFiData = void;
+
+type eETHPoolDepositParam = [];
+type weETHWrap = [_eETHAmount: string];
+type weETHUnwrap = [_weETHAmount: string];
+
+type EtherFiParam = eETHPoolDepositParam | weETHWrap | weETHUnwrap;
+
+enum EtherFiFunctions {
+  deposit = 'deposit',
+  wrap = 'wrap',
+  unwrap = 'unwrap',
+}
+
+const EtherFiConfig: Record<
+  number,
+  { eETH: string; eETHPool: string; weETH: string }
+> = {
+  1: {
+    eETH: '0x35fa164735182de50811e8e2e824cfb9b6118ac2',
+    eETHPool: '0x308861a430be4cce5502d0a12724771fc6daf216',
+    weETH: '0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee',
+  },
+};
+
+export class EtherFi
+  extends SimpleExchange
+  implements IDexTxBuilder<EtherFiData, EtherFiParam>
+{
+  static dexKeys = ['etherfi'];
+
+  eETHPoolInterface: Interface;
+  weETHInterface: Interface;
+  needWrapNative = false;
+
+  eETH: string;
+  eETHPool: string;
+  weETH: string;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'etherfi');
+
+    this.eETHPoolInterface = new Interface(eETHPoolABI as JsonFragment[]);
+    this.weETHInterface = new Interface(weETHABI as JsonFragment[]);
+
+    this.eETH = EtherFiConfig[this.network].eETH.toLowerCase();
+    this.eETHPool = EtherFiConfig[this.network].eETHPool.toLowerCase();
+    this.weETH = EtherFiConfig[this.network].weETH.toLowerCase();
+  }
+
+  is_eETH = (token: string) => token.toLowerCase() === this.eETH;
+  is_weETH = (token: string) => token.toLowerCase() === this.weETH;
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: EtherFiData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const [Interface, swapCallee, swapFunction, swapFunctionParams] = ((): [
+      Interface,
+      Address,
+      EtherFiFunctions,
+      EtherFiParam,
+    ] => {
+      if (this.is_weETH(destToken)) {
+        assert(this.is_eETH(srcToken), 'srcToken should be eETH');
+        return [
+          this.weETHInterface,
+          this.weETH,
+          EtherFiFunctions.wrap,
+          [srcAmount],
+        ];
+      }
+
+      if (this.is_weETH(srcToken)) {
+        assert(this.is_eETH(destToken), 'destToken should be eETH');
+        return [
+          this.weETHInterface,
+          this.weETH,
+          EtherFiFunctions.unwrap,
+          [srcAmount],
+        ];
+      }
+
+      if (this.is_eETH(destToken)) {
+        assert(
+          this.isWETH(srcToken) || isETHAddress(srcToken),
+          'srcToken should be (w)eth',
+        );
+        return [
+          this.eETHPoolInterface,
+          this.eETHPool,
+          EtherFiFunctions.deposit,
+          [],
+        ];
+      }
+
+      throw new Error('LOGIC ERROR');
+    })();
+
+    const swapData = Interface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    // if src token is WETH, we need to withdraw from weth and pass eth value on call. For other cases, we need to approve and perform call
+    const isSrcTokenWeth = this.isWETH(srcToken);
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      isSrcTokenWeth ? ETHER_ADDRESS : srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      swapCallee,
+      swapCallee,
+      '0',
+      isSrcTokenWeth
+        ? {
+            callees: [this.dexHelper.config.data.wrappedNativeTokenAddress],
+            calldata: [
+              this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
+                srcAmount,
+              ]),
+            ],
+            values: ['0'],
+          }
+        : undefined,
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+  ): DexExchangeParam {
+    const is_eETH_dest = this.is_eETH(destToken);
+    const isWETH_src = this.isWETH(srcToken);
+
+    const [Interface, swapCallee, swapFunction, swapFunctionParams] = ((): [
+      Interface,
+      Address,
+      EtherFiFunctions,
+      EtherFiParam,
+    ] => {
+      if (this.is_weETH(destToken)) {
+        assert(this.is_eETH(srcToken), 'srcToken should be eETH');
+        return [
+          this.weETHInterface,
+          this.weETH,
+          EtherFiFunctions.wrap,
+          [srcAmount],
+        ];
+      }
+
+      if (this.is_weETH(srcToken)) {
+        assert(is_eETH_dest, 'destToken should be eETH');
+        return [
+          this.weETHInterface,
+          this.weETH,
+          EtherFiFunctions.unwrap,
+          [srcAmount],
+        ];
+      }
+
+      if (is_eETH_dest) {
+        assert(
+          isWETH_src || isETHAddress(srcToken),
+          'srcToken should be (w)eth',
+        );
+        return [
+          this.eETHPoolInterface,
+          this.eETHPool,
+          EtherFiFunctions.deposit,
+          [],
+        ];
+      }
+
+      throw new Error('LOGIC ERROR');
+    })();
+
+    const swapData = Interface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: swapCallee,
+      spender: swapCallee,
+      swappedAmountNotPresentInExchangeData: is_eETH_dest,
+      preSwapUnwrapCalldata: isWETH_src
+        ? this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
+            srcAmount,
+          ])
+        : undefined,
+      returnAmountPos: extractReturnAmountPosition(Interface, swapFunction)
+    };
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: EtherFiData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: NULL_ADDRESS,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+}

package/src/dex/generic-rfq/generic-rfq.ts

@@ -205,7 +205,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
   }
 
   static getDirectFunctionNameV6(): string[] {
-    return [ContractMethodV6.swapExactAmountInOutOnAugustusRFQTryBatchFill];
+    return [ContractMethodV6.swapOnAugustusRFQTryBatchFill];
   }
 
   getDirectParamV6(
@@ -262,7 +262,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
 
     const encoder = (...params: (string | RFQDirectPayload)[]) => {
       return this.augustusV6Interface.encodeFunctionData(
-        ContractMethodV6.swapExactAmountInOutOnAugustusRFQTryBatchFill,
+        ContractMethodV6.swapOnAugustusRFQTryBatchFill,
         [...params],
       );
     };
@@ -302,6 +302,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
       specialDexFlag: SpecialDex.SWAP_ON_AUGUSTUS_RFQ,
       targetExchange: this.augustusRFQAddress,
       specialDexSupportsInsertFromAmount: true,
+      returnAmountPos: undefined,
     };
   }
 
@@ -324,6 +325,7 @@ export class GenericRFQ extends ParaSwapLimitOrders {
       options.executionContractAddress,
       options.txOrigin,
       options.partner,
+      options.special,
     );
 
     const expiryAsBigInt = BigInt(order.order.expiry);

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -378,6 +378,7 @@ export class RateFetcher {
     takerAddress: Address,
     userAddress: Address,
     partner?: string,
+    special?: boolean,
   ): Promise<OrderInfo> {
     const srcToken = this.dexHelper.config.wrapETH(_srcToken);
     const destToken = this.dexHelper.config.wrapETH(_destToken);
@@ -394,6 +395,7 @@ export class RateFetcher {
       userAddress,
       takerAddress,
       partner,
+      special: special || false,
     };
 
     try {

package/src/dex/generic-rfq/types.ts

@@ -89,6 +89,7 @@ export type RFQPayload = {
   userAddress: Address;
   takerAddress: Address;
   partner?: string;
+  special?: boolean;
 };
 
 export type AugustusOrderWithStringAndSignature = AugustusOrderWithString & {

package/src/dex/gmx/gmx.ts

@@ -22,6 +22,7 @@ import { SimpleExchange } from '../simple-exchange';
 import { GMXConfig, Adapters } from './config';
 import { Vault } from './vault';
 import ERC20ABI from '../../abi/erc20.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 const GMXGasCost = 300 * 1000;
 
@@ -231,6 +232,13 @@ export class GMX extends SimpleExchange implements IDex<GMXData> {
       swappedAmountNotPresentInExchangeData: true,
       exchangeData,
       targetExchange: this.params.vault,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              Vault.interface,
+              'swap',
+            )
+          : undefined,
     };
   }
 

package/src/dex/hashflow/constants.ts

@@ -20,3 +20,35 @@ export const HASHFLOW_GAS_COST = 100_000;
 
 export const HASHFLOW_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION =
   new BigNumber('0.001');
+
+export const RESTRICT_79_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_SLIPPAGE_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_84_TTL_MS = 60 * 10 * 1000; // 10 mins
+export const RESTRICT_76_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_82_TTL_MS = 60 * 30 * 1000; // 30 mins
+export const RESTRICT_42_TTL_MS = 60 * 60 * 1000; // 60 mins
+export const RESTRICT_85_TTL_MS = 60 * 20 * 1000; // 20 mins
+export const RESTRICT_74_TTL_MS = 60 * 20 * 1000; // 20 mins
+export const RESTRICT_UNKNOWN_TTL_MS = 60 * 60 * 1000; // 60 mins
+export const RESTRICT_MISSING_QUOTE_DATA_TTL_MS = 60 * 10 * 1000; // 10 mins
+export const RESTRICT_MISSING_SIGNATURE_TTL_MS = 60 * 10 * 1000; // 10 mins
+
+export const UNKNOWN_ERROR_CODE = 'UNKNOWN';
+
+export const ERROR_CODE_TO_RESTRICT_TTL = {
+  '79': RESTRICT_79_TTL_MS, // {"code":79,"message":"Below minimum amount"}
+  SLIPPAGE: RESTRICT_SLIPPAGE_TTL_MS, // Error: Hashflow-56: too much slippage on quote SELL quoteTokenAmount 800317519410129900 / destAmount 848781022570196154 < 0.995
+  '84': RESTRICT_84_TTL_MS, // {"code":84,"message":"Rate Limit"}
+  '76': RESTRICT_76_TTL_MS, // {"code":76,"message":"Exceeds supported amounts"}
+  '82': RESTRICT_82_TTL_MS, // {"code":82,"message":"No maker supports this request"}
+  '42': RESTRICT_42_TTL_MS, // {"code":42,"message":"Unknown error"}
+  '85': RESTRICT_85_TTL_MS, // {"code":85,"message":"Markets too volatile"}
+  '74': RESTRICT_74_TTL_MS, // {"code":74,"message":"No maker could quote"}
+  MISSING_QUOTE_DATA: RESTRICT_MISSING_QUOTE_DATA_TTL_MS, //  missing quote data
+  MISSING_SIGNATURE_DATA: RESTRICT_MISSING_SIGNATURE_TTL_MS, // missing signature
+  [UNKNOWN_ERROR_CODE]: RESTRICT_UNKNOWN_TTL_MS, // unknown error
+};
+
+// not actually consecutive, meaning is if the error appeared > CONSECUTIVE_ERROR_THRESHOLD times within CONSECUTIVE_ERROR_TIMESPAN_MS ms -> restrict mm for ERROR_CODE_TO_RESTRICT_TTL[errorCode] ms
+export const CONSECUTIVE_ERROR_TIMESPAN_MS = 60 * 60 * 1000; // 1 hour
+export const CONSECUTIVE_ERROR_THRESHOLD = 3;