@paraswap/dex-lib 3.8.14 → 3.8.16

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/idex.ts

@@ -24,34 +24,7 @@ export type Context = {
   isGlobalDestToken: boolean;
 };
 
-export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
-  needWrapNative: boolean;
-  needsSequentialPreprocessing?: boolean;
-
-  // Returns the ETH fee required to swap
-  // It is optional for a DEX to implement this
-  // This is a legacy function and will be removed soon
-  getNetworkFee?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    data: ExchangeData,
-    side: SwapSide,
-  ): NumberAsString;
-
-  // If exists, called before getAdapterParam to use async calls and receive data if needed
-  preProcessTransaction?(
-    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
-
-  // This is helper a function to support testing if preProcessTransaction is implemented
-  getTokenFromAddress?(address: Address): Token;
-
+export interface IDexTxBuilderV5<ExchangeData, DirectParam = null> {
   // Encode params required by the exchange adapter
   // V5: Used for multiSwap, buy & megaSwap
   // V6: NOT used, pass a placeholder
@@ -76,18 +49,6 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     side: SwapSide,
   ): AsyncOrSync<SimpleExchangeParam>;
 
-  getDexParam?(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: ExchangeData,
-    side: SwapSide,
-    context: Context,
-    executorAddress: Address,
-  ): AsyncOrSync<DexExchangeParam>;
-
   // Returns params required by direct swap method.
   // Only Dexes which have a direct method should implement this
   // Used if there is a possibility for direct swap (Eg. UniswapV2,
@@ -108,8 +69,23 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     beneficiary: string,
     contractMethod: string,
   ): TxInfo<DirectParam>;
+}
 
-  // Same as above but for V6
+export interface IDexTxBuilderV6<ExchangeData, DirectParam = null> {
+  // Returns params required by generic method
+  getDexParam?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: ExchangeData,
+    side: SwapSide,
+    context: Context,
+    executorAddress: Address,
+  ): AsyncOrSync<DexExchangeParam>;
+
+  // Returns params for direct method
   getDirectParamV6?(
     srcToken: Address,
     destToken: Address,
@@ -127,6 +103,37 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
   ): TxInfo<DirectParam>;
 }
 
+export interface IDexTxBuilder<ExchangeData, DirectParam = null>
+  extends IDexTxBuilderV5<ExchangeData, DirectParam>,
+    IDexTxBuilderV6<ExchangeData, DirectParam> {
+  needWrapNative: boolean;
+  needsSequentialPreprocessing?: boolean;
+
+  // Returns the ETH fee required to swap
+  // It is optional for a DEX to implement this
+  // This is a legacy function and will be removed soon
+  getNetworkFee?(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: ExchangeData,
+    side: SwapSide,
+  ): NumberAsString;
+
+  // If exists, called before getAdapterParam to use async calls and receive data if needed
+  preProcessTransaction?(
+    optimalSwapExchange: OptimalSwapExchange<ExchangeData>,
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): AsyncOrSync<[OptimalSwapExchange<ExchangeData>, ExchangeTxInfo]>;
+
+  // This is helper a function to support testing if preProcessTransaction is implemented
+  getTokenFromAddress?(address: Address): Token;
+}
+
 export interface IDexPricing<ExchangeData> {
   readonly dexKey: string;
   // This is true if the the DEX is simply

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/weth/config.ts

@@ -73,4 +73,7 @@ export const Adapters: {
   [Network.BASE]: {
     [SwapSide.SELL]: [{ name: 'BaseAdapter02', index: 2 }],
   },
+  [Network.ZKEVM]: {
+    [SwapSide.SELL]: [{ name: 'PolygonZkEvmAdapter01', index: 3 }],
+  },
 };

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

@@ -873,4 +873,160 @@ describe('Weth E2E', () => {
       });
     });
   });
+
+  describe('Weth ZKEvm', () => {
+    const dexKey = 'Weth';
+    const network = Network.ZKEVM;
+
+    const nativeTokenSymbol = 'ETH';
+    const wrappedTokenSymbol = 'WETH';
+
+    const nativeAmount = '1000000000000000000';
+    const wrappedAmount = '1000000000000000000';
+
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const nativeToken = tokens[nativeTokenSymbol];
+    const wrappedToken = tokens[wrappedTokenSymbol];
+
+    const nativeHolder = holders[nativeTokenSymbol];
+    const wrappedHolder = holders[wrappedTokenSymbol];
+
+    describe('SimpleSwap SELL', () => {
+      const contractMethod = ContractMethod.simpleSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+
+    describe('MultiSwap SELL', () => {
+      const contractMethod = ContractMethod.multiSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+
+    describe('MegaSwap SELL', () => {
+      const contractMethod = ContractMethod.megaSwap;
+      const side = SwapSide.SELL;
+
+      it('native -> wrapped', async () => {
+        await testE2E(
+          nativeToken,
+          wrappedToken,
+          nativeHolder,
+          nativeAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+      it('wrapped -> native', async () => {
+        await testE2E(
+          wrappedToken,
+          nativeToken,
+          wrappedHolder,
+          wrappedAmount,
+          side,
+          dexKey,
+          contractMethod,
+          network,
+          provider,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          true,
+        );
+      });
+    });
+  });
 });

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/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',