@paraswap/dex-lib 3.8.14 → 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/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',

package/.vscode/tasks.json

@@ -1,15 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "tsc: build - tsconfig.json",
-      "type": "typescript",
-      "tsconfig": "tsconfig.json",
-      "problemMatcher": ["$tsc"],
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    }
-  ]
-}

package/build/abi/uniswap-v3/AlienBaseV3Router.abi.json

@@ -1,52 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "components": [
-                    { "internalType": "bytes", "name": "path", "type": "bytes" },
-                    { "internalType": "address", "name": "recipient", "type": "address" },
-                    { "internalType": "uint256", "name": "amountIn", "type": "uint256" },
-                    {
-                        "internalType": "uint256",
-                        "name": "amountOutMinimum",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct ISwapRouter.ExactInputParams",
-                "name": "params",
-                "type": "tuple"
-            }
-        ],
-        "name": "exactInput",
-        "outputs": [
-            { "internalType": "uint256", "name": "amountOut", "type": "uint256" }
-        ],
-        "stateMutability": "payable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "components": [
-                    { "internalType": "bytes", "name": "path", "type": "bytes" },
-                    { "internalType": "address", "name": "recipient", "type": "address" },
-                    { "internalType": "uint256", "name": "amountOut", "type": "uint256" },
-                    {
-                        "internalType": "uint256",
-                        "name": "amountInMaximum",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct ISwapRouter.ExactOutputParams",
-                "name": "params",
-                "type": "tuple"
-            }
-        ],
-        "name": "exactOutput",
-        "outputs": [
-            { "internalType": "uint256", "name": "amountIn", "type": "uint256" }
-        ],
-        "stateMutability": "payable",
-        "type": "function"
-    }
-]

package/build/dex/aave-v2/tokens-avalanche.json

@@ -1,44 +0,0 @@
-[
-    {
-        "aSymbol": "avWETH",
-        "aAddress": "0x53f7c5869a859f0aec3d334ee8b4cf01e3492f21",
-        "address": "0x49d5c2bdffac6ce2bfdb6640f4f80f226bc10bab",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "avDAI",
-        "aAddress": "0x47afa96cdc9fab46904a55a6ad4bf6660b53c38a",
-        "address": "0xd586e7f844cea2f87f50152665bcbc2c279d8d70",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "avUSDT",
-        "aAddress": "0x532e6537fea298397212f09a61e03311686f548e",
-        "address": "0xc7198437980c041c805a1edcba50c1ce5db95118",
-        "decimals": 6
-    },
-    {
-        "aSymbol": "avUSDC",
-        "aAddress": "0x46a51127c3ce23fb7ab1de06226147f446e4a857",
-        "address": "0xa7d7079b0fead91f3e65f86e8915cb59c1a4c664",
-        "decimals": 6
-    },
-    {
-        "aSymbol": "avAAVE",
-        "aAddress": "0xd45b7c061016102f9fa220502908f2c0f1add1d7",
-        "address": "0x63a72806098bd3d9520cc43356dd78afe5d386d9",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "avWBTC",
-        "aAddress": "0x686bef2417b6dc32c50a3cbfbcc3bb60e1e9a15d",
-        "address": "0x50b7545627a5162f82a992c33b87adc75187b218",
-        "decimals": 8
-    },
-    {
-        "aSymbol": "avWAVAX",
-        "aAddress": "0xdfe521292ece2a4f44242efbcd66bc594ca9714b",
-        "address": "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7",
-        "decimals": 18
-    }
-]