@paraswap/dex-lib 3.8.13 → 3.8.15

package/src/dex/fx-protocol-rusd/fx-protocol-rusd.ts

@@ -0,0 +1,282 @@
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  Logger,
+  NumberAsString,
+  DexExchangeParam,
+  PoolLiquidity,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { DexParams, FxProtocolData } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { FxProtocolConfig } from './config';
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import FxUSD_ABI from '../../abi/fx-protocol/FxUSD.json';
+import FxMarket_ABI from '../../abi/fx-protocol/FxMarket.json';
+import EthWeETHOralce_ABI from '../../abi/fx-protocol/weETHOralce.json';
+
+import { extractReturnAmountPosition } from '../../executor/utils';
+import { FxProtocolRusdEvent } from './fx-protocol-rusd-event';
+import { BI_POWS } from '../../bigint-constants';
+import { getOnChainState } from './utils';
+
+export class FxProtocolRusd
+  extends SimpleExchange
+  implements IDex<FxProtocolData>
+{
+  protected config: DexParams;
+
+  readonly hasConstantPriceLargeAmounts = true;
+
+  readonly needWrapNative = false;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(FxProtocolConfig);
+
+  fxUSDIface: Interface;
+  rUSDMarketIface: Interface;
+  weETHOracleIface: Interface;
+  fxProtocolRusdPool: FxProtocolRusdEvent;
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+  ) {
+    super(dexHelper, dexKey);
+    const config = FxProtocolConfig[dexKey][network];
+    this.fxUSDIface = new Interface(FxUSD_ABI as JsonFragment[]);
+    this.rUSDMarketIface = new Interface(FxMarket_ABI as JsonFragment[]);
+    this.weETHOracleIface = new Interface(EthWeETHOralce_ABI as JsonFragment[]);
+    this.config = {
+      rUSDAddress: config.rUSDAddress.toLowerCase(),
+      weETHAddress: config.weETHAddress.toLowerCase(),
+      rUSDWeETHMarketAddress: config.rUSDWeETHMarketAddress.toLowerCase(),
+      weETHOracleAddress: config.weETHOracleAddress.toLowerCase(),
+    };
+    this.logger = dexHelper.getLogger(dexKey);
+    this.fxProtocolRusdPool = new FxProtocolRusdEvent(
+      this.dexKey,
+      dexHelper,
+      this.config.rUSDWeETHMarketAddress,
+      this.rUSDMarketIface,
+      this.config.weETHOracleAddress,
+      this.weETHOracleIface,
+      this.logger,
+    );
+  }
+
+  async initializePricing(blockNumber: number) {
+    const poolState = await getOnChainState(
+      this.dexHelper.multiContract,
+      this.config.rUSDWeETHMarketAddress,
+      this.rUSDMarketIface,
+      this.config.weETHOracleAddress,
+      this.weETHOracleIface,
+      blockNumber,
+    );
+
+    await this.fxProtocolRusdPool.initialize(blockNumber, {
+      state: poolState,
+    });
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  is_weETH(token: string) {
+    return token.toLowerCase() === this.config.weETHAddress.toLowerCase();
+  }
+
+  is_rUSD(token: string) {
+    return token.toLowerCase() === this.config.rUSDAddress.toLowerCase();
+  }
+
+  is_rUSD_swap_token(srcToken: string, destToken: string) {
+    return (
+      (this.is_weETH(srcToken) && this.is_rUSD(destToken)) ||
+      (this.is_rUSD(srcToken) && this.is_weETH(destToken))
+    );
+  }
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters() {
+    return null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (!this.is_rUSD_swap_token(srcToken.address, destToken.address)) {
+      return [];
+    }
+    return [`${this.dexKey}_${this.config.rUSDAddress}`];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<FxProtocolData>> {
+    // note: BUY is not supported
+    if (side === SwapSide.BUY) return null;
+
+    const isRUSDSwapToken = this.is_rUSD_swap_token(
+      srcToken.address,
+      destToken.address,
+    );
+    if (!isRUSDSwapToken) {
+      return null;
+    }
+    const pool = this.fxProtocolRusdPool;
+    const is_redeem = this.is_weETH(destToken.address);
+    const unitIn = BI_POWS[18];
+    const unitOut = await pool.getPrice(blockNumber, unitIn, is_redeem);
+    const amountsOut = await Promise.all(
+      amounts.map(_amountIn =>
+        pool.getPrice(blockNumber, _amountIn, is_redeem),
+      ),
+    );
+
+    return [
+      {
+        unit: unitOut,
+        prices: amountsOut,
+        data: {},
+        poolAddresses: [this.config.rUSDAddress],
+        exchange: this.dexKey,
+        gasCost: 1000000,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<FxProtocolData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  // Encode params required by the exchange adapter
+  // V5: Used for multiSwap, buy & megaSwap
+  // V6: Not used, can be left blank
+  // Hint: abiCoder.encodeParameter() could be useful
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: FxProtocolData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const payload = '0x';
+
+    return {
+      targetExchange: this.config.rUSDAddress,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: FxProtocolData,
+    side: SwapSide,
+  ): Promise<DexExchangeParam> {
+    const is_rUSD_src = this.is_rUSD(srcToken);
+    const is_weETH_src = this.is_weETH(srcToken);
+    const is_rUSD_dest = this.is_rUSD(destToken);
+    const is_weETH_dest = this.is_weETH(destToken);
+
+    if (is_weETH_src && is_rUSD_dest) {
+      const exchangeData = this.fxUSDIface.encodeFunctionData('mint', [
+        this.config.weETHAddress,
+        srcAmount,
+        recipient,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        exchangeData,
+        targetExchange: this.config.rUSDAddress,
+        returnAmountPos: extractReturnAmountPosition(
+          this.fxUSDIface,
+          'mint',
+          '_amountOut',
+        ),
+      };
+    }
+    if (is_rUSD_src && is_weETH_dest) {
+      const exchangeData = this.fxUSDIface.encodeFunctionData('redeem', [
+        this.config.weETHAddress,
+        srcAmount,
+        recipient,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: true,
+        exchangeData,
+        targetExchange: this.config.rUSDAddress,
+        returnAmountPos: extractReturnAmountPosition(
+          this.fxUSDIface,
+          'redeem',
+          '_amountOut',
+        ),
+      };
+    }
+    throw new Error('LOGIC ERROR');
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.is_rUSD(tokenAddress) && !this.is_weETH(tokenAddress)) return [];
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.rUSDAddress,
+        connectorTokens: this.is_weETH(tokenAddress)
+          ? [
+              {
+                decimals: 18,
+                address: this.config.rUSDAddress,
+              },
+            ]
+          : [
+              {
+                decimals: 18,
+                address: this.config.weETHAddress,
+              },
+            ],
+        liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+      },
+    ];
+  }
+}

package/src/dex/fx-protocol-rusd/types.ts

@@ -0,0 +1,16 @@
+import { Address } from '../../types';
+
+export type FxProtocolPoolState = {
+  nav: string;
+  redeemFee: string;
+  weETHPrice: string;
+};
+
+export type FxProtocolData = {};
+
+export type DexParams = {
+  rUSDAddress: Address;
+  weETHAddress: Address;
+  rUSDWeETHMarketAddress: Address;
+  weETHOracleAddress: Address;
+};

package/src/dex/fx-protocol-rusd/utils.ts

@@ -0,0 +1,47 @@
+import { Contract } from 'web3-eth-contract';
+import { FxProtocolPoolState } from './types';
+import { Interface } from '@ethersproject/abi';
+
+export async function getOnChainState(
+  multiContract: Contract,
+  marketAddress: string,
+  marketInterface: Interface,
+  ethWeETHOracleAddress: string,
+  ethWeETHOracleIface: Interface,
+  blockNumber: number | 'latest',
+): Promise<FxProtocolPoolState> {
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: marketAddress,
+        callData: marketInterface.encodeFunctionData(
+          'fTokenRedeemFeeRatio',
+          [],
+        ),
+      },
+      {
+        target: ethWeETHOracleAddress,
+        callData: ethWeETHOracleIface.encodeFunctionData('latestAnswer', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const redeemFee = BigInt(
+    marketInterface.decodeFunctionResult(
+      'fTokenRedeemFeeRatio',
+      data.returnData[0],
+    )[0],
+  ).toString();
+  const weETHPrice = BigInt(
+    ethWeETHOracleIface.decodeFunctionResult(
+      'latestAnswer',
+      data.returnData[1],
+    )[0],
+  ).toString();
+
+  return {
+    nav: '1000000000000000000',
+    redeemFee,
+    weETHPrice,
+  };
+}

package/src/dex/index.ts

@@ -81,6 +81,8 @@ import { EtherFi } from './etherfi';
 import { Spark } from './spark/spark';
 import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
+import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
+import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 
 const LegacyDexes = [
   CurveV2,
@@ -157,6 +159,8 @@ const Dexes = [
   PharaohV1,
   Spark,
   AaveV3Stata,
+  ConcentratorArusd,
+  FxProtocolRusd,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -58,7 +58,6 @@ async function checkOnChainPricing(
   const expectedPrices = [0n].concat(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
-
   expect(prices).toEqual(expectedPrices);
 }
 

package/src/executor/Executor01BytecodeBuilder.ts

@@ -10,7 +10,6 @@ import {
   ExecutorBytecodeBuilder,
   SingleSwapCallDataParams,
 } from './ExecutorBytecodeBuilder';
-import { assert } from 'ts-essentials';
 
 const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
@@ -344,6 +343,7 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
       routeIndex,
       swapIndex,
       flag,
+      swapExchangeIndex,
     } = params;
 
     const dontCheckBalanceAfterSwap = flag % 3 === 0;
@@ -378,19 +378,15 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (insertFromAmount) {
       const fromAmount = ethers.utils.defaultAbiCoder.encode(
         ['uint256'],
-        [swap.swapExchanges[0].srcAmount],
+        [swap.swapExchanges[swapExchangeIndex].srcAmount],
       );
 
       const fromAmountIndex = exchangeData
         .replace('0x', '')
         .indexOf(fromAmount.replace('0x', ''));
 
-      assert(
-        fromAmountIndex !== -1,
-        'Encoding error: could not resolve position of fromAmount in exchangeData',
-      );
-
-      fromAmountPos = fromAmountIndex / 2;
+      fromAmountPos =
+        (fromAmountIndex !== -1 ? fromAmountIndex : exchangeData.length) / 2;
     }
 
     return this.buildCallData(

package/src/executor/Executor02BytecodeBuilder.ts

@@ -24,7 +24,6 @@ import {
   ZEROS_4_BYTES,
   DEFAULT_RETURN_AMOUNT_POS,
 } from './constants';
-import { assert } from 'ts-essentials';
 
 const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
@@ -339,12 +338,8 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
         .replace('0x', '')
         .indexOf(fromAmount.replace('0x', ''));
 
-      assert(
-        fromAmountIndex !== -1,
-        'Encoding error: could not resolve position of fromAmount in exchangeData',
-      );
-
-      fromAmountPos = fromAmountIndex / 2;
+      fromAmountPos =
+        (fromAmountIndex !== -1 ? fromAmountIndex : exchangeData.length) / 2;
     }
 
     return this.buildCallData(

package/src/executor/Executor03BytecodeBuilder.ts

@@ -67,13 +67,28 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     const exchangeParam = exchangeParams[exchangeParamIndex];
     const swap = priceRoute.bestRoute[0].swaps[0];
 
-    const { dexFuncHasRecipient, needWrapNative } = exchangeParam;
+    const {
+      dexFuncHasRecipient,
+      needWrapNative,
+      swappedAmountNotPresentInExchangeData,
+      specialDexFlag,
+      specialDexSupportsInsertFromAmount,
+    } = exchangeParam;
+    const isSpecialDex =
+      specialDexFlag !== undefined && specialDexFlag !== SpecialDex.DEFAULT;
+
+    const forcePreventInsertFromAmount =
+      swappedAmountNotPresentInExchangeData ||
+      (isSpecialDex && !specialDexSupportsInsertFromAmount);
 
     const needWrap = needWrapNative && isEthSrc && maybeWethCallData?.deposit;
     const needUnwrap =
       needWrapNative && isEthDest && maybeWethCallData?.withdraw;
 
-    let dexFlag = Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
+    let dexFlag = forcePreventInsertFromAmount
+      ? Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP
+      : Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0 or 3
+
     let approveFlag =
       Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
 
@@ -81,15 +96,21 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       dexFlag =
         Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
     } else if (isEthDest && !needUnwrap) {
-      dexFlag = Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 4
+      dexFlag = forcePreventInsertFromAmount
+        ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 4
+        : Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 7
     } else if (isEthDest && needUnwrap) {
-      dexFlag = Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 8
+      dexFlag = forcePreventInsertFromAmount
+        ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 8
+        : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
       // dexFlag = Flag.ZERO;
     } else if (
       !isETHAddress(swap.destToken) &&
       exchangeParams.some(param => !param.dexFuncHasRecipient)
     ) {
-      dexFlag = Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 8
+      dexFlag = forcePreventInsertFromAmount
+        ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 8
+        : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
     }
 
     return {
@@ -251,6 +272,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       exchangeParamIndex,
       flag,
       maybeWethCallData,
+      swapExchangeIndex,
     } = params;
     const dontCheckBalanceAfterSwap = flag % 3 === 0;
     const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
@@ -300,11 +322,11 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (insertAmount) {
       const fromAmount = ethers.utils.defaultAbiCoder.encode(
         ['uint256'],
-        [swap.swapExchanges[0].srcAmount],
+        [swap.swapExchanges[swapExchangeIndex].srcAmount],
       );
       const toAmount = ethers.utils.defaultAbiCoder.encode(
         ['uint256'],
-        [swap.swapExchanges[0].destAmount],
+        [swap.swapExchanges[swapExchangeIndex].destAmount],
       );
 
       const fromAmountIndex = exchangeData
@@ -314,17 +336,10 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
         .replace('0x', '')
         .indexOf(toAmount.replace('0x', ''));
 
-      assert(
-        fromAmountIndex !== -1,
-        'Encoding error: could not resolve position of fromAmount in exchangeData',
-      );
-      assert(
-        toAmountIndex !== -1,
-        'Encoding error: could not resolve position of toAmount in exchangeData',
-      );
-
-      fromAmountPos = fromAmountIndex / 2;
-      toAmountPos = toAmountIndex / 2;
+      fromAmountPos =
+        (fromAmountIndex !== -1 ? fromAmountIndex : exchangeData.length) / 2;
+      toAmountPos =
+        (toAmountIndex !== -1 ? toAmountIndex : exchangeData.length) / 2;
     }
 
     return this.buildCallData(
@@ -377,7 +392,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
           acc,
           this.buildSingleSwapCallData({
             priceRoute,
-            exchangeParams,
+            exchangeParams: orderedExchangeParams.map(e => e.exchangeParam),
             index,
             flags,
             sender,

package/src/generic-swap-transaction-builder.ts

@@ -7,7 +7,7 @@ import {
   OptimalSwapExchange,
   TxObject,
 } from './types';
-import { BigNumber } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import {
   ETHER_ADDRESS,
   FEE_PERCENT_IN_BASIS_POINTS_MASK,
@@ -18,10 +18,8 @@ import {
   IS_TAKE_SURPLUS_MASK,
   IS_USER_SURPLUS_MASK,
   NULL_ADDRESS,
-  SwapSide,
 } from './constants';
 import { AbiCoder, Interface } from '@ethersproject/abi';
-import { ethers } from 'ethers';
 import AugustusV6ABI from './abi/augustus-v6/ABI.json';
 import { isETHAddress, uuidToBytes16 } from './utils';
 import {
@@ -34,7 +32,7 @@ import ERC20ABI from './abi/erc20.json';
 import { ExecutorDetector } from './executor/ExecutorDetector';
 import { ExecutorBytecodeBuilder } from './executor/ExecutorBytecodeBuilder';
 import { IDexTxBuilder } from './dex/idex';
-import { ParaSwapVersion } from '@paraswap/core';
+import { ParaSwapVersion, SwapSide } from '@paraswap/core';
 
 const {
   utils: { hexlify, hexConcat, hexZeroPad },
@@ -139,7 +137,7 @@ export class GenericSwapTransactionBuilder {
             const dexParams = await dex.getDexParam!(
               srcToken,
               destToken,
-              srcAmount,
+              side === SwapSide.BUY ? se.srcAmount : srcAmount, // in other case we would not be able to make insert from amount on Ex3
               destAmount,
               recipient,
               se.data,

package/tests/constants-e2e.ts

@@ -499,6 +499,14 @@ export const Tokens: {
       address: '0x23878914efe38d27c4d67ab83ed1b93a74d4086a',
       decimals: 6,
     },
+    rUSD: {
+      address: '0x65D72AA8DA931F047169112fcf34f52DbaAE7D18',
+      decimals: 18,
+    },
+    arUSD: {
+      address: '0x07D1718fF05a8C53C8F05aDAEd57C0d672945f9a',
+      decimals: 18,
+    },
   },
   [Network.POLYGON]: {
     jGBP: {
@@ -1569,6 +1577,8 @@ export const Holders: {
     stataUSDT: '0x6803364AceD5181877abC11E865FB27cB654a426',
     aaveUSDT: '0x32c98a981Fe7C333Bd4e8E7630E8e0CF5ce20987',
     weETH: '0x267ed5f71EE47D3E45Bb1569Aa37889a2d10f91e',
+    rUSD: '0xEC2eda1C4F981E468ABF62424a10B69B738b498E',
+    arUSD: '0xeFc24206053a452e2299BF3b8f964512b041Db4C',
   },
   [Network.POLYGON]: {
     jGBP: '0x02aa0B826c7BA6386DdBE04C0a8715A1c0A16B24',