@paraswap/dex-lib 3.8.35 → 3.8.36-susds

package/src/dex/lite-psm/config.ts

@@ -10,6 +10,11 @@ export const LitePsmConfig: DexConfigMap<DexParams> = {
         address: '0x6b175474e89094c44da98b954eedeac495271d0f',
         decimals: 18,
       },
+      usds: {
+        address: '0xdc035d45d973e3ec169d2276ddab16f1e407384f',
+        decimals: 18,
+      },
+      usdsPsmAddress: '0xA188EEC8F81263234dA3622A406892F3D630f98c',
       vatAddress: '0x35d1b3f3d7966a1dfe207aa4514c12a259a0492b',
       pools: [
         {
@@ -17,7 +22,6 @@ export const LitePsmConfig: DexConfigMap<DexParams> = {
             address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
             decimals: 6,
           },
-          gemJoinAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042', // Same as psmAddress. LitePsm does not have an external gem join.
           pocketAddress: '0x37305b1cd40574e4c5ce33f8e8306be057fd7341',
           psmAddress: '0xf6e72db5454dd049d0788e411b06cfaf16853042',
           identifier:

package/src/dex/lite-psm/lite-psm-e2e.test.ts

@@ -10,7 +10,7 @@ import { generateConfig } from '../../config';
 describe('LitePsm E2E', () => {
   const dexKey = 'LitePsm';
 
-  describe('LitePsm MAINNET_V6', () => {
+  describe('LitePsm DAI', () => {
     const network = Network.MAINNET;
     const tokens = Tokens[network];
     const holders = Holders[network];
@@ -76,4 +76,71 @@ describe('LitePsm E2E', () => {
       }),
     );
   });
+
+  describe('LitePsm USDS', () => {
+    const network = Network.MAINNET;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'USDS';
+
+    const tokenAAmount: string = '10000000';
+    const tokenBAmount: string = '10000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.swapExactAmountIn,
+          ContractMethod.swapExactAmountInOutOnMakerPSM,
+        ],
+      ],
+      [
+        SwapSide.BUY,
+        [
+          ContractMethod.swapExactAmountOut,
+          ContractMethod.swapExactAmountInOutOnMakerPSM,
+        ],
+      ],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it(`${side}:${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+
+          it(`${side}:${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+            await testE2E(
+              tokens[tokenBSymbol],
+              tokens[tokenASymbol],
+              holders[tokenBSymbol],
+              side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      }),
+    );
+  });
 });

package/src/dex/lite-psm/lite-psm.ts

@@ -4,9 +4,7 @@ import {
   Address,
   ExchangePrices,
   PoolPrices,
-  Log,
   AdapterExchangeParam,
-  SimpleExchangeParam,
   PoolLiquidity,
   Logger,
   NumberAsString,
@@ -32,7 +30,8 @@ import {
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import { LitePsmConfig } from './config';
-import PsmABI from '../../abi/lite-psm/psm.json';
+import DaiPsmABI from '../../abi/lite-psm/psm.json';
+import UsdsPsmABI from '../../abi/lite-psm/usdsPsm.json';
 import { BI_POWS } from '../../bigint-constants';
 import { SpecialDex } from '../../executor/types';
 import { hexConcat, hexZeroPad, hexlify } from '@ethersproject/bytes';
@@ -45,7 +44,8 @@ import { BigNumber } from 'ethers';
 import { LitePsmEventPool, getOnChainState } from './lite-psm-event-pool';
 import { extractReturnAmountPosition } from '../../executor/utils';
 
-const psmInterface = new Interface(PsmABI);
+const daiPsmInterface = new Interface(DaiPsmABI);
+const usdsPsmInterface = new Interface(UsdsPsmABI);
 const WAD = BI_POWS[18];
 
 const ceilDiv = (a: bigint, b: bigint) => (a + b - 1n) / b;
@@ -70,6 +70,8 @@ export class LitePsm
     dexKey: string,
     protected dexHelper: IDexHelper,
     protected dai: Token = LitePsmConfig[dexKey][network].dai,
+    protected usds: Token = LitePsmConfig[dexKey][network].usds,
+    protected usdsPsm: Address = LitePsmConfig[dexKey][network].usdsPsmAddress,
     protected vatAddress: Address = LitePsmConfig[dexKey][network].vatAddress,
     protected poolConfigs: PoolConfig[] = LitePsmConfig[dexKey][network].pools,
   ) {
@@ -123,6 +125,8 @@ export class LitePsm
     return (
       (srcAddress === this.dai.address && this.eventPools[destAddress]) ||
       (destAddress === this.dai.address && this.eventPools[srcAddress]) ||
+      (srcAddress === this.usds.address && this.eventPools[destAddress]) ||
+      (destAddress === this.usds.address && this.eventPools[srcAddress]) ||
       null
     );
   }
@@ -153,7 +157,7 @@ export class LitePsm
   }
 
   computePrices(
-    isSrcDai: boolean,
+    isDestGem: boolean,
     to18ConversionFactor: bigint,
     side: SwapSide,
     amounts: bigint[],
@@ -168,7 +172,7 @@ export class LitePsm
 
     return amounts.map(a => {
       if (side === SwapSide.SELL) {
-        if (isSrcDai) {
+        if (isDestGem) {
           const gemAmt18 = (a * WAD) / (WAD + poolState.tout);
           if (buyGemCheck(gemAmt18)) return gemAmt18 / to18ConversionFactor;
         } else {
@@ -177,7 +181,7 @@ export class LitePsm
             return gemAmt18 - (gemAmt18 * poolState.tin) / WAD;
         }
       } else {
-        if (isSrcDai) {
+        if (isDestGem) {
           const gemAmt18 = to18ConversionFactor * a;
           if (buyGemCheck(gemAmt18))
             return gemAmt18 + (gemAmt18 * poolState.tout) / WAD;
@@ -214,33 +218,39 @@ export class LitePsm
       (side === SwapSide.SELL ? srcToken : destToken).decimals,
     );
 
-    const isSrcDai = srcToken.address.toLowerCase() === this.dai.address;
-    const gem = isSrcDai ? destToken : srcToken;
+    const srcLower = srcToken.address.toLowerCase();
+    const isSrcDai = srcLower === this.dai.address;
+    const isDaiSwap =
+      isSrcDai || destToken.address.toLowerCase() === this.dai.address;
+
+    const isDestGem = isSrcDai || srcLower === this.usds.address;
+
+    const gem = isDestGem ? destToken : srcToken;
     const toll =
-      (side === SwapSide.SELL && isSrcDai) ||
-      (side === SwapSide.BUY && !isSrcDai)
+      (side === SwapSide.SELL && isDestGem) ||
+      (side === SwapSide.BUY && !isDestGem)
         ? poolState.tout
         : poolState.tin;
 
     const [unit, ...prices] = this.computePrices(
-      isSrcDai,
+      isDestGem,
       eventPool.to18ConversionFactor,
       side,
       [unitVolume, ...amounts],
       poolState,
     );
 
+    const psm = isDaiSwap ? eventPool.poolConfig.psmAddress : this.usdsPsm;
     return [
       {
         prices,
         unit,
         data: {
           toll: toll.toString(),
-          psmAddress: eventPool.poolConfig.psmAddress,
-          gemJoinAddress: eventPool.poolConfig.gemJoinAddress,
+          psmAddress: psm,
           gemDecimals: gem.decimals,
         },
-        poolAddresses: [eventPool.poolConfig.psmAddress],
+        poolAddresses: [psm],
         exchange: this.dexKey,
         gasCost: 50000,
         poolIdentifier,
@@ -270,10 +280,12 @@ export class LitePsm
     data: LitePsmData,
     side: SwapSide,
   ): { isGemSell: boolean; gemAmount: string } {
-    const isSrcDai = srcToken.toLowerCase() === this.dai.address;
+    const isDestGem =
+      srcToken.toLowerCase() === this.dai.address ||
+      srcToken.toLowerCase() === this.usds.address;
     const to18ConversionFactor = getBigIntPow(18 - data.gemDecimals);
     if (side === SwapSide.SELL) {
-      if (isSrcDai) {
+      if (isDestGem) {
         const gemAmt18 = (BigInt(srcAmount) * WAD) / (WAD + BigInt(data.toll));
         return {
           isGemSell: false,
@@ -283,7 +295,7 @@ export class LitePsm
         return { isGemSell: true, gemAmount: srcAmount };
       }
     } else {
-      if (isSrcDai) {
+      if (isDestGem) {
         return { isGemSell: false, gemAmount: destAmount };
       } else {
         const gemAmt = ceilDiv(
@@ -338,9 +350,7 @@ export class LitePsm
       isApproved = await this.dexHelper.augustusApprovals.hasApproval(
         options.executionContractAddress,
         srcToken.address,
-        srcToken.address.toLowerCase() === this.dai.address.toLowerCase()
-          ? optimalSwapExchange.data.psmAddress
-          : optimalSwapExchange.data.gemJoinAddress,
+        optimalSwapExchange.data.psmAddress,
       );
     }
 
@@ -370,10 +380,16 @@ export class LitePsm
       side,
     );
 
-    let exchangeData = psmInterface.encodeFunctionData(
-      isGemSell ? 'sellGem' : 'buyGem',
-      [recipient, gemAmount],
-    );
+    const isDaiSwap =
+      destToken.toLowerCase() === this.dai.address ||
+      srcToken.toLowerCase() === this.dai.address;
+
+    let exchangeData = (
+      isDaiSwap ? daiPsmInterface : usdsPsmInterface
+    ).encodeFunctionData(isGemSell ? 'sellGem' : 'buyGem', [
+      recipient,
+      gemAmount,
+    ]);
 
     // append toll and to18ConversionFactor & set specialDexFlag = SWAP_ON_MAKER_PSM to
     // - `buyGem` on Ex1 & Ex2
@@ -397,10 +413,14 @@ export class LitePsm
       exchangeData,
       targetExchange: data.psmAddress,
       specialDexFlag,
-      spender: isGemSell ? data.gemJoinAddress : data.psmAddress,
+      spender: data.psmAddress, // psm is the join for both dai and usds
       returnAmountPos:
         side === SwapSide.SELL && isGemSell
-          ? extractReturnAmountPosition(psmInterface, 'sellGem', 'daiOutWad')
+          ? extractReturnAmountPosition(
+              isDaiSwap ? daiPsmInterface : usdsPsmInterface,
+              'sellGem',
+              isDaiSwap ? 'daiOutWad' : 'usdsOutWad',
+            )
           : undefined,
     };
   }
@@ -453,7 +473,7 @@ export class LitePsm
       data.toll,
       to18ConversionFactor.toString(),
       data.psmAddress,
-      data.gemJoinAddress,
+      data.psmAddress,
       metadata,
       beneficiaryDirectionApproveFlag.toString(),
     ];
@@ -492,9 +512,10 @@ export class LitePsm
       );
     };
 
-    const isDai = _tokenAddress === this.dai.address;
+    const isDaiOrUsds =
+      _tokenAddress === this.dai.address || _tokenAddress === this.usds.address;
 
-    const validPoolConfigs = isDai
+    const validPoolConfigs = isDaiOrUsds
       ? this.poolConfigs
       : this.eventPools[_tokenAddress]
       ? [this.eventPools[_tokenAddress].poolConfig]
@@ -513,7 +534,7 @@ export class LitePsm
       exchange: this.dexKey,
       address: p.psmAddress,
       liquidityUSD: minLiq(poolStates[i], p.gem.decimals),
-      connectorTokens: [isDai ? p.gem : this.dai],
+      connectorTokens: isDaiOrUsds ? [p.gem] : [this.dai, this.usds],
     }));
   }
 }

package/src/dex/lite-psm/types.ts

@@ -10,7 +10,6 @@ export type PoolState = {
 
 export type LitePsmData = {
   psmAddress: Address;
-  gemJoinAddress: Address;
   gemDecimals: number;
   toll: string;
   isApproved?: boolean;
@@ -18,7 +17,6 @@ export type LitePsmData = {
 
 export type PoolConfig = {
   gem: Token;
-  gemJoinAddress: Address; // dai liquidity
   pocketAddress: Address; // gem liquidity
   psmAddress: Address;
   identifier: string; // bytes32 of pool identifier (Eg. bytes32("PSM-USDC-A"))
@@ -26,6 +24,8 @@ export type PoolConfig = {
 
 export type DexParams = {
   dai: Token;
+  usds: Token;
+  usdsPsmAddress: Address;
   vatAddress: Address;
   pools: PoolConfig[];
 };
@@ -38,6 +38,7 @@ export type LitePsmParams = [
   toll: NumberAsString,
   to18ConversionFactor: NumberAsString,
   exchange: Address,
+  // psm (exchange) is the join for both dai and usds
   gemJoinAddress: Address,
   metadata: string,
   beneficiaryDirectionApproveFlag: NumberAsString,

package/src/dex/spark/config.ts

@@ -2,6 +2,9 @@ import { SparkParams } from './types';
 import { DexConfigMap } from '../../types';
 import { Network } from '../../constants';
 import { SwapSide } from '@paraswap/core';
+import PotAbi from '../../abi/maker-psm/pot.json';
+import SavingsUSDSAbi from '../../abi/sdai/SavingsUSDS.abi.json';
+import { Interface } from '@ethersproject/abi';
 
 export const SDaiConfig: DexConfigMap<SparkParams> = {
   Spark: {
@@ -9,6 +12,27 @@ export const SDaiConfig: DexConfigMap<SparkParams> = {
       sdaiAddress: '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
       daiAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
       potAddress: '0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7',
+      savingsRate: {
+        symbol: 'dsr',
+        // bytes32 repr of "dsr" string
+        topic:
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(PotAbi),
+    },
+  },
+  sUSDS: {
+    [Network.MAINNET]: {
+      sdaiAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // sUSDS
+      daiAddress: '0xdC035D45d973E3EC169d2276DDab16f1e407384F', // USDS
+      potAddress: '0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD', // no separate pot, sUSDS is the pot
+      savingsRate: {
+        symbol: 'ssr',
+        // bytes32 repr of "ssr" string
+        topic:
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+      },
+      poolInterface: new Interface(SavingsUSDSAbi),
     },
   },
 };

package/src/dex/spark/scripts/validate-state.ts

@@ -72,6 +72,7 @@ async function isPoolStateEqualToReal(
     dexHelper.multiContract,
     potAddress,
     new Interface(PotAbi),
+    'dsr',
     blockNumber,
   );
 

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

@@ -26,17 +26,17 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
         ContractMethod.swapExactAmountIn,
       ],
     ],
     [
       SwapSide.BUY,
       [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
+        // ContractMethod.simpleBuy,
+        // ContractMethod.buy,
         ContractMethod.swapExactAmountOut,
       ],
     ],
@@ -80,10 +80,9 @@ function testForNetwork(
   });
 }
 
-describe('sDAI E2E', () => {
-  const dexKey = 'Spark';
-
-  describe('Mainnet', () => {
+describe('Spark E2E', () => {
+  describe('sDai', () => {
+    const dexKey = 'Spark';
     const network = Network.MAINNET;
 
     const tokenASymbol: string = 'DAI';
@@ -101,4 +100,24 @@ describe('sDAI E2E', () => {
       tokenBAmount,
     );
   });
+
+  describe('sUSDS', () => {
+    const dexKey = 'sUSDS';
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'USDS';
+    const tokenBSymbol: string = 'sUSDS';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
 });

package/src/dex/spark/spark-events.test.ts

@@ -12,41 +12,7 @@ import PotAbi from '../../abi/maker-psm/pot.json';
 import { Interface } from '@ethersproject/abi';
 import _ from 'lodash';
 
-/*
-  README
-  ======
-
-  This test script adds unit tests for SDai event based
-  system. This is done by fetching the state on-chain before the
-  event block, manually pushing the block logs to the event-subscriber,
-  comparing the local state with on-chain state.
-
-  Most of the logic for testing is abstracted by `testEventSubscriber`.
-  You need to do two things to make the tests work:
-
-  1. Fetch the block numbers where certain events were released. You
-  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
-  block numbers for different events. Make sure to get sufficient
-  number of blockNumbers to cover all possible cases for the event
-  mutations.
-
-  2. Complete the implementation for fetchPoolState function. The
-  function should fetch the on-chain state of the event subscriber
-  using just the blocknumber.
-
-  The template tests only include the test for a single event
-  subscriber. There can be cases where multiple event subscribers
-  exist for a single DEX. In such cases additional tests should be
-  added.
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-events.test.ts`
-
-  (This comment should be removed from the final implementation)
-*/
-
 jest.setTimeout(50 * 1000);
-const dexKey = 'Spark';
 const network = Network.MAINNET;
 
 async function fetchPoolState(
@@ -56,7 +22,8 @@ async function fetchPoolState(
   return sdaiPool.generateState(blockNumber);
 }
 
-describe('SDai Event', function () {
+describe('SDai', function () {
+  const dexKey = 'Spark';
   const blockNumbers: { [eventName: string]: number[] } = {
     drip: [19827559, 19827524, 19827163, 19827124, 19827000, 19826892],
     // TODO: no matching logs, you have to manually call "file"
@@ -69,33 +36,81 @@ describe('SDai Event', function () {
     potAddress: SDaiConfig[dexKey][network].potAddress,
   };
 
-  describe('SDaiPool', function () {
-    Object.keys(blockNumbers).forEach((event: string) => {
-      blockNumbers[event].forEach((blockNumber: number) => {
-        it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
-          const dexHelper = new DummyDexHelper(network);
-          const logger = dexHelper.getLogger(dexKey);
-
-          const sdaiPool = new SparkSDaiEventPool(
-            dexKey,
-            `dai-sdai-pool`,
-            dexHelper,
-            addresses.potAddress,
-            new Interface(PotAbi),
-            logger,
-          );
-
-          await sdaiPool.initialize(blockNumber);
-
-          await testEventSubscriber(
-            sdaiPool,
-            sdaiPool.addressesSubscribed,
-            (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
-            blockNumber,
-            `${dexKey}_${sdaiPool}`,
-            dexHelper.provider,
-          );
-        });
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  Object.keys(blockNumbers).forEach((event: string) => {
+    blockNumbers[event].forEach((blockNumber: number) => {
+      it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+        const dexHelper = new DummyDexHelper(network);
+        const logger = dexHelper.getLogger(dexKey);
+
+        const sdaiPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `dai-sdai-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x6473720000000000000000000000000000000000000000000000000000000000',
+          'dsr',
+        );
+
+        await sdaiPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sdaiPool,
+          sdaiPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sdaiPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sdaiPool}`,
+          dexHelper.provider,
+        );
+      });
+    });
+  });
+});
+
+describe('sUSDS', function () {
+  const dexKey = 'sUSDS';
+  const blockNumbers: { [eventName: string]: number[] } = {
+    drip: [20812786, 20812797, 20813343, 20813668, 20814065, 20814418],
+  };
+
+  const addresses: { [contract: string]: string } = {
+    potAddress: SDaiConfig[dexKey][network].potAddress,
+  };
+
+  const potIface = SDaiConfig[dexKey][network].poolInterface;
+
+  Object.keys(blockNumbers).forEach((event: string) => {
+    blockNumbers[event].forEach((blockNumber: number) => {
+      it(`Should return the correct state after the ${blockNumber}:${event}`, async function () {
+        const dexHelper = new DummyDexHelper(network);
+        const logger = dexHelper.getLogger(dexKey);
+
+        const sUSDSPool = new SparkSDaiEventPool(
+          dexKey,
+          network,
+          `usds-susds-pool`,
+          dexHelper,
+          addresses.potAddress,
+          potIface,
+          logger,
+          '0x7373720000000000000000000000000000000000000000000000000000000000',
+          'ssr',
+        );
+
+        await sUSDSPool.initialize(blockNumber);
+
+        await testEventSubscriber(
+          sUSDSPool,
+          sUSDSPool.addressesSubscribed,
+          (_blockNumber: number) => fetchPoolState(sUSDSPool, _blockNumber),
+          blockNumber,
+          `${dexKey}_${sUSDSPool}`,
+          dexHelper.provider,
+        );
       });
     });
   });