@paraswap/dex-lib 3.8.12 → 3.8.13-arusd-fxusd.2

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

@@ -0,0 +1,303 @@
+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';
+
+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 data: { returnData: any[] } =
+      await this.dexHelper.multiContract.methods
+        .aggregate([
+          {
+            target: this.config.rUSDWeETHMarketAddress,
+            callData: this.rUSDMarketIface.encodeFunctionData(
+              'fTokenRedeemFeeRatio',
+              [],
+            ),
+          },
+          {
+            target: this.config.weETHOracleAddress,
+            callData: this.weETHOracleIface.encodeFunctionData(
+              'latestAnswer',
+              [],
+            ),
+          },
+        ])
+        .call({}, blockNumber);
+
+    const redeemFee = BigInt(
+      this.rUSDMarketIface.decodeFunctionResult(
+        'fTokenRedeemFeeRatio',
+        data.returnData[0],
+      )[0],
+    );
+    const weETHPrice = BigInt(
+      this.weETHOracleIface.decodeFunctionResult(
+        'latestAnswer',
+        data.returnData[1],
+      )[0],
+    );
+    await Promise.all([
+      this.fxProtocolRusdPool.initialize(blockNumber, {
+        state: {
+          nav: 1000000000000000000n,
+          redeemFee,
+          weETHPrice,
+        },
+      }),
+    ]);
+  }
+
+  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>> {
+    if (side == SwapSide.BUY) {
+      // note: BUY is not supported
+      return null;
+    }
+
+    const isRUSDSwapToken = this.is_rUSD_swap_token(
+      srcToken.address,
+      destToken.address,
+    );
+    if (!isRUSDSwapToken) {
+      return null;
+    }
+    const pool = this.fxProtocolRusdPool;
+    if (!pool.getState(blockNumber)) return null;
+
+    const is_redeem = this.is_weETH(destToken.address);
+    const unitIn = BI_POWS[18];
+    const unitOut = pool.getPrice(blockNumber, unitIn, is_redeem);
+    const amountsOut = 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,
+        this.dexHelper.config.data.executorsAddresses?.Executor01,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: false,
+        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,
+        this.dexHelper.config.data.executorsAddresses?.Executor01,
+        '0',
+      ]);
+      return {
+        needWrapNative: false,
+        dexFuncHasRecipient: false,
+        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[]> {
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.rUSDAddress,
+        connectorTokens: [
+          {
+            decimals: 18,
+            address: this.config.rUSDAddress,
+          },
+        ],
+        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: bigint;
+  redeemFee: bigint;
+  weETHPrice: bigint;
+};
+
+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,46 @@
+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],
+  );
+  const weETHPrice = BigInt(
+    ethWeETHOracleIface.decodeFunctionResult(
+      'latestAnswer',
+      data.returnData[1],
+    )[0],
+  );
+  return {
+    nav: 1000000000000000000n,
+    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/solidly-v3/config.ts

@@ -61,6 +61,36 @@ export const SolidlyV3Config: DexConfigMap<DexParams> = {
         '0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf',
       subgraphURL: 'HDNu25S2uqr13BHrQdPv2PfTpwxJgPB7QEnC8fsgKcM9',
     },
+    [Network.BASE]: {
+      factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
+      supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
+      stateMulticall: '0x000c5dd531b3e2327c0E3a382bC8B21a284E6F61',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf',
+      subgraphURL: 'C8G1vfqsgWTg4ydzxWdsLj1jCKsxAKFamP5GjuSdRF8W',
+    },
+    [Network.ARBITRUM]: {
+      factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
+      supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
+      stateMulticall: '0x000c5dd531b3e2327c0E3a382bC8B21a284E6F61',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf',
+      subgraphURL: 'ALCsbp7jWC6EQjwgicvZkG6dDEFGMV32QUZJvJGqL9Kx',
+    },
+    [Network.OPTIMISM]: {
+      factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
+      supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
+      stateMulticall: '0x000c5dd531b3e2327c0E3a382bC8B21a284E6F61',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf',
+      subgraphURL: 'HCThb3gJC45qUYmNEaYmZZTqJW3pSq7X6tb4MqNHEvZf',
+    },
   },
 };
 
@@ -73,4 +103,16 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'FantomAdapter02', index: 1 }],
     [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 5 }],
   },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter02', index: 5 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 11 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter03', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 14 }],
+  },
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter02', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'OptimismBuyAdapter', index: 10 }],
+  },
 };

package/src/dex/solidly-v3/solidly-v3-e2e.test.ts

@@ -79,7 +79,7 @@ function testForNetwork(
 describe('SolidlyV3 E2E', () => {
   const dexKey = 'SolidlyV3';
 
-  describe('Mainnet_V6', () => {
+  describe('Mainnet', () => {
     const network = Network.MAINNET;
 
     const pairs = [
@@ -110,12 +110,12 @@ describe('SolidlyV3 E2E', () => {
       [
         {
           name: 'USDC',
-          sellAmount: '400000000',
+          sellAmount: '4000000',
           buyAmount: '4000000',
         },
         {
           name: 'USDT',
-          sellAmount: '500000000',
+          sellAmount: '5000000',
           buyAmount: '5000000',
         },
       ],
@@ -156,4 +156,115 @@ describe('SolidlyV3 E2E', () => {
 
     testForNetwork(network, dexKey, pairs);
   });
+
+  describe('Base', () => {
+    const network = Network.BASE;
+
+    const pairs = [
+      [
+        {
+          name: NativeTokenSymbols[network],
+          sellAmount: '100000000000000', //0.0001 ETH
+          buyAmount: '100000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '1000000', // $1
+          buyAmount: '1000000', // $1
+        },
+      ],
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000',
+          buyAmount: '100000',
+        },
+        {
+          name: 'WETH',
+          sellAmount: '100000000000000', //0.0001 ETH
+          buyAmount: '100000000',
+        },
+      ],
+      [
+        {
+          name: 'USDC',
+          sellAmount: '100000',
+          buyAmount: '100000',
+        },
+        {
+          name: 'USDbC',
+          sellAmount: '100000',
+          buyAmount: '100000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Optimism', () => {
+    const network = Network.OPTIMISM;
+
+    const pairs = [
+      [
+        {
+          name: NativeTokenSymbols[network],
+          sellAmount: '10000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'wstETH',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+      [
+        {
+          name: 'USDC',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000',
+          buyAmount: '1000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const pairs = [
+      [
+        {
+          name: NativeTokenSymbols[network],
+          sellAmount: '10000000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'USDC',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+      [
+        {
+          name: 'USDC',
+          sellAmount: '1000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '100000',
+          buyAmount: '1000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
 });

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/implementations/local-paraswap-sdk.ts

@@ -24,6 +24,7 @@ import {
 import { GenericSwapTransactionBuilder } from '../generic-swap-transaction-builder';
 import { AddressOrSymbol } from '@paraswap/sdk';
 import { ParaSwapVersion } from '@paraswap/core';
+import { TransactionBuilder } from '../transaction-builder';
 
 export interface IParaSwapSDK {
   getPrices(
@@ -60,6 +61,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
   pricingHelper: PricingHelper;
   dexKeys: string[];
   transactionBuilder: GenericSwapTransactionBuilder;
+  transactionBuilderV5: TransactionBuilder;
 
   constructor(
     protected network: number,
@@ -79,6 +81,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
     this.transactionBuilder = new GenericSwapTransactionBuilder(
       this.dexAdapterService,
     );
+    this.transactionBuilderV5 = new TransactionBuilder(this.dexAdapterService);
 
     this.dexKeys = Array.isArray(dexKeys) ? dexKeys : [dexKeys];
     this.dexKeys.map(dexKey => {
@@ -196,8 +199,11 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       gasCost: '0',
       others: [],
       side,
+      // For V5 tests, put Augustus V5 address here
+      // contractAddress: '0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57',
       contractAddress: '',
       tokenTransferProxy: '',
+      // For V5 tests, put V5 version here
       version: ParaSwapVersion.V6,
     };
 
@@ -305,6 +311,8 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       throw e;
     }
 
+    // For V5 use transactionBuilderV5
+    // return await this.transactionBuilderV5.build({
     return await this.transactionBuilder.build({
       priceRoute,
       minMaxAmount: minMaxAmount.toString(),

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',
@@ -1640,7 +1650,7 @@ export const Holders: {
     FVM: '0x07BB65fAaC502d4996532F834A1B7ba5dC32Ff96',
     lzUSDC: '0x06F1C4A56357bF3971C79063f2B58E58c547BC0B',
     axlUSDC: '0xccf932cd565c21d2e516c8ff3a4f244eea27e09a',
-    SOLID: '0xdF6A50d16320D9eAf0D91e0039fcE89c700F95F1',
+    SOLID: '0xddf169bf228e6d6e701180e2e6f290739663a784',
     scrvUSDC_e: '0xb8c1dAb69724da9d3225F14bfD76Ae97bB92BFda',
     scrvUSDC_p: '0x74796478d7755a77807fADd2389A18DF1baf9e7c',
   },

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
-      }
-    }
-  ]
-}